diff --git a/Android.mk b/Android.mk
new file mode 100644
index 0000000..b306ea7
--- /dev/null
+++ b/Android.mk
@@ -0,0 +1,112 @@
+LOCAL_PATH := $(call my-dir)
+LLVM_ROOT_PATH := external/llvm/llvm
+
+# Shared library for target
+# ========================================================
+include $(CLEAR_VARS)
+LOCAL_PRELINK_MODULE := false
+LOCAL_MODULE := libbcc
+LOCAL_SRC_FILES :=	\
+	bcc.cpp	\
+	bcc_runtime.c	\
+	runtime/lib/arm/adddf3vfp.S	\
+	runtime/lib/arm/addsf3vfp.S	\
+	runtime/lib/arm/divdf3vfp.S	\
+	runtime/lib/arm/divsf3vfp.S	\
+	runtime/lib/arm/eqdf2vfp.S	\
+	runtime/lib/arm/eqsf2vfp.S	\
+	runtime/lib/arm/extendsfdf2vfp.S	\
+	runtime/lib/arm/fixdfsivfp.S	\
+	runtime/lib/arm/fixsfsivfp.S	\
+	runtime/lib/arm/fixunsdfsivfp.S	\
+	runtime/lib/arm/fixunssfsivfp.S	\
+	runtime/lib/arm/floatsidfvfp.S	\
+	runtime/lib/arm/floatsisfvfp.S	\
+	runtime/lib/arm/floatunssidfvfp.S	\
+	runtime/lib/arm/floatunssisfvfp.S	\
+	runtime/lib/arm/gedf2vfp.S	\
+	runtime/lib/arm/gesf2vfp.S	\
+	runtime/lib/arm/gtdf2vfp.S	\
+	runtime/lib/arm/gtsf2vfp.S	\
+	runtime/lib/arm/ledf2vfp.S	\
+	runtime/lib/arm/lesf2vfp.S	\
+	runtime/lib/arm/ltdf2vfp.S	\
+	runtime/lib/arm/ltsf2vfp.S	\
+	runtime/lib/arm/muldf3vfp.S	\
+	runtime/lib/arm/mulsf3vfp.S	\
+	runtime/lib/arm/nedf2vfp.S	\
+	runtime/lib/arm/negdf2vfp.S	\
+	runtime/lib/arm/negsf2vfp.S	\
+	runtime/lib/arm/nesf2vfp.S	\
+	runtime/lib/arm/subdf3vfp.S	\
+	runtime/lib/arm/subsf3vfp.S	\
+	runtime/lib/arm/truncdfsf2vfp.S	\
+	runtime/lib/arm/unorddf2vfp.S	\
+	runtime/lib/arm/unordsf2vfp.S	#\
+#	disassembler/arm-dis.c	\
+#	disassembler/dis-asm.c 
+
+LOCAL_STATIC_LIBRARIES :=	\
+	libLLVMARMCodeGen	\
+	libLLVMARMInfo	\
+	libLLVMBitReader	\
+	libLLVMSelectionDAG	\
+	libLLVMAsmPrinter	\
+	libLLVMCodeGen	\
+	libLLVMJIT	\
+	libLLVMTarget	\
+	libLLVMMC	\
+	libLLVMScalarOpts	\
+	libLLVMTransformUtils	\
+	libLLVMCore	\
+	libLLVMSupport	\
+	libLLVMSystem	\
+	libLLVMAnalysis
+
+LOCAL_SHARED_LIBRARIES := libdl libcutils libstlport
+
+LOCAL_C_INCLUDES :=	\
+	$(LOCAL_PATH)/include $(LOCAL_PATH)/disassembler
+
+#LOCAL_CFLAGS := -DUSE_DISASSEMBLER
+
+include $(LLVM_ROOT_PATH)/llvm-device-build.mk
+include $(BUILD_SHARED_LIBRARY)
+
+# Shared library for host
+# ========================================================
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := libbcc
+LOCAL_SRC_FILES := bcc.cpp bcc_runtime.c
+
+LOCAL_STATIC_LIBRARIES :=	\
+	libcutils	\
+	libLLVMX86CodeGen	\
+	libLLVMX86Info	\
+	libLLVMBitReader	\
+	libLLVMSelectionDAG	\
+	libLLVMAsmPrinter	\
+	libLLVMCodeGen	\
+	libLLVMJIT	\
+	libLLVMTarget	\
+	libLLVMMC	\
+	libLLVMScalarOpts	\
+	libLLVMTransformUtils	\
+	libLLVMCore	\
+	libLLVMSupport	\
+	libLLVMSystem	\
+	libLLVMAnalysis
+
+LOCAL_LDLIBS := -ldl -lpthread
+
+LOCAL_C_INCLUDES :=	\
+	$(LOCAL_PATH)/include
+
+include $(LLVM_ROOT_PATH)/llvm-host-build.mk
+include $(BUILD_HOST_SHARED_LIBRARY)
+
+# Build children
+# ========================================================
+
+include $(call all-makefiles-under,$(LOCAL_PATH))
diff --git a/bcc.cpp b/bcc.cpp
new file mode 100644
index 0000000..95c8700
--- /dev/null
+++ b/bcc.cpp
@@ -0,0 +1,2948 @@
+/*
+ * Bitcode compiler (bcc) for Android:
+ * This is an eager-compilation JIT running on Android.
+ *
+ */
+
+#define LOG_TAG "bcc"
+#include <cutils/log.h>
+
+#include <ctype.h>
+#include <errno.h>
+#include <limits.h>
+#include <stdarg.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <cutils/hashmap.h>
+
+#if defined(__i386__)
+#include <sys/mman.h>
+#endif
+
+#if defined(__arm__)
+  #define DEFAULT_ARM_CODEGEN
+  #define PROVIDE_ARM_CODEGEN
+#elif defined(__i386__)
+  #define DEFAULT_X86_CODEGEN
+  #define PROVIDE_X86_CODEGEN
+#elif defined(__x86_64__)
+  #define DEFAULT_X64_CODEGEN
+  #define PROVIDE_X64_CODEGEN
+#endif
+
+#if defined(FORCE_ARM_CODEGEN)
+  #define DEFAULT_ARM_CODEGEN
+  #undef DEFAULT_X86_CODEGEN
+  #undef DEFAULT_X64_CODEGEN
+  #define PROVIDE_ARM_CODEGEN
+  #undef PROVIDE_X86_CODEGEN
+  #undef PROVIDE_X64_CODEGEN
+#elif defined(FORCE_X86_CODEGEN)
+  #undef DEFAULT_ARM_CODEGEN
+  #define DEFAULT_X86_CODEGEN
+  #undef DEFAULT_X64_CODEGEN
+  #undef PROVIDE_ARM_CODEGEN
+  #define PROVIDE_X86_CODEGEN
+  #undef PROVIDE_X64_CODEGEN
+#elif defined(FORCE_X64_CODEGEN)
+  #undef DEFAULT_ARM_CODEGEN
+  #undef DEFAULT_X86_CODEGEN
+  #define DEFAULT_X64_CODEGEN
+  #undef PROVIDE_ARM_CODEGEN
+  #undef PROVIDE_X86_CODEGEN
+  #define PROVIDE_X64_CODEGEN
+#endif
+
+#if defined(DEFAULT_ARM_CODEGEN)
+  #define TARGET_TRIPLE_STRING    "armv7-none-linux-gnueabi"
+#elif defined(DEFAULT_X86_CODEGEN)
+  #define TARGET_TRIPLE_STRING    "i686-unknown-linux"
+#elif defined(DEFAULT_X64_CODEGEN)
+  #define  TARGET_TRIPLE_STRING   "x86_64-unknown-linux"
+#endif
+
+#if (defined(__VFP_FP__) && !defined(__SOFTFP__))
+#define ARM_USE_VFP
+#endif
+
+#include <bcc/bcc.h>
+#include "bcc_runtime.h"
+
+#define LOG_API(...) do {} while(0)
+// #define LOG_API(...) fprintf (stderr, __VA_ARGS__)
+
+#define LOG_STACK(...) do {} while(0)
+// #define LOG_STACK(...) fprintf (stderr, __VA_ARGS__)
+
+// #define PROVIDE_TRACE_CODEGEN
+
+#if defined(USE_DISASSEMBLER)
+#   include "disassembler/dis-asm.h"
+#   include <cstdio>
+#endif
+
+#include <set>
+#include <map>
+#include <list>
+#include <cmath>
+#include <string>
+#include <cstring>
+#include <algorithm>                    /* for std::reverse */
+
+// Basic
+#include "llvm/Use.h"                   /* for class llvm::Use */
+#include "llvm/User.h"                  /* for class llvm::User */
+#include "llvm/Module.h"                /* for class llvm::Module */
+#include "llvm/Function.h"              /* for class llvm::Function */
+#include "llvm/Constant.h"              /* for class llvm::Constant */
+#include "llvm/Constants.h"             /* for class llvm::ConstantExpr */
+#include "llvm/Instruction.h"           /* for class llvm::Instruction */
+#include "llvm/PassManager.h"           /* for class llvm::PassManager and
+                                         * llvm::FunctionPassManager
+                                         */
+#include "llvm/LLVMContext.h"           /* for llvm::getGlobalContext() */
+#include "llvm/GlobalValue.h"           /* for class llvm::GlobalValue */
+#include "llvm/Instructions.h"          /* for class llvm::CallInst */
+#include "llvm/OperandTraits.h"         /* for macro
+                                         * DECLARE_TRANSPARENT_OPERAND_ACCESSORS
+                                         * and macro
+                                         * DEFINE_TRANSPARENT_OPERAND_ACCESSORS
+                                         */
+#include "llvm/TypeSymbolTable.h"       /* for Type Reflection */
+
+// System
+#include "llvm/System/Host.h"           /* for function
+                                         * llvm::sys::isLittleEndianHost()
+                                         */
+#include "llvm/System/Memory.h"         /* for class llvm::sys::MemoryBlock */
+
+// ADT
+#include "llvm/ADT/APInt.h"             /* for class llvm::APInt */
+#include "llvm/ADT/APFloat.h"           /* for class llvm::APFloat */
+#include "llvm/ADT/DenseMap.h"          /* for class llvm::DenseMap */
+#include "llvm/ADT/ValueMap.h"          /* for class llvm::ValueMap and
+                                         * class llvm::ValueMapConfig
+                                         */
+#include "llvm/ADT/StringMap.h"         /* for class llvm::StringMap */
+#include "llvm/ADT/OwningPtr.h"         /* for class llvm::OwningPtr */
+#include "llvm/ADT/SmallString.h"       /* for class llvm::SmallString */
+
+// Target
+#include "llvm/Target/TargetData.h"     /* for class llvm::TargetData */
+#include "llvm/Target/TargetSelect.h"   /* for function
+                                         * LLVMInitialize[ARM|X86]
+                                         * [TargetInfo|Target]()
+                                         */
+#include "llvm/Target/TargetOptions.h"  /* for
+                                         *  variable bool llvm::UseSoftFloat
+                                         *  FloatABI::ABIType llvm::FloatABIType
+                                         *  bool llvm::NoZerosInBSS
+                                         */
+#include "llvm/Target/TargetMachine.h"  /* for class llvm::TargetMachine and
+                                         * llvm::TargetMachine::AssemblyFile
+                                         */
+#include "llvm/Target/TargetJITInfo.h"  /* for class llvm::TargetJITInfo */
+#include "llvm/Target/TargetRegistry.h" /* for class llvm::TargetRegistry */
+#include "llvm/Target/SubtargetFeature.h"
+                                        /* for class llvm::SubtargetFeature */
+
+// Support
+#include "llvm/Support/Casting.h"       /* for class cast<> */
+#include "llvm/Support/raw_ostream.h"   /* for class llvm::raw_ostream and
+                                         * llvm::raw_string_ostream
+                                         */
+#include "llvm/Support/ValueHandle.h"   /* for class AssertingVH<> */
+#include "llvm/Support/MemoryBuffer.h"  /* for class llvm::MemoryBuffer */
+#include "llvm/Support/ManagedStatic.h" /* for class llvm::llvm_shutdown */
+#include "llvm/Support/ErrorHandling.h" /* for function
+                                         * llvm::llvm_install_error_handler()
+                                         * and macro llvm_unreachable()
+                                         */
+#include "llvm/Support/StandardPasses.h"/* for function
+                                         * llvm::createStandardFunctionPasses()
+                                         * and
+                                         * llvm::createStandardModulePasses()
+                                         */
+#include "llvm/Support/FormattedStream.h"
+                                        /* for
+                                         * class llvm::formatted_raw_ostream
+                                         * llvm::formatted_raw_ostream::
+                                         * PRESERVE_STREAM
+                                         * llvm::FileModel::Error
+                                         */
+
+// Bitcode
+#include "llvm/Bitcode/ReaderWriter.h"  /* for function
+                                         * llvm::ParseBitcodeFile()
+                                         */
+
+// CodeGen
+#include "llvm/CodeGen/Passes.h"        /* for
+                                         * llvm::createLocalRegisterAllocator()
+                                         * and
+                                         * llvm::
+                                         * createLinearScanRegisterAllocator()
+                                         */
+#include "llvm/CodeGen/JITCodeEmitter.h"/* for class llvm::JITCodeEmitter */
+#include "llvm/CodeGen/MachineFunction.h"
+                                        /* for class llvm::MachineFunction */
+#include "llvm/CodeGen/RegAllocRegistry.h"
+                                        /* for class llvm::RegisterRegAlloc */
+#include "llvm/CodeGen/SchedulerRegistry.h"
+                                        /* for class llvm::RegisterScheduler
+                                         * and llvm::createDefaultScheduler()
+                                         */
+#include "llvm/CodeGen/MachineRelocation.h"
+                                        /* for class llvm::MachineRelocation */
+#include "llvm/CodeGen/MachineModuleInfo.h"
+                                        /* for class llvm::MachineModuleInfo */
+#include "llvm/CodeGen/MachineCodeEmitter.h"
+                                        /* for class llvm::MachineCodeEmitter */
+#include "llvm/CodeGen/MachineConstantPool.h"
+                                        /* for class llvm::MachineConstantPool
+                                         */
+#include "llvm/CodeGen/MachineJumpTableInfo.h"
+                                        /* for class llvm::MachineJumpTableInfo
+                                         */
+
+// ExecutionEngine
+#include "llvm/ExecutionEngine/GenericValue.h"
+                                        /* for struct llvm::GenericValue */
+#include "llvm/ExecutionEngine/JITMemoryManager.h"
+                                        /* for class llvm::JITMemoryManager */
+
+
+/*
+ * Compilation class that suits Android's needs.
+ * (Support: no argument passed, ...)
+ */
+
+namespace bcc {
+
+class Compiler {
+  /*
+   * This part is designed to be orthogonal to those exported bcc*() functions
+   * implementation and internal struct BCCscript.
+   */
+
+
+  /*********************************************
+   * The variable section below (e.g., Triple, CodeGenOptLevel)
+   * is initialized in GlobalInitialization()
+   */
+  static bool GlobalInitialized;
+
+  /*
+   * If given, this will be the name of the target triple to compile for.
+   * If not given, the initial values defined in this file will be used.
+   */
+  static std::string Triple;
+
+  static llvm::CodeGenOpt::Level CodeGenOptLevel;
+  /*
+   * End of section of GlobalInitializing variables
+   **********************************************/
+
+  /* If given, the name of the target CPU to generate code for. */
+  static std::string CPU;
+
+  /*
+   * The list of target specific features to enable or disable -- this should
+   * be a list of strings starting with '+' (enable) or '-' (disable).
+   */
+  static std::vector<std::string> Features;
+
+  struct Runtime {
+      const char* mName;
+      void* mPtr;
+  };
+  static struct Runtime Runtimes[];
+
+  static void GlobalInitialization() {
+    if(GlobalInitialized) return;
+
+    /* Set Triple, CPU and Features here */
+    Triple = TARGET_TRIPLE_STRING;
+
+#if defined(DEFAULT_ARM_CODEGEN) || defined(PROVIDE_ARM_CODEGEN)
+    LLVMInitializeARMTargetInfo();
+    LLVMInitializeARMTarget();
+#endif
+
+#if defined(DEFAULT_X86_CODEGEN) || defined(PROVIDE_X86_CODEGEN)
+    LLVMInitializeX86TargetInfo();
+    LLVMInitializeX86Target();
+#endif
+
+#if defined(DEFAULT_X64_CODEGEN) || defined(PROVIDE_X64_CODEGEN)
+    LLVMInitializeX86TargetInfo();
+    LLVMInitializeX86Target();
+#endif
+
+    /*
+     * -O0: llvm::CodeGenOpt::None
+     * -O1: llvm::CodeGenOpt::Less
+     * -O2: llvm::CodeGenOpt::Default
+     * -O3: llvm::CodeGenOpt::Aggressive
+     */
+    CodeGenOptLevel = llvm::CodeGenOpt::Aggressive;
+
+    /* Below are the global settings to LLVM */
+
+    /* Disable frame pointer elimination optimization */
+    llvm::NoFramePointerElim = false;
+
+    /*
+     * Use hardfloat ABI
+     *
+     * FIXME: Need to detect the CPU capability and decide whether to use
+     * softfp. To use softfp, change following 2 lines to
+     *
+     *  llvm::FloatABIType = llvm::FloatABI::Soft;
+     *  llvm::UseSoftFloat = true;
+     */
+    llvm::FloatABIType = llvm::FloatABI::Hard;
+    llvm::UseSoftFloat = false;
+
+    /*
+     * BCC needs all unknown symbols resolved at JIT/compilation time.
+     * So we don't need any dynamic relocation model.
+     */
+    llvm::TargetMachine::setRelocationModel(llvm::Reloc::Static);
+
+#ifdef DEFAULT_X64_CODEGEN
+    /* Data address in X86_64 architecture may reside in a far-away place */
+    llvm::TargetMachine::setCodeModel(llvm::CodeModel::Medium);
+#else
+    /*
+     * This is set for the linker (specify how large of the virtual addresses
+     * we can access for all unknown symbols.)
+    */
+    llvm::TargetMachine::setCodeModel(llvm::CodeModel::Small);
+#endif
+
+    /* Register the scheduler */
+    llvm::RegisterScheduler::setDefault(llvm::createDefaultScheduler);
+
+    /*
+     * Register allocation policy:
+     *  createLocalRegisterAllocator: fast but bad quality
+     *  createLinearScanRegisterAllocator: not so fast but good quality
+     */
+    llvm::RegisterRegAlloc::setDefault
+        ((CodeGenOptLevel == llvm::CodeGenOpt::None) ?
+         llvm::createLocalRegisterAllocator :
+         llvm::createLinearScanRegisterAllocator);
+
+    GlobalInitialized = true;
+    return;
+  }
+
+  static void LLVMErrorHandler(void *UserData, const std::string &Message) {
+    // std::string* Error = static_cast<std::string*>(UserData);
+    // Error->assign(Message);
+    // return;
+    fprintf(stderr, "%s\n", Message.c_str());
+    exit(1);
+  }
+
+  static const llvm::StringRef PragmaMetadataName;
+
+ private:
+  std::string mError;
+
+  inline bool hasError() const {
+    return !mError.empty();
+  }
+  inline void setError(const char* Error) {
+    mError.assign(Error);  // Copying
+    return;
+  }
+  inline void setError(const std::string& Error) {
+    mError = Error;
+    return;
+  }
+
+  typedef std::list< std::pair<std::string, std::string> > PragmaList;
+  PragmaList mPragmas;
+
+  /* Memory manager for the code reside in memory */
+  /*
+   * The memory for our code emitter is very simple and is conforming to the
+   * design decisions of Android RenderScript's Exection Environment:
+   *   The code, data, and symbol sizes are limited (currently 100KB.)
+   *
+   * It's very different from typical compiler, which has no limitation
+   * on the code size. How does code emitter know the size of the code
+   * it is about to emit? It does not know beforehand. We want to solve
+   * this without complicating the code emitter too much.
+   *
+   * We solve this by pre-allocating a certain amount of memory,
+   * and then start the code emission. Once the buffer overflows, the emitter
+   * simply discards all the subsequent emission but still has a counter
+   * on how many bytes have been emitted.
+
+   * So once the whole emission is done, if there's a buffer overflow,
+   * it re-allocates the buffer with enough size (based on the
+   *  counter from previous emission) and re-emit again.
+   */
+  class CodeMemoryManager : public llvm::JITMemoryManager {
+    /* {{{ */
+   private:
+    static const unsigned int MaxCodeSize = 100 * 1024; /* 100 KiB for code */
+    static const unsigned int MaxGOTSize = 1 * 1024;    /* 1 KiB for global
+                                                           offset table (GOT) */
+
+    /*
+     * Our memory layout is as follows:
+     *
+     *  The direction of arrows (-> and <-) shows memory's growth direction
+     *  when more space is needed.
+     *
+     * @mpCodeMem:
+     *  +--------------------------------------------------------------+
+     *  | Function Memory ... ->                <- ... Global/Stub/GOT |
+     *  +--------------------------------------------------------------+
+     *  |<------------------ Total: @MaxCodeSize KiB ----------------->|
+     *
+     *  Where size of GOT is @MaxGOTSize KiB.
+     *
+     * @mCurFuncMemIdx: The current index (starting from 0) of the last byte
+     *                    of function code's memoey usage
+     * @mCurGSGMemIdx: The current index (starting from 0) of the last byte
+     *                    of Global Stub/GOT's memory usage
+     *
+     */
+
+    intptr_t mCurFuncMemIdx;
+    intptr_t mCurGSGMemIdx;
+    llvm::sys::MemoryBlock* mpCodeMem;
+
+    /* GOT Base */
+    uint8_t* mpGOTBase;
+
+    typedef std::map<const llvm::Function*, pair<void* /* start address */,
+                                                 void* /* end address */>
+                     > FunctionMapTy;
+    FunctionMapTy mFunctionMap;
+
+    inline intptr_t getFreeMemSize() const {
+      return mCurGSGMemIdx - mCurFuncMemIdx;
+    }
+    inline uint8_t* getCodeMemBase() const {
+      return static_cast<uint8_t*>(mpCodeMem->base());
+    }
+
+    uint8_t* allocateGSGMemory(uintptr_t Size,
+                               unsigned Alignment = 1 /* no alignment */)
+    {
+      if(getFreeMemSize() < Size)
+        /* The code size excesses our limit */
+        return NULL;
+
+      if(Alignment == 0)
+        Alignment = 1;
+
+      uint8_t* result = getCodeMemBase() + mCurGSGMemIdx - Size;
+      result = (uint8_t*) (((intptr_t) result) & ~(intptr_t) (Alignment - 1));
+
+      mCurGSGMemIdx = result - getCodeMemBase();
+
+      return result;
+    }
+
+   public:
+    CodeMemoryManager() : mpCodeMem(NULL), mpGOTBase(NULL) {
+      reset();
+      std::string ErrMsg;
+      llvm::sys::MemoryBlock B = llvm::sys::Memory::
+          AllocateRWX(MaxCodeSize, NULL, &ErrMsg);
+      if(B.base() == 0)
+        llvm::llvm_report_error(
+            "Failed to allocate Memory for code emitter\n" + ErrMsg
+                                );
+      mpCodeMem = new llvm::sys::MemoryBlock(B.base(), B.size());
+
+      return;
+    }
+
+    /*
+     * setMemoryWritable - When code generation is in progress,
+     *  the code pages may need permissions changed.
+     */
+    void setMemoryWritable() {
+      llvm::sys::Memory::setWritable(*mpCodeMem);
+      return;
+    }
+
+    /*
+     * setMemoryExecutable - When code generation is done and we're ready to
+     *  start execution, the code pages may need permissions changed.
+     */
+    void setMemoryExecutable() {
+      llvm::sys::Memory::setExecutable(*mpCodeMem);
+      return;
+    }
+
+    /*
+     * setPoisonMemory - Setting this flag to true makes the memory manager
+     *  garbage values over freed memory.  This is useful for testing and
+     *  debugging, and is to be turned on by default in debug mode.
+     */
+    void setPoisonMemory(bool poison) {
+      /* no effect */
+      return;
+    }
+
+    /* Global Offset Table Management */
+
+    /*
+     * AllocateGOT - If the current table requires a Global Offset Table, this
+     *  method is invoked to allocate it.  This method is required to set HasGOT
+     *  to true.
+     */
+    void AllocateGOT() {
+      assert(mpGOTBase != NULL && "Cannot allocate the GOT multiple times");
+      mpGOTBase = allocateGSGMemory(MaxGOTSize);
+      HasGOT = true;
+      return;
+    }
+
+    /*
+     * getGOTBase - If this is managing a Global Offset Table, this method
+     *  should return a pointer to its base.
+     */
+    uint8_t* getGOTBase() const {
+      return mpGOTBase;
+    }
+
+    /* Main Allocation Functions */
+
+    /*
+     * startFunctionBody - When we start JITing a function, the JIT calls this
+     *  method to allocate a block of free RWX memory, which returns a pointer to
+     *  it.  If the JIT wants to request a block of memory of at least a certain
+     *  size, it passes that value as ActualSize, and this method returns a block
+     *  with at least that much space.  If the JIT doesn't know ahead of time how
+     *  much space it will need to emit the function, it passes 0 for the
+     *  ActualSize.  In either case, this method is required to pass back the size
+     *  of the allocated block through ActualSize.  The JIT will be careful to
+     *  not write more than the returned ActualSize bytes of memory.
+     */
+    uint8_t* startFunctionBody(const llvm::Function *F, uintptr_t &ActualSize) {
+      if(getFreeMemSize() < ActualSize)
+        /* The code size excesses our limit */
+        return NULL;
+
+      ActualSize = getFreeMemSize();
+      return (getCodeMemBase() + mCurFuncMemIdx);
+    }
+
+    /*
+     * allocateStub - This method is called by the JIT to allocate space for a
+     *  function stub (used to handle limited branch displacements) while it is
+     *  JIT compiling a function.  For example, if foo calls bar, and if bar
+     *  either needs to be lazily compiled or is a native function that exists
+     *  too
+     *  far away from the call site to work, this method will be used to make a
+     *  thunk for it.  The stub should be "close" to the current function body,
+     *  but should not be included in the 'actualsize' returned by
+     *  startFunctionBody.
+     */
+    uint8_t* allocateStub(const llvm::GlobalValue* F, unsigned StubSize,
+                          unsigned Alignment) {
+      return allocateGSGMemory(StubSize, Alignment);
+    }
+
+    /*
+     * endFunctionBody - This method is called when the JIT is done codegen'ing
+     *  the specified function.  At this point we know the size of the JIT
+     *  compiled function.  This passes in FunctionStart (which was returned by
+     *  the startFunctionBody method) and FunctionEnd which is a pointer to the
+     *  actual end of the function.  This method should mark the space allocated
+     *  and remember where it is in case the client wants to deallocate it.
+     */
+    void endFunctionBody(const llvm::Function* F, uint8_t* FunctionStart,
+                         uint8_t* FunctionEnd) {
+      assert(FunctionEnd > FunctionStart);
+      assert(FunctionStart == (getCodeMemBase() + mCurFuncMemIdx) &&
+             "Mismatched function start/end!");
+
+      /* Advance the pointer */
+      intptr_t FunctionCodeSize = FunctionEnd - FunctionStart;
+      assert(FunctionCodeSize <= getFreeMemSize() &&
+             "Code size excess the limitation!");
+      mCurFuncMemIdx += FunctionCodeSize;
+
+      /* Record there's a function in our memory start from @FunctionStart */
+      assert(mFunctionMap.find(F) == mFunctionMap.end() &&
+             "Function already emitted!");
+      mFunctionMap.insert( make_pair<const llvm::Function*, pair<void*, void*>
+                                    >(F, make_pair(FunctionStart, FunctionEnd))
+                           );
+
+      return;
+    }
+
+    /*
+     * allocateSpace - Allocate a (function code) memory block of the
+     *  given size.  This method cannot be called between
+     *  calls to startFunctionBody and endFunctionBody.
+     */
+    uint8_t* allocateSpace(intptr_t Size, unsigned Alignment) {
+      if(getFreeMemSize() < Size)
+        /* The code size excesses our limit */
+        return NULL;
+
+      if(Alignment == 0)
+        Alignment = 1;
+
+      uint8_t* result = getCodeMemBase() + mCurFuncMemIdx;
+      result = (uint8_t*) (((intptr_t) result + Alignment - 1) &
+                           ~(intptr_t) (Alignment - 1)
+                           );
+
+      mCurFuncMemIdx = (result + Size) - getCodeMemBase();
+
+      return result;
+    }
+
+    /* allocateGlobal - Allocate memory for a global. */
+    uint8_t* allocateGlobal(uintptr_t Size, unsigned Alignment) {
+      return allocateGSGMemory(Size, Alignment);
+    }
+
+    /*
+     * deallocateFunctionBody - Free the specified function body.  The argument
+     *  must be the return value from a call to startFunctionBody() that hasn't
+     *  been deallocated yet.  This is never called when the JIT is currently
+     *  emitting a function.
+     */
+    void deallocateFunctionBody(void *Body) {
+      /* linear search */
+      FunctionMapTy::iterator I;
+      for(I = mFunctionMap.begin();
+          I != mFunctionMap.end();
+          I++)
+        if(I->second.first == Body)
+          break;
+
+      assert(I != mFunctionMap.end() && "Memory is never allocated!");
+
+      /* free the memory */
+      uint8_t* FunctionStart = (uint8_t*) I->second.first;
+      uint8_t* FunctionEnd = (uint8_t*) I->second.second;
+      intptr_t SizeNeedMove = (getCodeMemBase() + mCurFuncMemIdx) - FunctionEnd;
+
+      assert(SizeNeedMove >= 0 &&
+             "Internal error: CodeMemoryManager::mCurFuncMemIdx may not"
+             " be correctly calculated!");
+
+      if(SizeNeedMove > 0)
+        /* there's data behind deallocating function */
+        ::memmove(FunctionStart, FunctionEnd, SizeNeedMove);
+      mCurFuncMemIdx -= (FunctionEnd - FunctionStart);
+
+      return;
+    }
+
+    /*
+     * startExceptionTable - When we finished JITing the function, if exception
+     *  handling is set, we emit the exception table.
+     */
+    uint8_t* startExceptionTable(const llvm::Function* F, uintptr_t &ActualSize)
+    {
+      assert(false && "Exception is not allowed in our language specification");
+      return NULL;
+    }
+
+    /*
+     * endExceptionTable - This method is called when the JIT is done emitting
+     *  the exception table.
+     */
+    void endExceptionTable(const llvm::Function *F, uint8_t *TableStart,
+                           uint8_t *TableEnd, uint8_t* FrameRegister) {
+      assert(false && "Exception is not allowed in our language specification");
+      return;
+    }
+
+    /*
+     * deallocateExceptionTable - Free the specified exception table's memory.
+     *  The argument must be the return value from a call to
+     *  startExceptionTable()
+     *  that hasn't been deallocated yet.  This is never called when the JIT is
+     *  currently emitting an exception table.
+     */
+    void deallocateExceptionTable(void *ET) {
+      assert(false && "Exception is not allowed in our language specification");
+      return;
+    }
+
+    /* Below are the methods we create */
+    void reset() {
+      mpGOTBase = NULL;
+      HasGOT = false;
+
+      mCurFuncMemIdx = 0;
+      mCurGSGMemIdx = MaxCodeSize - 1;
+
+      mFunctionMap.clear();
+
+      return;
+    }
+
+    ~CodeMemoryManager() {
+      if(mpCodeMem != NULL)
+        llvm::sys::Memory::ReleaseRWX(*mpCodeMem);
+      return;
+    }
+    /* }}} */
+  };  /* End of class CodeMemoryManager */
+
+  /* The memory manager for code emitter */
+  llvm::OwningPtr<CodeMemoryManager> mCodeMemMgr;
+  CodeMemoryManager* createCodeMemoryManager() {
+    mCodeMemMgr.reset(new CodeMemoryManager());
+    return mCodeMemMgr.get();
+  }
+
+  /* Code emitter */
+  class CodeEmitter : public llvm::JITCodeEmitter {
+    /* {{{ */
+   public:
+    typedef llvm::DenseMap<const llvm::GlobalValue*, void*> GlobalAddressMapTy;
+    typedef GlobalAddressMapTy::const_iterator global_addresses_const_iterator;
+
+   private:
+    CodeMemoryManager* mpMemMgr;
+
+    /* The JITInfo for the target we are compiling to */
+    llvm::TargetJITInfo* mpTJI;
+
+    const llvm::TargetData* mpTD;
+
+    /*
+     * MBBLocations - This vector is a mapping from MBB ID's to their address.
+     *  It is filled in by the StartMachineBasicBlock callback and queried by
+     *  the getMachineBasicBlockAddress callback.
+     */
+    std::vector<uintptr_t> mMBBLocations;
+
+    /* ConstantPool - The constant pool for the current function. */
+    llvm::MachineConstantPool* mpConstantPool;
+
+    /* ConstantPoolBase - A pointer to the first entry in the constant pool. */
+    void *mpConstantPoolBase;
+
+    /* ConstPoolAddresses - Addresses of individual constant pool entries. */
+    llvm::SmallVector<uintptr_t, 8> mConstPoolAddresses;
+
+    /* JumpTable - The jump tables for the current function. */
+    llvm::MachineJumpTableInfo *mpJumpTable;
+
+    /* JumpTableBase - A pointer to the first entry in the jump table. */
+    void *mpJumpTableBase;
+
+    /*
+     * When outputting a function stub in the context of some other function, we
+     *  save BufferBegin/BufferEnd/CurBufferPtr here.
+     */
+    uint8_t *mpSavedBufferBegin, *mpSavedBufferEnd, *mpSavedCurBufferPtr;
+
+    /* Relocations - These are the relocations that the function needs,
+       as emitted. */
+    std::vector<llvm::MachineRelocation> mRelocations;
+
+    /* LabelLocations - This vector is a mapping from Label ID's to their
+       address. */
+    std::vector<uintptr_t> mLabelLocations;
+
+    class EmittedFunctionCode {
+     public:
+      void* FunctionBody;  // Beginning of the function's allocation.
+      void* Code;  // The address the function's code actually starts at.
+      int Size; // The size of the function code
+
+      EmittedFunctionCode() : FunctionBody(NULL), Code(NULL) { return; }
+    };
+    EmittedFunctionCode* mpCurEmitFunction;
+
+    typedef std::map<const std::string, EmittedFunctionCode*
+                     > EmittedFunctionsMapTy;
+    EmittedFunctionsMapTy mEmittedFunctions;
+
+    /* MMI - Machine module info for exception informations */
+    llvm::MachineModuleInfo* mpMMI;
+
+    GlobalAddressMapTy mGlobalAddressMap;
+
+    /*
+     * UpdateGlobalMapping - Replace an existing mapping for GV with a new
+     *  address.  This updates both maps as required.  If "Addr" is null, the
+     *  entry for the global is removed from the mappings.
+     */
+    void* UpdateGlobalMapping(const llvm::GlobalValue *GV, void *Addr) {
+      if(Addr == NULL) {
+        /* Removing mapping */
+        GlobalAddressMapTy::iterator I = mGlobalAddressMap.find(GV);
+        void *OldVal;
+
+        if(I == mGlobalAddressMap.end())
+          OldVal = NULL;
+        else {
+          OldVal = I->second;
+          mGlobalAddressMap.erase(I);
+        }
+
+        return OldVal;
+      }
+
+      void*& CurVal = mGlobalAddressMap[GV];
+      void* OldVal = CurVal;
+
+      CurVal = Addr;
+
+      return OldVal;
+    }
+
+    /*
+     * AddGlobalMapping - Tell the execution engine that the specified global is
+     *  at the specified location.  This is used internally as functions are
+     *  JIT'd
+     *  and as global variables are laid out in memory.
+     */
+    void AddGlobalMapping(const llvm::GlobalValue *GV, void *Addr) {
+      void*& CurVal = mGlobalAddressMap[GV];
+      assert((CurVal == 0 || Addr == 0) && "GlobalMapping already established!");
+      CurVal = Addr;
+      return;
+    }
+
+    /*
+     * GetPointerToGlobalIfAvailable - This returns the address of the specified
+     *  global value if it is has already been codegen'd,
+     *  otherwise it returns null.
+     */
+    void* GetPointerToGlobalIfAvailable(const llvm::GlobalValue* GV) const {
+      GlobalAddressMapTy::const_iterator I = mGlobalAddressMap.find(GV);
+      return ((I != mGlobalAddressMap.end()) ? I->second : NULL);
+    }
+
+    unsigned int GetConstantPoolSizeInBytes(llvm::MachineConstantPool* MCP) {
+      const std::vector<llvm::MachineConstantPoolEntry>& Constants =
+          MCP->getConstants();
+
+      if(Constants.empty())
+        return 0;
+
+      unsigned int Size = 0;
+      for(int i=0;i<Constants.size();i++) {
+        llvm::MachineConstantPoolEntry CPE = Constants[i];
+        unsigned int AlignMask = CPE.getAlignment() - 1;
+        Size = (Size + AlignMask) & ~AlignMask;
+        const llvm::Type* Ty = CPE.getType();
+        Size += mpTD->getTypeAllocSize(Ty);
+      }
+
+      return Size;
+    }
+
+    /*
+     * This function converts a Constant* into a GenericValue. The interesting
+     *  part is if C is a ConstantExpr.
+     */
+    void GetConstantValue(const llvm::Constant *C, llvm::GenericValue& Result) {
+      if(C->getValueID() == llvm::Value::UndefValueVal)
+        return;
+      else if(C->getValueID() == llvm::Value::ConstantExprVal) {
+        const llvm::ConstantExpr* CE = (llvm::ConstantExpr*) C;
+        const llvm::Constant* Op0 = CE->getOperand(0);
+
+        switch(CE->getOpcode()) {
+          case llvm::Instruction::GetElementPtr:
+            {
+              /* Compute the index */
+              llvm::SmallVector<llvm::Value*, 8> Indices(CE->op_begin() + 1,
+                                                         CE->op_end());
+              uint64_t Offset = mpTD->getIndexedOffset(Op0->getType(),
+                                                       &Indices[0],
+                                                       Indices.size());
+
+              GetConstantValue(Op0, Result);
+              Result.PointerVal = (char*) Result.PointerVal + Offset;
+
+              return;
+            }
+            break;
+
+          case llvm::Instruction::Trunc:
+            {
+              uint32_t BitWidth =
+                  llvm::cast<llvm::IntegerType>(CE->getType())->getBitWidth();
+
+              GetConstantValue(Op0, Result);
+              Result.IntVal = Result.IntVal.trunc(BitWidth);
+
+              return;
+            }
+            break;
+
+          case llvm::Instruction::ZExt:
+            {
+              uint32_t BitWidth =
+                  llvm::cast<llvm::IntegerType>(CE->getType())->getBitWidth();
+
+              GetConstantValue(Op0, Result);
+              Result.IntVal = Result.IntVal.zext(BitWidth);
+
+              return;
+            }
+            break;
+
+          case llvm::Instruction::SExt:
+            {
+              uint32_t BitWidth =
+                  llvm::cast<llvm::IntegerType>(CE->getType())->getBitWidth();
+
+              GetConstantValue(Op0, Result);
+              Result.IntVal = Result.IntVal.sext(BitWidth);
+
+              return;
+            }
+            break;
+
+
+          case llvm::Instruction::FPTrunc:
+            {
+              /* FIXME long double */
+              GetConstantValue(Op0, Result);
+              Result.FloatVal = float(Result.DoubleVal);
+              return;
+            }
+            break;
+
+
+          case llvm::Instruction::FPExt:
+            {
+              /* FIXME long double */
+              GetConstantValue(Op0, Result);
+              Result.DoubleVal = double(Result.FloatVal);
+              return;
+            }
+            break;
+
+
+          case llvm::Instruction::UIToFP:
+            {
+              GetConstantValue(Op0, Result);
+              if(CE->getType()->isFloatTy())
+                Result.FloatVal = float(Result.IntVal.roundToDouble());
+              else if(CE->getType()->isDoubleTy())
+                Result.DoubleVal = Result.IntVal.roundToDouble();
+              else if(CE->getType()->isX86_FP80Ty()) {
+                const uint64_t zero[] = { 0, 0 };
+                llvm::APFloat apf = llvm::APFloat(llvm::APInt(80, 2, zero));
+                apf.convertFromAPInt(Result.IntVal,
+                                     false,
+                                     llvm::APFloat::rmNearestTiesToEven);
+                Result.IntVal = apf.bitcastToAPInt();
+              }
+              return;
+            }
+            break;
+
+          case llvm::Instruction::SIToFP:
+            {
+              GetConstantValue(Op0, Result);
+              if(CE->getType()->isFloatTy())
+                Result.FloatVal = float(Result.IntVal.signedRoundToDouble());
+              else if(CE->getType()->isDoubleTy())
+                Result.DoubleVal = Result.IntVal.signedRoundToDouble();
+              else if(CE->getType()->isX86_FP80Ty()) {
+                const uint64_t zero[] = { 0, 0 };
+                llvm::APFloat apf = llvm::APFloat(llvm::APInt(80, 2, zero));
+                apf.convertFromAPInt(Result.IntVal,
+                                     true,
+                                     llvm::APFloat::rmNearestTiesToEven);
+                Result.IntVal = apf.bitcastToAPInt();
+              }
+              return;
+            }
+            break;
+
+            /* double->APInt conversion handles sign */
+          case llvm::Instruction::FPToUI:
+          case llvm::Instruction::FPToSI:
+            {
+              uint32_t BitWidth =
+                  llvm::cast<llvm::IntegerType>(CE->getType())->getBitWidth();
+
+              GetConstantValue(Op0, Result);
+              if(Op0->getType()->isFloatTy())
+                Result.IntVal =
+                 llvm::APIntOps::RoundFloatToAPInt(Result.FloatVal, BitWidth);
+              else if(Op0->getType()->isDoubleTy())
+                Result.IntVal =
+                 llvm::APIntOps::RoundDoubleToAPInt(Result.DoubleVal, BitWidth);
+              else if(Op0->getType()->isX86_FP80Ty()) {
+                llvm::APFloat apf = llvm::APFloat(Result.IntVal);
+                uint64_t v;
+                bool ignored;
+                apf.convertToInteger(&v,
+                                     BitWidth,
+                                     CE->getOpcode()
+                                      == llvm::Instruction::FPToSI,
+                                     llvm::APFloat::rmTowardZero,
+                                     &ignored);
+                Result.IntVal = v; // endian?
+              }
+              return;
+            }
+            break;
+
+          case llvm::Instruction::PtrToInt:
+            {
+              uint32_t PtrWidth = mpTD->getPointerSizeInBits();
+
+              GetConstantValue(Op0, Result);
+              Result.IntVal = llvm::APInt(PtrWidth, uintptr_t
+                                          (Result.PointerVal));
+
+              return;
+            }
+            break;
+
+          case llvm::Instruction::IntToPtr:
+            {
+              uint32_t PtrWidth = mpTD->getPointerSizeInBits();
+
+              GetConstantValue(Op0, Result);
+              if(PtrWidth != Result.IntVal.getBitWidth())
+                Result.IntVal = Result.IntVal.zextOrTrunc(PtrWidth);
+              assert(Result.IntVal.getBitWidth() <= 64 && "Bad pointer width");
+
+              Result.PointerVal = llvm::PointerTy
+                  (uintptr_t(Result.IntVal.getZExtValue()));
+
+              return;
+            }
+            break;
+
+          case llvm::Instruction::BitCast:
+            {
+              GetConstantValue(Op0, Result);
+              const llvm::Type* DestTy = CE->getType();
+
+              switch(Op0->getType()->getTypeID()) {
+                case llvm::Type::IntegerTyID:
+                  assert(DestTy->isFloatingPointTy() && "invalid bitcast");
+                  if(DestTy->isFloatTy())
+                    Result.FloatVal = Result.IntVal.bitsToFloat();
+                  else if(DestTy->isDoubleTy())
+                    Result.DoubleVal = Result.IntVal.bitsToDouble();
+                  break;
+
+                case llvm::Type::FloatTyID:
+                  assert(DestTy->isIntegerTy(32) && "Invalid bitcast");
+                  Result.IntVal.floatToBits(Result.FloatVal);
+                  break;
+
+                case llvm::Type::DoubleTyID:
+                  assert(DestTy->isIntegerTy(64) && "Invalid bitcast");
+                  Result.IntVal.doubleToBits(Result.DoubleVal);
+                  break;
+
+                case llvm::Type::PointerTyID:
+                  assert(DestTy->isPointerTy() && "Invalid bitcast");
+                  break; // getConstantValue(Op0) above already converted it
+
+                default:
+                  llvm_unreachable("Invalid bitcast operand");
+                  break;
+              }
+
+              return;
+            }
+            break;
+
+          case llvm::Instruction::Add:
+          case llvm::Instruction::FAdd:
+          case llvm::Instruction::Sub:
+          case llvm::Instruction::FSub:
+          case llvm::Instruction::Mul:
+          case llvm::Instruction::FMul:
+          case llvm::Instruction::UDiv:
+          case llvm::Instruction::SDiv:
+          case llvm::Instruction::URem:
+          case llvm::Instruction::SRem:
+          case llvm::Instruction::And:
+          case llvm::Instruction::Or:
+          case llvm::Instruction::Xor:
+            {
+              llvm::GenericValue LHS, RHS;
+              GetConstantValue(Op0, LHS);
+              GetConstantValue(CE->getOperand(1), RHS);
+
+              switch(Op0->getType()->getTypeID()) {
+                case llvm::Type::IntegerTyID:
+                  switch (CE->getOpcode()) {
+                    case llvm::Instruction::Add:
+                      Result.IntVal = LHS.IntVal + RHS.IntVal;
+                      break;
+                    case llvm::Instruction::Sub:
+                      Result.IntVal = LHS.IntVal - RHS.IntVal;
+                      break;
+                    case llvm::Instruction::Mul:
+                      Result.IntVal = LHS.IntVal * RHS.IntVal;
+                      break;
+                    case llvm::Instruction::UDiv:
+                      Result.IntVal = LHS.IntVal.udiv(RHS.IntVal);
+                      break;
+                    case llvm::Instruction::SDiv:
+                      Result.IntVal = LHS.IntVal.sdiv(RHS.IntVal);
+                      break;
+                    case llvm::Instruction::URem:
+                      Result.IntVal = LHS.IntVal.urem(RHS.IntVal);
+                      break;
+                    case llvm::Instruction::SRem:
+                      Result.IntVal = LHS.IntVal.srem(RHS.IntVal);
+                      break;
+                    case llvm::Instruction::And:
+                      Result.IntVal = LHS.IntVal & RHS.IntVal;
+                      break;
+                    case llvm::Instruction::Or:
+                      Result.IntVal = LHS.IntVal | RHS.IntVal;
+                      break;
+                    case llvm::Instruction::Xor:
+                      Result.IntVal = LHS.IntVal ^ RHS.IntVal;
+                      break;
+                    default:
+                      llvm_unreachable("Invalid integer opcode");
+                      break;
+                  }
+                  break;
+
+                case llvm::Type::FloatTyID:
+                  switch (CE->getOpcode()) {
+                    case llvm::Instruction::FAdd:
+                      Result.FloatVal = LHS.FloatVal + RHS.FloatVal;
+                      break;
+                    case llvm::Instruction::FSub:
+                      Result.FloatVal = LHS.FloatVal - RHS.FloatVal;
+                      break;
+                    case llvm::Instruction::FMul:
+                      Result.FloatVal = LHS.FloatVal * RHS.FloatVal;
+                      break;
+                    case llvm::Instruction::FDiv:
+                      Result.FloatVal = LHS.FloatVal / RHS.FloatVal;
+                      break;
+                    case llvm::Instruction::FRem:
+                      Result.FloatVal = ::fmodf(LHS.FloatVal, RHS.FloatVal);
+                      break;
+                    default:
+                      llvm_unreachable("Invalid float opcode");
+                      break;
+                  }
+                  break;
+
+                case llvm::Type::DoubleTyID:
+                  switch (CE->getOpcode()) {
+                    case llvm::Instruction::FAdd:
+                      Result.DoubleVal = LHS.DoubleVal + RHS.DoubleVal;
+                      break;
+                    case llvm::Instruction::FSub:
+                      Result.DoubleVal = LHS.DoubleVal - RHS.DoubleVal;
+                      break;
+                    case llvm::Instruction::FMul:
+                      Result.DoubleVal = LHS.DoubleVal * RHS.DoubleVal;
+                      break;
+                    case llvm::Instruction::FDiv:
+                      Result.DoubleVal = LHS.DoubleVal / RHS.DoubleVal;
+                      break;
+                    case llvm::Instruction::FRem:
+                      Result.DoubleVal = ::fmod(LHS.DoubleVal, RHS.DoubleVal);
+                      break;
+                    default:
+                      llvm_unreachable("Invalid double opcode");
+                      break;
+                  }
+                  break;
+
+                case llvm::Type::X86_FP80TyID:
+                case llvm::Type::PPC_FP128TyID:
+                case llvm::Type::FP128TyID:
+                  {
+                    llvm::APFloat apfLHS = llvm::APFloat(LHS.IntVal);
+                    switch (CE->getOpcode()) {
+                      case llvm::Instruction::FAdd:
+                        apfLHS.add(llvm::APFloat(RHS.IntVal),
+                                   llvm::APFloat::rmNearestTiesToEven);
+                        break;
+                      case llvm::Instruction::FSub:
+                        apfLHS.subtract(llvm::APFloat(RHS.IntVal),
+                                        llvm::APFloat::rmNearestTiesToEven);
+                        break;
+                      case llvm::Instruction::FMul:
+                        apfLHS.multiply(llvm::APFloat(RHS.IntVal),
+                                        llvm::APFloat::rmNearestTiesToEven);
+                        break;
+                      case llvm::Instruction::FDiv:
+                        apfLHS.divide(llvm::APFloat(RHS.IntVal),
+                                      llvm::APFloat::rmNearestTiesToEven);
+                        break;
+                      case llvm::Instruction::FRem:
+                        apfLHS.mod(llvm::APFloat(RHS.IntVal),
+                                   llvm::APFloat::rmNearestTiesToEven);
+                        break;
+                      default:
+                        llvm_unreachable("Invalid long double opcode");
+                        llvm_unreachable(0);
+                        break;
+                    }
+
+                    Result.IntVal = apfLHS.bitcastToAPInt();
+                  }
+                  break;
+
+                default:
+                  llvm_unreachable("Bad add type!");
+                  break;
+              } /* End switch(Op0->getType()->getTypeID()) */
+
+              return;
+            }
+
+          default:
+            break;
+        }   /* End switch(CE->getOpcode()) */
+
+        std::string msg;
+        llvm::raw_string_ostream Msg(msg);
+        Msg << "ConstantExpr not handled: " << *CE;
+        llvm::llvm_report_error(Msg.str());
+      } /* C->getValueID() == llvm::Value::ConstantExprVal */
+
+      switch (C->getType()->getTypeID()) {
+        case llvm::Type::FloatTyID:
+          Result.FloatVal = llvm::cast<llvm::ConstantFP>(C)
+              ->getValueAPF().convertToFloat();
+          break;
+
+        case llvm::Type::DoubleTyID:
+          Result.DoubleVal = llvm::cast<llvm::ConstantFP>(C)
+              ->getValueAPF().convertToDouble();
+          break;
+
+        case llvm::Type::X86_FP80TyID:
+        case llvm::Type::FP128TyID:
+        case llvm::Type::PPC_FP128TyID:
+          Result.IntVal = llvm::cast <llvm::ConstantFP>(C)
+              ->getValueAPF().bitcastToAPInt();
+          break;
+
+        case llvm::Type::IntegerTyID:
+          Result.IntVal = llvm::cast<llvm::ConstantInt>(C)
+              ->getValue();
+          break;
+
+        case llvm::Type::PointerTyID:
+          switch(C->getValueID()) {
+            case llvm::Value::ConstantPointerNullVal:
+              Result.PointerVal = NULL;
+              break;
+
+            case llvm::Value::FunctionVal:
+              {
+                const llvm::Function* F = (llvm::Function*) C;
+                Result.PointerVal = GetPointerToFunctionOrStub
+                    (const_cast<llvm::Function*>(F)
+                     );
+              }
+              break;
+
+            case llvm::Value::GlobalVariableVal:
+              {
+                const llvm::GlobalVariable* GV = (llvm::GlobalVariable*) C;
+                Result.PointerVal = GetOrEmitGlobalVariable
+                    (const_cast<llvm::GlobalVariable*>(GV)
+                     );
+              }
+              break;
+
+            case llvm::Value::BlockAddressVal:
+              {
+                // const llvm::BlockAddress* BA = (llvm::BlockAddress*) C;
+                // Result.PointerVal = getPointerToBasicBlock
+                //    (const_cast<llvm::BasicBlock*>(BA->getBasicBlock()));
+                assert(false && "JIT does not support address-of-label yet!");
+              }
+              break;
+
+            default:
+              llvm_unreachable("Unknown constant pointer type!");
+              break;
+          }
+          break;
+
+        default:
+          std::string msg;
+          llvm::raw_string_ostream Msg(msg);
+          Msg << "ERROR: Constant unimplemented for type: " << *C->getType();
+          llvm::llvm_report_error(Msg.str());
+          break;
+      }
+
+      return;
+    }
+
+    /*
+     * StoreValueToMemory -
+     *   Stores the data in @Val of type @Ty at address @Addr.
+     */
+    void StoreValueToMemory(const llvm::GenericValue& Val, void* Addr,
+                            const llvm::Type *Ty) {
+      const unsigned int StoreBytes = mpTD->getTypeStoreSize(Ty);
+
+      switch(Ty->getTypeID()) {
+        case llvm::Type::IntegerTyID:
+          {
+            const llvm::APInt& IntVal = Val.IntVal;
+            assert((IntVal.getBitWidth() + 7) / 8 >= StoreBytes &&
+                   "Integer too small!");
+
+            uint8_t *Src = (uint8_t*) IntVal.getRawData();
+
+            if(llvm::sys::isLittleEndianHost()) {
+              /*
+               * Little-endian host - the source is ordered from LSB to MSB.
+               * Order the destination from LSB to MSB: Do a straight copy.
+               */
+              memcpy(Addr, Src, StoreBytes);
+            } else {
+              /*
+               * Big-endian host - the source is an array of 64 bit words
+               * ordered from LSW to MSW.
+               *
+               * Each word is ordered from MSB to LSB.
+               *
+               * Order the destination from MSB to LSB:
+               *  Reverse the word order, but not the bytes in a word.
+               */
+              unsigned int i = StoreBytes;
+              while(i > sizeof(uint64_t)) {
+                i -= sizeof(uint64_t);
+                memcpy((uint8_t*) Addr + i, Src, sizeof(uint64_t));
+                Src += sizeof(uint64_t);
+              }
+
+              memcpy(Addr, Src + sizeof(uint64_t) - i, i);
+            }
+          }
+          break;
+
+        case llvm::Type::FloatTyID:
+          {
+            *((float*) Addr) = Val.FloatVal;
+          }
+          break;
+
+        case llvm::Type::DoubleTyID:
+          {
+            *((double*) Addr) = Val.DoubleVal;
+          }
+          break;
+
+        case llvm::Type::X86_FP80TyID:
+          {
+            memcpy(Addr, Val.IntVal.getRawData(), 10);
+          }
+          break;
+
+        case llvm::Type::PointerTyID:
+          {
+            /*
+             * Ensure 64 bit target pointers are fully
+             * initialized on 32 bit hosts.
+             */
+            if(StoreBytes != sizeof(llvm::PointerTy))
+              memset(Addr, 0, StoreBytes);
+            *((llvm::PointerTy*) Addr) = Val.PointerVal;
+          }
+          break;
+
+        default:
+          break;
+      }
+
+      if(llvm::sys::isLittleEndianHost() != mpTD->isLittleEndian())
+        std::reverse((uint8_t*) Addr, (uint8_t*) Addr + StoreBytes);
+
+      return;
+    }
+
+    /*
+     * InitializeConstantToMemory -
+     *   Recursive function to apply a @Constant value into the
+     *   specified memory location @Addr.
+     */
+    void InitializeConstantToMemory(const llvm::Constant *C, void *Addr) {
+      switch(C->getValueID()) {
+        case llvm::Value::UndefValueVal:
+          // Nothing to do
+          break;
+
+        case llvm::Value::ConstantVectorVal:
+          {
+            // dynamic cast may hurt performance
+            const llvm::ConstantVector* CP = (llvm::ConstantVector*) C;
+
+            unsigned int ElementSize = mpTD->getTypeAllocSize
+                (CP->getType()->getElementType());
+
+            for(int i=0;i<CP->getNumOperands();i++)
+              InitializeConstantToMemory(CP->getOperand(i),
+                                         (char*) Addr + i * ElementSize);
+          }
+          break;
+
+        case llvm::Value::ConstantAggregateZeroVal:
+          memset(Addr, 0, (size_t) mpTD->getTypeAllocSize(C->getType()));
+          break;
+
+        case llvm::Value::ConstantArrayVal:
+          {
+            const llvm::ConstantArray* CPA = (llvm::ConstantArray*) C;
+            unsigned int ElementSize = mpTD->getTypeAllocSize
+                (CPA->getType()->getElementType());
+
+            for(int i=0;i<CPA->getNumOperands();i++)
+              InitializeConstantToMemory(CPA->getOperand(i),
+                                         (char*) Addr + i * ElementSize);
+          }
+          break;
+
+        case llvm::Value::ConstantStructVal:
+          {
+            const llvm::ConstantStruct* CPS = (llvm::ConstantStruct*) C;
+            const llvm::StructLayout* SL = mpTD->getStructLayout
+                (llvm::cast<llvm::StructType>(CPS->getType()));
+
+            for(int i=0;i<CPS->getNumOperands();i++)
+              InitializeConstantToMemory(CPS->getOperand(i),
+                                         (char*) Addr +
+                                         SL->getElementOffset(i));
+          }
+          break;
+
+        default:
+          {
+            if(C->getType()->isFirstClassType()) {
+              llvm::GenericValue Val;
+              GetConstantValue(C, Val);
+              StoreValueToMemory(Val, Addr, C->getType());
+            } else
+              llvm_unreachable
+                  ("Unknown constant type to initialize memory with!");
+          }
+          break;
+      }
+
+      return;
+    }
+
+    void emitConstantPool(llvm::MachineConstantPool *MCP) {
+      if(mpTJI->hasCustomConstantPool())
+        return;
+
+      /*
+       * Constant pool address resolution is handled by the target itself in ARM
+       * (TargetJITInfo::hasCustomConstantPool() return true).
+       */
+#if !defined(PROVIDE_ARM_CODEGEN)
+      const std::vector<llvm::MachineConstantPoolEntry>& Constants =
+          MCP->getConstants();
+
+      if(Constants.empty())
+        return;
+
+      unsigned Size = GetConstantPoolSizeInBytes(MCP);
+      unsigned Align = MCP->getConstantPoolAlignment();
+
+      mpConstantPoolBase = allocateSpace(Size, Align);
+      mpConstantPool = MCP;
+
+      if(mpConstantPoolBase == NULL)
+        return; /* out of memory */
+
+      unsigned Offset = 0;
+      for(int i=0;i<Constants.size();i++) {
+        llvm::MachineConstantPoolEntry CPE = Constants[i];
+        unsigned AlignMask = CPE.getAlignment() - 1;
+        Offset = (Offset + AlignMask) & ~AlignMask;
+
+        uintptr_t CAddr = (uintptr_t) mpConstantPoolBase + Offset;
+        mConstPoolAddresses.push_back(CAddr);
+
+        if(CPE.isMachineConstantPoolEntry())
+          llvm::llvm_report_error
+              ("Initialize memory with machine specific constant pool"
+               " entry has not been implemented!");
+
+        InitializeConstantToMemory(CPE.Val.ConstVal, (void*) CAddr);
+
+        const llvm::Type *Ty = CPE.Val.ConstVal->getType();
+        Offset += mpTD->getTypeAllocSize(Ty);
+      }
+#endif
+      return;
+    }
+
+    void initJumpTableInfo(llvm::MachineJumpTableInfo *MJTI) {
+      if(mpTJI->hasCustomJumpTables())
+        return;
+
+      const std::vector<llvm::MachineJumpTableEntry>& JT =
+          MJTI->getJumpTables();
+      if(JT.empty())
+        return;
+
+      unsigned NumEntries = 0;
+      for(int i=0;i<JT.size();i++)
+        NumEntries += JT[i].MBBs.size();
+
+      unsigned EntrySize = MJTI->getEntrySize(*mpTD);
+
+      mpJumpTable = MJTI;;
+      mpJumpTableBase = allocateSpace(NumEntries * EntrySize,
+                                      MJTI->getEntryAlignment(*mpTD));
+
+      return;
+    }
+
+    void emitJumpTableInfo(llvm::MachineJumpTableInfo *MJTI) {
+      if(mpTJI->hasCustomJumpTables())
+        return;
+
+      const std::vector<llvm::MachineJumpTableEntry>& JT =
+          MJTI->getJumpTables();
+      if(JT.empty() || mpJumpTableBase == 0)
+        return;
+
+      assert((llvm::TargetMachine::getRelocationModel() == llvm::Reloc::Static)
+             && "Cross JIT'ing?");
+      assert(MJTI->getEntrySize(*mpTD) == sizeof(void*) && "Cross JIT'ing?");
+
+      /*
+       * For each jump table, map each target in the jump table to the
+       *  address of an emitted MachineBasicBlock.
+       */
+      intptr_t *SlotPtr = (intptr_t*) mpJumpTableBase;
+      for(int i=0;i<JT.size();i++) {
+        const std::vector<llvm::MachineBasicBlock*>& MBBs = JT[i].MBBs;
+        /*
+         * Store the address of the basic block for this jump table slot in the
+         * memory we allocated for the jump table in 'initJumpTableInfo'
+         */
+        for(int j=0;j<MBBs.size();j++)
+          *SlotPtr++ = getMachineBasicBlockAddress(MBBs[j]);
+      }
+    }
+
+    void* GetPointerToGlobal(llvm::GlobalValue* V, void* Reference,
+                             bool MayNeedFarStub) {
+      switch(V->getValueID()) {
+        case llvm::Value::FunctionVal:
+          {
+            llvm::Function* F = (llvm::Function*) V;
+            void* FnStub = GetLazyFunctionStubIfAvailable(F);
+
+            if(FnStub)
+              /*
+               * Return the function stub if it's already created.
+               * We do this first so that:
+               *   we're returning the same address for the function
+               *   as any previous call.
+               *
+               *  TODO: Yes, this is wrong. The lazy stub isn't guaranteed
+               *  to be close enough to call.
+               */
+              return FnStub;
+
+            /*
+             * If we know the target can handle arbitrary-distance calls, try to
+             *  return a direct pointer.
+             */
+            if(!MayNeedFarStub) {
+              /* If we have code, go ahead and return that. */
+              if(void* ResultPtr = GetPointerToGlobalIfAvailable(F))
+                return ResultPtr;
+
+              /*
+               * x86_64 architecture may encounter the bug
+               *  http://hlvm.llvm.org/bugs/show_bug.cgi?id=5201
+               *  which generate instruction "call" instead of "callq".
+               *
+               * And once the real address of stub is
+               *  greater than 64-bit long, the replacement will truncate
+               *  to 32-bit resulting a serious problem.
+               */
+#if !defined(__x86_64__)
+              /*
+               * If this is an external function pointer,
+               * we can force the JIT to
+               *  'compile' it, which really just adds it to the map.
+               */
+              if(F->isDeclaration() || F->hasAvailableExternallyLinkage())
+                return GetPointerToFunction(F, /* AbortOnFailure */true);
+#endif
+            }
+
+            /*
+             * Otherwise, we may need a to emit a stub, and, conservatively, we
+             *  always do so.
+             */
+            return GetLazyFunctionStub(F);
+          }
+          break;
+
+        case llvm::Value::GlobalVariableVal:
+          return GetOrEmitGlobalVariable((llvm::GlobalVariable*) V);
+          break;
+
+        case llvm::Value::GlobalAliasVal:
+          {
+            llvm::GlobalAlias* GA = (llvm::GlobalAlias*) V;
+            const llvm::GlobalValue* GV = GA->resolveAliasedGlobal(false);
+
+            switch(GV->getValueID()) {
+              case llvm::Value::FunctionVal:
+                /* FIXME: is there's any possibility that the function
+                   is not code-gen'd? */
+                return GetPointerToFunction(
+                    const_cast<llvm::Function*>((const llvm::Function*) GV),
+                    /* AbortOnFailure */true
+                                            );
+                break;
+
+              case llvm::Value::GlobalVariableVal:
+                {
+                  if(void* p = mGlobalAddressMap[GV])
+                    return p;
+
+                  llvm::GlobalVariable* GVar = (llvm::GlobalVariable*) GV;
+                  EmitGlobalVariable(GVar);
+
+                  return mGlobalAddressMap[GV];
+                }
+                break;
+
+              case llvm::Value::GlobalAliasVal:
+                assert(false && "Alias should be resolved ultimately!");
+                break;
+            }
+          }
+          break;
+
+        default:
+          break;
+      }
+
+      llvm_unreachable("Unknown type of global value!");
+
+    }
+
+    /*
+     * GetPointerToFunctionOrStub - If the specified function has been
+     *  code-gen'd, return a pointer to the function.
+     * If not, compile it, or use
+     *  a stub to implement lazy compilation if available.
+     */
+    void* GetPointerToFunctionOrStub(llvm::Function* F) {
+      /*
+       * If we have already code generated the function,
+       * just return the address.
+       */
+      if(void* Addr = GetPointerToGlobalIfAvailable(F))
+        return Addr;
+
+      /* Get a stub if the target supports it. */
+      return GetLazyFunctionStub(F);
+    }
+
+    typedef llvm::DenseMap<llvm::Function*, void*> FunctionToLazyStubMapTy;
+    FunctionToLazyStubMapTy mFunctionToLazyStubMap;
+
+    void* GetLazyFunctionStubIfAvailable(llvm::Function* F) {
+      return mFunctionToLazyStubMap.lookup(F);
+    }
+
+    std::set<llvm::Function*> PendingFunctions;
+    void* GetLazyFunctionStub(llvm::Function* F) {
+      /* If we already have a lazy stub for this function, recycle it. */
+      void*& Stub = mFunctionToLazyStubMap[F];
+      if(Stub)
+        return Stub;
+
+      /*
+       * In any cases, we should NOT resolve function at runtime
+       *  (though we are able to).
+       *  We resolve this right now.
+       */
+      void* Actual = NULL;
+      if(F->isDeclaration() || F->hasAvailableExternallyLinkage())
+        Actual = GetPointerToFunction(F, /* AbortOnFailure */true);
+
+      /*
+       * Codegen a new stub, calling the actual address of
+       * the external function, if it was resolved.
+       */
+      llvm::TargetJITInfo::StubLayout SL = mpTJI->getStubLayout();
+      startGVStub(F, SL.Size, SL.Alignment);
+      Stub = mpTJI->emitFunctionStub(F, Actual, *this);
+      finishGVStub();
+
+      /*
+       * We really want the address of the stub in the GlobalAddressMap
+       * for the JIT, not the address of the external function.
+       */
+      UpdateGlobalMapping(F, Stub);
+
+      if(!Actual)
+        PendingFunctions.insert(F);
+      else
+        Disassembler(F->getNameStr() + " (stub)",
+                     (uint8_t*) Stub, SL.Size, (uintptr_t) Stub);
+
+      return Stub;
+    }
+
+    /* Our resolver to undefined symbol */
+    BCCSymbolLookupFn mpSymbolLookupFn;
+    void* mpSymbolLookupContext;
+
+    void* GetPointerToFunction(llvm::Function* F, bool AbortOnFailure) {
+      void* Addr = GetPointerToGlobalIfAvailable(F);
+      if(Addr)
+        return Addr;
+
+      assert((F->isDeclaration() || F->hasAvailableExternallyLinkage()) &&
+             "Internal error: only external defined function routes here!");
+
+      /* Handle the failure resolution by ourselves. */
+      Addr = GetPointerToNamedSymbol(F->getName().str().c_str(),
+                                     /* AbortOnFailure */ false);
+
+      /*
+       * If we resolved the symbol to a null address (eg. a weak external)
+       *  return a null pointer let the application handle it.
+       */
+      if(Addr == NULL)
+        if(AbortOnFailure)
+          llvm::llvm_report_error
+              ("Could not resolve external function address: " + F->getName()
+               );
+        else
+          return NULL;
+
+      AddGlobalMapping(F, Addr);
+
+      return Addr;
+    }
+
+    void* GetPointerToNamedSymbol(const std::string& Name,
+                                  bool AbortOnFailure) {
+      if(void* Addr = FindRuntimeFunction(Name.c_str()))
+        return Addr;
+
+      if(mpSymbolLookupFn)
+        if(void* Addr = mpSymbolLookupFn(mpSymbolLookupContext, Name.c_str()))
+          return Addr;
+
+      if(AbortOnFailure)
+        llvm::llvm_report_error("Program used external symbol '" + Name +
+                                "' which could not be resolved!");
+
+      return NULL;
+    }
+
+    /*
+     * GetOrEmitGlobalVariable - Return the address of the specified global
+     *  variable, possibly emitting it to memory if needed.  This is used by the
+     *  Emitter.
+     */
+    void* GetOrEmitGlobalVariable(const llvm::GlobalVariable *GV) {
+      void* Ptr = GetPointerToGlobalIfAvailable(GV);
+      if(Ptr)
+        return Ptr;
+
+      if(GV->isDeclaration() || GV->hasAvailableExternallyLinkage()) {
+        /* If the global is external, just remember the address. */
+        Ptr = GetPointerToNamedSymbol(GV->getName().str(), true);
+        AddGlobalMapping(GV, Ptr);
+      } else {
+        /* If the global hasn't been emitted to memory yet,
+           allocate space and emit it into memory. */
+        Ptr = GetMemoryForGV(GV);
+        AddGlobalMapping(GV, Ptr);
+        EmitGlobalVariable(GV);
+      }
+
+      return Ptr;
+    }
+
+    /*
+     * GetMemoryForGV - This method abstracts memory allocation of global
+     *  variable so that the JIT can allocate thread local variables depending
+     *  on the target.
+     */
+    void* GetMemoryForGV(const llvm::GlobalVariable* GV) {
+      char* Ptr;
+
+      const llvm::Type* GlobalType = GV->getType()->getElementType();
+      size_t S = mpTD->getTypeAllocSize(GlobalType);
+      size_t A = mpTD->getPreferredAlignment(GV);
+
+      if(GV->isThreadLocal()) {
+        /*
+         * We can support TLS by
+         *
+         *  Ptr = TJI.allocateThreadLocalMemory(S);
+         *
+         * But I tend not to .
+         * (should we disable this in the front-end (i.e. slang)?).
+         */
+        llvm::llvm_report_error
+            ("Compilation of Thread Local Storage (TLS) is disabled!");
+
+      } else if(mpTJI->allocateSeparateGVMemory()) {
+        /*
+         * On the Apple's ARM target (such as iPhone),
+         *  the global variable should be
+         *  placed in separately allocated heap memory rather than in the same
+         *  code memory.
+         *  The question is, how about the Android?
+         */
+        if(A <= 8) {
+          Ptr = (char*) malloc(S);
+        } else {
+          /*
+           * Allocate (S + A) bytes of memory,
+           * then use an aligned pointer within that space.
+           */
+          Ptr = (char*) malloc(S + A);
+          unsigned int MisAligned = ((intptr_t) Ptr & (A - 1));
+          Ptr = Ptr + (MisAligned ? (A - MisAligned) : 0);
+        }
+      } else {
+        Ptr = (char*) allocateGlobal(S, A);
+      }
+
+      return Ptr;
+    }
+
+    void EmitGlobalVariable(const llvm::GlobalVariable *GV) {
+      void* GA = GetPointerToGlobalIfAvailable(GV);
+
+      if(GV->isThreadLocal())
+        llvm::llvm_report_error("We don't support Thread Local Storage (TLS)!");
+
+      if(GA == NULL) {
+        /* If it's not already specified, allocate memory for the global. */
+        GA = GetMemoryForGV(GV);
+        AddGlobalMapping(GV, GA);
+      }
+
+      InitializeConstantToMemory(GV->getInitializer(), GA);
+
+      /* You can do some statistics on global variable here */
+      return;
+    }
+
+    typedef std::map<llvm::AssertingVH<llvm::GlobalValue>, void*
+                     > GlobalToIndirectSymMapTy;
+    GlobalToIndirectSymMapTy GlobalToIndirectSymMap;
+
+    void* GetPointerToGVIndirectSym(llvm::GlobalValue *V, void *Reference) {
+      /*
+       * Make sure GV is emitted first, and create a stub containing the fully
+       *  resolved address.
+       */
+      void* GVAddress = GetPointerToGlobal(V, Reference, false);
+
+      /* If we already have a stub for this global variable, recycle it. */
+      void*& IndirectSym = GlobalToIndirectSymMap[V];
+      /* Otherwise, codegen a new indirect symbol. */
+      if(!IndirectSym)
+        IndirectSym = mpTJI->emitGlobalValueIndirectSym(V, GVAddress, *this);
+
+      return IndirectSym;
+    }
+
+    /*
+     * ExternalFnToStubMap - This is the equivalent of FunctionToLazyStubMap
+     *  for external functions.
+     *
+     *  TODO: Of course, external functions don't need a lazy stub.
+     *        It's actually
+     *        here to make it more likely that far calls succeed, but no single
+     *        stub can guarantee that. I'll remove this in a subsequent checkin
+     *        when I actually fix far calls. (comment from LLVM source)
+     */
+    std::map<void*, void*> ExternalFnToStubMap;
+
+    /*
+     * GetExternalFunctionStub - Return a stub for the function at the
+     *  specified address.
+     */
+    void* GetExternalFunctionStub(void* FnAddr) {
+      void*& Stub = ExternalFnToStubMap[FnAddr];
+      if(Stub)
+        return Stub;
+
+      llvm::TargetJITInfo::StubLayout SL = mpTJI->getStubLayout();
+      startGVStub(0, SL.Size, SL.Alignment);
+      Stub = mpTJI->emitFunctionStub(0, FnAddr, *this);
+      finishGVStub();
+
+      return Stub;
+    }
+
+
+    void Disassembler(const std::string& Name, uint8_t* Start,
+                      size_t Length, uintptr_t PC) {
+#if defined(USE_DISASSEMBLER)
+      FILE* out = stdout;
+
+      fprintf(out, "JIT: Disassembled code: %s\n", Name.c_str());
+
+      disassemble_info disasm_info;
+      int (*print_insn)(bfd_vma pc, disassemble_info *info);
+
+      INIT_DISASSEMBLE_INFO(disasm_info, out, fprintf);
+
+      disasm_info.buffer = Start;
+      disasm_info.buffer_vma = (bfd_vma) (uintptr_t) Start;
+      disasm_info.buffer_length = Length;
+      disasm_info.endian = BFD_ENDIAN_LITTLE;
+
+#if defined(DEFAULT_X86_CODEGEN)
+      disasm_info.mach = bfd_mach_i386_i386;
+      print_insn = print_insn_i386;
+#elif defined(DEFAULT_ARM_CODEGEN)
+      print_insn = print_insn_arm;
+#elif defined(DEFAULT_X64_CODEGEN)
+      disasm_info.mach = bfd_mach_x86_64;
+      print_insn = print_insn_i386;
+#else
+#error "Unknown target for disassembler"
+#endif
+
+#if defined(DEFAULT_X64_CODEGEN)
+#   define TARGET_FMT_lx "%llx"
+#else
+#   define TARGET_FMT_lx "%08x"
+#endif
+      int Count;
+      for( ; Length > 0; PC += Count, Length -= Count) {
+        fprintf(out, "\t0x" TARGET_FMT_lx ": ", (bfd_vma) PC);
+        Count = print_insn(PC, &disasm_info);
+        fprintf(out, "\n");
+      }
+
+      fprintf(out, "\n");
+#undef TARGET_FMT_lx
+
+#endif  /* USE_DISASSEMBLER */
+      return;
+    }
+
+   public:
+    /* Will take the ownership of @MemMgr */
+    CodeEmitter(CodeMemoryManager* pMemMgr) :
+        mpMemMgr(pMemMgr),
+        mpTJI(NULL),
+        mpTD(NULL),
+        mpCurEmitFunction(NULL),
+        mpConstantPool(NULL),
+        mpJumpTable(NULL),
+        mpMMI(NULL),
+        mpSymbolLookupFn(NULL),
+        mpSymbolLookupContext(NULL)
+    {
+      return;
+    }
+
+    inline global_addresses_const_iterator global_address_begin() const {
+      return mGlobalAddressMap.begin();
+    }
+    inline global_addresses_const_iterator global_address_end() const {
+      return mGlobalAddressMap.end();
+    }
+
+    void registerSymbolCallback(BCCSymbolLookupFn pFn, BCCvoid* pContext) {
+      mpSymbolLookupFn = pFn;
+      mpSymbolLookupContext = pContext;
+      return;
+    }
+
+    void setTargetMachine(llvm::TargetMachine& TM) {
+      /* set TargetJITInfo */
+      mpTJI = TM.getJITInfo();
+      /* set TargetData */
+      mpTD = TM.getTargetData();
+
+      /*
+        if(mpTJI->needsGOT())
+        mpMemMgr->AllocateGOT();  // however,
+        // both X86 and ARM target don't need GOT
+        // (mpTJI->needsGOT() always returns false)
+      */
+      assert(!mpTJI->needsGOT() && "We don't support GOT needed target!");
+
+      return;
+    }
+
+    /*
+     * startFunction - This callback is invoked when the specified function is
+     *  about to be code generated.  This initializes the BufferBegin/End/Ptr
+     *  fields.
+     */
+    void startFunction(llvm::MachineFunction &F) {
+      uintptr_t ActualSize = 0;
+
+      mpMemMgr->setMemoryWritable();
+
+      /*
+       * BufferBegin, BufferEnd and CurBufferPtr
+       *  are all inherited from class MachineCodeEmitter,
+       *  which is the super class of the class JITCodeEmitter.
+       *
+       * BufferBegin/BufferEnd - Pointers to the start and end of the memory
+       *  allocated for this code buffer.
+       *
+       * CurBufferPtr - Pointer to the next byte of memory to fill when emitting
+       *  code.
+       *  This is guranteed to be in the range [BufferBegin,BufferEnd].  If
+       *  this pointer is at BufferEnd, it will never move due to code emission,
+       *  and
+       *  all code emission requests will be ignored (this is
+       *  the buffer overflow condition).
+       */
+      BufferBegin = CurBufferPtr = mpMemMgr
+          ->startFunctionBody(F.getFunction(), ActualSize);
+      BufferEnd = BufferBegin + ActualSize;
+
+      if(mpCurEmitFunction == NULL)
+        mpCurEmitFunction = new EmittedFunctionCode();
+      mpCurEmitFunction->FunctionBody = BufferBegin;
+
+      /* Ensure the constant pool/jump table info is at least 4-byte aligned. */
+      emitAlignment(16);
+
+      emitConstantPool(F.getConstantPool());
+      if(llvm::MachineJumpTableInfo *MJTI = F.getJumpTableInfo())
+        initJumpTableInfo(MJTI);
+
+      /* About to start emitting the machine code for the function. */
+      emitAlignment(std::max(F.getFunction()->getAlignment(), 8U));
+
+      UpdateGlobalMapping(F.getFunction(), CurBufferPtr);
+
+      mpCurEmitFunction->Code = CurBufferPtr;
+
+      mMBBLocations.clear();
+
+      return;
+    }
+
+    /*
+     * finishFunction - This callback is invoked
+     *  when the specified function has
+     *  finished code generation.
+     *  If a buffer overflow has occurred, this method
+     *  returns true (the callee is required to try again), otherwise it returns
+     *  false.
+     */
+    bool finishFunction(llvm::MachineFunction &F) {
+      if(CurBufferPtr == BufferEnd) {
+        /* No enough memory */
+        mpMemMgr->endFunctionBody(F.getFunction(), BufferBegin, CurBufferPtr);
+        return false;
+      }
+
+      if(llvm::MachineJumpTableInfo *MJTI = F.getJumpTableInfo())
+        emitJumpTableInfo(MJTI);
+
+      /*
+       * FnStart is the start of the text,
+       * not the start of the constant pool and other per-function data.
+       */
+      uint8_t* FnStart = (uint8_t*) GetPointerToGlobalIfAvailable
+          (F.getFunction());
+
+      /* FnEnd is the end of the function's machine code. */
+      uint8_t* FnEnd = CurBufferPtr;
+
+      if(!mRelocations.empty()) {
+        /* Resolve the relocations to concrete pointers. */
+        for(int i=0;i<mRelocations.size();i++) {
+          llvm::MachineRelocation& MR = mRelocations[i];
+          void* ResultPtr = NULL;
+
+          if(!MR.letTargetResolve()) {
+            if(MR.isExternalSymbol()) {
+              ResultPtr = GetPointerToNamedSymbol(MR.getExternalSymbol(), true);
+              if(MR.mayNeedFarStub())
+                ResultPtr = GetExternalFunctionStub(ResultPtr);
+            } else if(MR.isGlobalValue()) {
+              ResultPtr = GetPointerToGlobal(MR.getGlobalValue(),
+                                             BufferBegin
+                                               + MR.getMachineCodeOffset(),
+                                             MR.mayNeedFarStub());
+            } else if(MR.isIndirectSymbol()) {
+              ResultPtr = GetPointerToGVIndirectSym
+                  (MR.getGlobalValue(),
+                   BufferBegin + MR.getMachineCodeOffset()
+                   );
+            } else if(MR.isBasicBlock()) {
+              ResultPtr =
+                  (void*) getMachineBasicBlockAddress(MR.getBasicBlock());
+            } else if(MR.isConstantPoolIndex()) {
+              ResultPtr =
+                  (void*) getConstantPoolEntryAddress
+                    (MR.getConstantPoolIndex());
+            } else {
+              assert(MR.isJumpTableIndex() && "Unknown type of relocation");
+              ResultPtr =
+                  (void*) getJumpTableEntryAddress(MR.getJumpTableIndex());
+            }
+
+            MR.setResultPointer(ResultPtr);
+          }
+        }
+
+        mpTJI->relocate(BufferBegin, &mRelocations[0], mRelocations.size(),
+                        mpMemMgr->getGOTBase());
+      }
+
+      mpMemMgr->endFunctionBody(F.getFunction(), BufferBegin, CurBufferPtr);
+      /*
+       * CurBufferPtr may have moved beyond FnEnd, due to memory allocation for
+       *  global variables that were referenced in the relocations.
+       */
+      if(CurBufferPtr == BufferEnd)
+        return false;
+
+      /* Now that we've succeeded in emitting the function */
+      mpCurEmitFunction->Size = CurBufferPtr - BufferBegin;
+      BufferBegin = CurBufferPtr = 0;
+
+      if(F.getFunction()->hasName())
+        mEmittedFunctions[F.getFunction()->getNameStr()] = mpCurEmitFunction;
+      mpCurEmitFunction = NULL;
+
+      mRelocations.clear();
+      mConstPoolAddresses.clear();
+
+      /* Mark code region readable and executable if it's not so already. */
+      mpMemMgr->setMemoryExecutable();
+
+      Disassembler(F.getFunction()->getNameStr(),
+                   FnStart, FnEnd - FnStart, (uintptr_t) FnStart);
+
+      if(mpMMI)
+        mpMMI->EndFunction();
+
+      return false;
+    }
+
+    void startGVStub(const llvm::GlobalValue* GV, unsigned StubSize,
+                     unsigned Alignment) {
+      mpSavedBufferBegin = BufferBegin;
+      mpSavedBufferEnd = BufferEnd;
+      mpSavedCurBufferPtr = CurBufferPtr;
+
+      BufferBegin = CurBufferPtr = mpMemMgr->allocateStub(GV, StubSize,
+                                                          Alignment);
+      BufferEnd = BufferBegin + StubSize + 1;
+
+      return;
+    }
+
+    void startGVStub(void* Buffer, unsigned StubSize) {
+      mpSavedBufferBegin = BufferBegin;
+      mpSavedBufferEnd = BufferEnd;
+      mpSavedCurBufferPtr = CurBufferPtr;
+
+      BufferBegin = CurBufferPtr = (uint8_t *) Buffer;
+      BufferEnd = BufferBegin + StubSize + 1;
+
+      return;
+    }
+
+    void finishGVStub() {
+      assert(CurBufferPtr != BufferEnd && "Stub overflowed allocated space.");
+
+      /* restore */
+      BufferBegin = mpSavedBufferBegin;
+      BufferEnd = mpSavedBufferEnd;
+      CurBufferPtr = mpSavedCurBufferPtr;
+
+      return;
+    }
+
+    /*
+     * allocIndirectGV - Allocates and fills storage for an indirect
+     *  GlobalValue, and returns the address.
+     */
+    void* allocIndirectGV(const llvm::GlobalValue *GV,
+                          const uint8_t *Buffer, size_t Size,
+                          unsigned Alignment) {
+      uint8_t* IndGV = mpMemMgr->allocateStub(GV, Size, Alignment);
+      memcpy(IndGV, Buffer, Size);
+      return IndGV;
+    }
+
+    /* emitLabel - Emits a label */
+    void emitLabel(uint64_t LabelID) {
+      if(mLabelLocations.size() <= LabelID)
+        mLabelLocations.resize((LabelID + 1) * 2);
+      mLabelLocations[LabelID] = getCurrentPCValue();
+      return;
+    }
+
+    /*
+     * allocateGlobal - Allocate memory for a global.  Unlike allocateSpace,
+     *  this method does not allocate memory in the current output buffer,
+     *  because a global may live longer than the current function.
+     */
+    void* allocateGlobal(uintptr_t Size, unsigned Alignment) {
+      /* Delegate this call through the memory manager. */
+      return mpMemMgr->allocateGlobal(Size, Alignment);
+    }
+
+    /*
+     * StartMachineBasicBlock - This should be called by the target when a new
+     *  basic block is about to be emitted.  This way the MCE knows where the
+     *  start of the block is, and can implement getMachineBasicBlockAddress.
+     */
+    void StartMachineBasicBlock(llvm::MachineBasicBlock *MBB) {
+      if(mMBBLocations.size() <= (unsigned) MBB->getNumber())
+        mMBBLocations.resize((MBB->getNumber() + 1) * 2);
+      mMBBLocations[MBB->getNumber()] = getCurrentPCValue();
+      return;
+    }
+
+    /*
+     * addRelocation - Whenever a relocatable address is needed, it should be
+     *  noted with this interface.
+     */
+    void addRelocation(const llvm::MachineRelocation &MR) {
+      mRelocations.push_back(MR);
+      return;
+    }
+
+    /*
+     * getConstantPoolEntryAddress - Return the address of the 'Index' entry in
+     *  the constant pool that was last emitted with
+     *  the emitConstantPool method.
+     */
+    uintptr_t getConstantPoolEntryAddress(unsigned Index) const {
+      assert(Index < mpConstantPool->getConstants().size() &&
+             "Invalid constant pool index!");
+      return mConstPoolAddresses[Index];
+    }
+
+    /*
+     * getJumpTableEntryAddress - Return the address of the jump table
+     *  with index
+     *  'Index' in the function that last called initJumpTableInfo.
+     */
+    uintptr_t getJumpTableEntryAddress(unsigned Index) const {
+      const std::vector<llvm::MachineJumpTableEntry>& JT =
+          mpJumpTable->getJumpTables();
+
+      assert(Index < JT.size() && "Invalid jump table index!");
+
+      unsigned int Offset = 0;
+      unsigned int EntrySize = mpJumpTable->getEntrySize(*mpTD);
+
+      for(int i=0;i<Index;i++)
+        Offset += JT[i].MBBs.size();
+      Offset *= EntrySize;
+
+      return (uintptr_t)((char *) mpJumpTableBase + Offset);
+    }
+
+    /*
+     * getMachineBasicBlockAddress - Return the address of the specified
+     *  MachineBasicBlock, only usable after the label for the MBB has been
+     *  emitted.
+     */
+    uintptr_t getMachineBasicBlockAddress(llvm::MachineBasicBlock *MBB) const {
+      assert(mMBBLocations.size() > (unsigned) MBB->getNumber() &&
+             mMBBLocations[MBB->getNumber()] && "MBB not emitted!");
+      return mMBBLocations[MBB->getNumber()];
+    }
+
+    /*
+     * getLabelAddress - Return the address of the specified LabelID,
+     *  only usable after the LabelID has been emitted.
+     */
+    uintptr_t getLabelAddress(uint64_t LabelID) const {
+      assert(mLabelLocations.size() > (unsigned) LabelID &&
+             mLabelLocations[LabelID] && "Label not emitted!");
+      return mLabelLocations[LabelID];
+    }
+
+    /*
+     * Specifies the MachineModuleInfo object.
+     *  This is used for exception handling
+     *  purposes.
+     */
+    void setModuleInfo(llvm::MachineModuleInfo* Info) {
+      mpMMI = Info;
+      return;
+    }
+
+    void updateFunctionStub(llvm::Function* F) {
+      /* Get the empty stub we generated earlier. */
+      void* Stub;
+      std::set<llvm::Function*>::iterator I = PendingFunctions.find(F);
+      if(I != PendingFunctions.end())
+        Stub = *I;
+      else
+        return;
+
+      void* Addr = GetPointerToGlobalIfAvailable(F);
+
+      assert(Addr != Stub &&
+             "Function must have non-stub address to be updated.");
+
+      /*
+       * Tell the target jit info to rewrite the stub at the specified address,
+       *  rather than creating a new one.
+       */
+      llvm::TargetJITInfo::StubLayout SL = mpTJI->getStubLayout();
+      startGVStub(Stub, SL.Size);
+      mpTJI->emitFunctionStub(F, Addr, *this);
+      finishGVStub();
+
+      Disassembler(F->getNameStr() + " (stub)", (uint8_t*) Stub,
+                   SL.Size, (uintptr_t) Stub);
+
+      PendingFunctions.erase(I);
+
+      return;
+    }
+
+    /*
+     * Once you finish the compilation on a translation unit,
+     *  you can call this function to recycle the memory
+     *  (which is used at compilation time and not needed for runtime).
+     *
+     *  NOTE: You should not call this funtion until the code-gen passes
+     *   for a given module is done.
+     *   Otherwise, the results is undefined and may cause the system crash!
+     */
+    void releaseUnnecessary() {
+      mMBBLocations.clear();
+      mLabelLocations.clear();
+      //sliao mGlobalAddressMap.clear();
+      mFunctionToLazyStubMap.clear();
+      GlobalToIndirectSymMap.clear();
+      ExternalFnToStubMap.clear();
+      PendingFunctions.clear();
+
+      return;
+    }
+
+    void reset() {
+      releaseUnnecessary();
+
+      mpSymbolLookupFn = NULL;
+      mpSymbolLookupContext = NULL;
+
+      mpTJI = NULL;
+      mpTD = NULL;
+
+      for(EmittedFunctionsMapTy::iterator I = mEmittedFunctions.begin();
+          I != mEmittedFunctions.end();
+          I++)
+        if(I->second != NULL)
+          delete I->second;
+      mEmittedFunctions.clear();
+
+      mpMemMgr->reset();
+
+      return;
+    }
+
+    void* lookup(const char* Name) {
+      EmittedFunctionsMapTy::const_iterator I = mEmittedFunctions.find(Name);
+      if(I == mEmittedFunctions.end())
+        return NULL;
+      else
+        return I->second->Code;
+    }
+
+    void getVarNames(llvm::Module *M,
+                     BCCsizei* actualVarCount,
+                     BCCsizei maxVarCount,
+                     void** vars) {
+      int cnt = 0;
+      for (llvm::Module::const_global_iterator c = M->global_begin(),
+             e = M->global_end(); c != e; ++c) {
+        llvm::GlobalVariable *g = (const_cast<llvm::GlobalVariable*> (&(*c)));
+        if (!g->hasInternalLinkage()) {
+          cnt++;
+        }
+      }
+
+      if (actualVarCount)
+        *actualVarCount = cnt;
+      if (cnt > maxVarCount)
+        cnt = maxVarCount;
+      if (!vars)
+        return;
+
+      for (llvm::Module::const_global_iterator c = M->global_begin(),
+               e = M->global_end();
+           c != e && cnt > 0;
+           ++c, --cnt) {
+        llvm::GlobalVariable *g = (const_cast<llvm::GlobalVariable*> (&(*c)));
+        if (!g->hasInternalLinkage()) {
+          // A member function in CodeEmitter
+          *vars++ = (void*) GetPointerToGlobalIfAvailable(g);
+        }
+      }
+    }
+
+    void getFunctionNames(BCCsizei* actualFunctionCount,
+                          BCCsizei maxFunctionCount,
+                          BCCchar** functions) {
+      int functionCount = mEmittedFunctions.size();
+
+      if(actualFunctionCount)
+        *actualFunctionCount = functionCount;
+      if(functionCount > maxFunctionCount)
+        functionCount = maxFunctionCount;
+      if(functions)
+        for(EmittedFunctionsMapTy::const_iterator it =
+              mEmittedFunctions.begin();
+            functionCount > 0;
+            functionCount--, it++)
+          *functions++ = (BCCchar*) it->first.c_str();
+
+      return;
+    }
+
+    void getFunctionBinary(BCCchar* label,
+                           BCCvoid** base,
+                           BCCsizei* length) {
+      EmittedFunctionsMapTy::const_iterator I = mEmittedFunctions.find(label);
+      if(I == mEmittedFunctions.end()) {
+        *base = NULL;
+        *length = 0;
+      } else {
+        *base = I->second->Code;
+        *length = I->second->Size;
+      }
+      return;
+    }
+
+    ~CodeEmitter() {
+      if(mpMemMgr)
+        delete mpMemMgr;
+      return;
+    }
+    /* }}} */
+  };  /* End of Class CodeEmitter */
+
+  /* The CodeEmitter */
+  llvm::OwningPtr<CodeEmitter> mCodeEmitter;
+  CodeEmitter* createCodeEmitter() {
+    mCodeEmitter.reset(new CodeEmitter(mCodeMemMgr.take()));
+    return mCodeEmitter.get();
+  }
+
+  BCCSymbolLookupFn mpSymbolLookupFn;
+  void* mpSymbolLookupContext;
+
+  llvm::Module* mModule;
+
+  bool mTypeInformationPrepared;
+  std::vector<const llvm::Type*> mTypes;
+
+  typedef llvm::StringMap<void*> GlobalVarAddresseTy;
+  GlobalVarAddresseTy mGlobalVarAddresses;
+
+ public:
+  Compiler() : mpSymbolLookupFn(NULL), mpSymbolLookupContext(NULL), mModule(NULL) {
+    llvm::llvm_install_error_handler(LLVMErrorHandler, &mError);
+    return;
+  }
+
+  /* interface for BCCscript::registerSymbolCallback() */
+  void registerSymbolCallback(BCCSymbolLookupFn pFn, BCCvoid* pContext) {
+    mpSymbolLookupFn = pFn;
+    mpSymbolLookupContext = pContext;
+    return;
+  }
+
+  int loadModule(const char* bitcode, size_t bitcodeSize) {
+    llvm::MemoryBuffer* SB = NULL;
+
+    if(bitcode == NULL || bitcodeSize <= 0)
+      return 0;
+
+    GlobalInitialization();
+
+    /* Package input to object MemoryBuffer */
+    SB = llvm::MemoryBuffer::getMemBuffer(bitcode, bitcode + bitcodeSize);
+    if(SB == NULL) {
+      setError("Error reading input Bitcode into memory");
+      goto on_bcc_load_module_error;
+    }
+
+    /* Read the input Bitcode as a Module */
+    mModule = llvm::ParseBitcodeFile(SB, llvm::getGlobalContext(), &mError);
+
+on_bcc_load_module_error:
+    if (SB)
+      delete SB;
+
+    return hasError();
+  }
+
+  /* interace for bccCompileScript() */
+  int compile() {
+    llvm::TargetData* TD = NULL;
+
+    llvm::TargetMachine* TM = NULL;
+    const llvm::Target* Target;
+    std::string FeaturesStr;
+
+    llvm::FunctionPassManager* CodeGenPasses = NULL;
+    const llvm::NamedMDNode* PragmaMetadata;
+
+    if(mModule == NULL) /* No module was loaded */
+      return 0;
+
+    /* Create TargetMachine */
+    Target = llvm::TargetRegistry::lookupTarget(Triple, mError);
+    if(hasError())
+      goto on_bcc_compile_error;
+
+    if(!CPU.empty() || !Features.empty()) {
+      llvm::SubtargetFeatures F;
+      F.setCPU(CPU);
+      for(std::vector<std::string>::const_iterator it = Features.begin();
+          it != Features.end();
+          it++)
+        F.AddFeature(*it);
+      FeaturesStr = F.getString();
+    }
+
+    TM = Target->createTargetMachine(Triple, FeaturesStr);
+    if(TM == NULL) {
+      setError("Failed to create target machine implementation for the"
+               " specified triple '" + Triple + "'");
+      goto on_bcc_compile_error;
+    }
+
+    /* Create memory manager for creation of code emitter later */
+    if(!mCodeMemMgr.get() && !createCodeMemoryManager()) {
+      setError("Failed to startup memory management for further compilation");
+      goto on_bcc_compile_error;
+    }
+
+    /* Create code emitter */
+    if(!mCodeEmitter.get()) {
+      if(!createCodeEmitter()) {
+        setError("Failed to create machine code emitter to complete"
+                 " the compilation");
+        goto on_bcc_compile_error;
+      }
+    } else {
+      /* reuse the code emitter */
+      mCodeEmitter->reset();
+    }
+
+    mCodeEmitter->setTargetMachine(*TM);
+    mCodeEmitter->registerSymbolCallback(mpSymbolLookupFn,
+                                         mpSymbolLookupContext);
+
+    /* Get target data from Module */
+    TD = new llvm::TargetData(mModule);
+    /* Create code-gen pass to run the code emitter */
+    CodeGenPasses = new llvm::FunctionPassManager(mModule);
+    CodeGenPasses->add(TD); // Will take the ownership of TD
+
+    if(TM->addPassesToEmitMachineCode(*CodeGenPasses,
+                                      *mCodeEmitter, CodeGenOptLevel)) {
+      setError("The machine code emission is not supported by BCC on target '"
+               + Triple + "'");
+      goto on_bcc_compile_error;
+    }
+
+    /*
+     * Run the pass (the code emitter) on every non-declaration function
+     * in the module
+     */
+    CodeGenPasses->doInitialization();
+    for(llvm::Module::iterator I = mModule->begin();
+        I != mModule->end();
+        I++)
+      if(!I->isDeclaration())
+        CodeGenPasses->run(*I);
+
+    CodeGenPasses->doFinalization();
+
+    /* Copy the global address mapping from code emitter and remapping */
+    for(CodeEmitter::global_addresses_const_iterator I =
+          mCodeEmitter->global_address_begin();
+        I != mCodeEmitter->global_address_end();
+        I++)
+    {
+      if(I->first->getValueID() != llvm::Value::GlobalVariableVal)
+        continue;
+      llvm::StringRef GlobalVarName = I->first->getName();
+      GlobalVarAddresseTy::value_type* V =
+          GlobalVarAddresseTy::value_type::Create(
+              GlobalVarName.begin(),
+              GlobalVarName.end(),
+              mGlobalVarAddresses.getAllocator(),
+              I->second
+          );
+      bool ret = mGlobalVarAddresses.insert(V);
+      assert(ret && "The global variable name should be unique over the module");
+    }
+
+    /*
+     * Tell code emitter now can release the memory using
+     * during the JIT since we have done the code emission
+     */
+    mCodeEmitter->releaseUnnecessary();
+
+    /*
+     * Finally, read pragma information from the metadata node
+     * of the @Module if any
+     */
+    PragmaMetadata = mModule->getNamedMetadata(PragmaMetadataName);
+    if(PragmaMetadata)
+      for(int i=0;i<PragmaMetadata->getNumOperands();i++) {
+        llvm::MDNode* Pragma = PragmaMetadata->getOperand(i);
+        if(Pragma != NULL &&
+           Pragma->getNumOperands() == 2 /* should have exactly 2 operands */) {
+          llvm::Value* PragmaNameMDS = Pragma->getOperand(0);
+          llvm::Value* PragmaValueMDS = Pragma->getOperand(1);
+
+          if((PragmaNameMDS->getValueID() == llvm::Value::MDStringVal) &&
+             (PragmaValueMDS->getValueID() == llvm::Value::MDStringVal)) {
+            llvm::StringRef PragmaName =
+                static_cast<llvm::MDString*>(PragmaNameMDS)->getString();
+            llvm::StringRef PragmaValue =
+                static_cast<llvm::MDString*>(PragmaValueMDS)->getString();
+
+            mPragmas.push_back( make_pair( std::string(PragmaName.data(),
+                                                       PragmaName.size()),
+                                           std::string(PragmaValue.data(),
+                                                       PragmaValue.size())
+                                           )
+                                );
+          }
+        }
+      }
+
+ on_bcc_compile_error:
+    if (CodeGenPasses) {
+      delete CodeGenPasses;
+    } else if (TD) {
+      delete TD;
+    }
+    if (TM)
+      delete TM;
+
+    return hasError();
+  }
+
+  /* interface for bccGetScriptInfoLog() */
+  char* getErrorMessage() {
+    return const_cast<char*>(mError.c_str());
+  }
+
+  /* interface for bccGetScriptLabel() */
+  void* lookup(const char* name) {
+    void* addr = NULL;
+    if(mCodeEmitter.get()) {
+      /* Find function pointer */
+      addr = mCodeEmitter->lookup(name);
+      if(addr == NULL) {
+        /*
+         * No function labeled with given name.
+         * Try searching the global variables.
+         */
+        GlobalVarAddresseTy::const_iterator I = mGlobalVarAddresses.find(name);
+        if(I != mGlobalVarAddresses.end())
+          addr = I->getValue();
+      }
+    }
+    return addr;
+  }
+
+  /* Interface for bccGetPragmas() */
+  void getPragmas(BCCsizei* actualStringCount,
+                  BCCsizei maxStringCount,
+                  BCCchar** strings) {
+    int stringCount = mPragmas.size() * 2;
+
+    if(actualStringCount)
+      *actualStringCount = stringCount;
+    if(stringCount > maxStringCount)
+      stringCount = maxStringCount;
+    if(strings)
+      for(PragmaList::const_iterator it = mPragmas.begin();
+          stringCount > 0;
+          stringCount-=2, it++)
+      {
+        *strings++ = (BCCchar*) it->first.c_str();
+        *strings++ = (BCCchar*) it->second.c_str();
+      }
+
+    return;
+  }
+
+  /* Interface for bccGetVars() */
+  void getVars(BCCsizei* actualVarCount,
+               BCCsizei maxVarCount,
+               void** vars) {
+    if(mCodeEmitter.get())
+      mCodeEmitter->getVarNames(mModule,
+                                actualVarCount,
+                                maxVarCount,
+                                vars);
+    else
+      *actualVarCount = 0;
+
+    return;
+  }
+
+  /* Interface for bccGetFunctions() */
+  void getFunctions(BCCsizei* actualFunctionCount,
+                 BCCsizei maxFunctionCount,
+                 BCCchar** functions) {
+    if(mCodeEmitter.get())
+      mCodeEmitter->getFunctionNames(actualFunctionCount,
+                                     maxFunctionCount,
+                                     functions);
+    else
+      *actualFunctionCount = 0;
+
+    return;
+  }
+
+  /* Interface for bccGetFunctionBinary() */
+  void getFunctionBinary(BCCchar* function,
+                         BCCvoid** base,
+                         BCCsizei* length) {
+    if(mCodeEmitter.get()) {
+      mCodeEmitter->getFunctionBinary(function, base, length);
+    } else {
+      *base = NULL;
+      *length = 0;
+    }
+    return;
+  }
+
+  inline const llvm::Module* getModule() const {
+    return mModule;
+  }
+
+  inline const std::vector<const llvm::Type*>& getTypes() const {
+    return mTypes;
+  }
+
+  ~Compiler() {
+    delete mModule;
+    llvm::llvm_shutdown();
+    return;
+  }
+};  /* End of Class Compiler */
+
+bool Compiler::GlobalInitialized = false;
+
+/* Code generation optimization level for the compiler */
+llvm::CodeGenOpt::Level Compiler::CodeGenOptLevel;
+
+std::string Compiler::Triple;
+
+std::string Compiler::CPU;
+
+std::vector<std::string> Compiler::Features;
+
+/*
+ * The named of metadata node that pragma resides
+ * (should be synced with slang.cpp)
+ */
+const llvm::StringRef Compiler::PragmaMetadataName = "#pragma";
+
+struct BCCscript {
+  /*
+   * Part I. Compiler
+   */
+
+  Compiler compiler;
+
+  void registerSymbolCallback(BCCSymbolLookupFn pFn, BCCvoid* pContext) {
+    compiler.registerSymbolCallback(pFn, pContext);
+  }
+
+  /*
+   * Part II. Logistics & Error handling
+   */
+
+  BCCscript() {
+    bccError = BCC_NO_ERROR;
+  }
+
+  ~BCCscript() {
+  }
+
+  void setError(BCCenum error) {
+    if (bccError == BCC_NO_ERROR && error != BCC_NO_ERROR) {
+      bccError = error;
+    }
+  }
+
+  BCCenum getError() {
+    BCCenum result = bccError;
+    bccError = BCC_NO_ERROR;
+    return result;
+  }
+
+  BCCenum bccError;
+};
+
+
+extern "C"
+BCCscript* bccCreateScript()
+{
+  return new BCCscript();
+}
+
+extern "C"
+BCCenum bccGetError( BCCscript* script )
+{
+  return script->getError();
+}
+
+extern "C"
+void bccDeleteScript(BCCscript* script) {
+  delete script;
+}
+
+extern "C"
+void bccRegisterSymbolCallback(BCCscript* script,
+                               BCCSymbolLookupFn pFn,
+                               BCCvoid* pContext)
+{
+  script->registerSymbolCallback(pFn, pContext);
+}
+
+extern "C"
+void bccScriptBitcode(BCCscript* script,
+                      const BCCchar* bitcode,
+                      BCCint size)
+{
+  script->compiler.loadModule(bitcode, size);
+}
+
+extern "C"
+void bccCompileScript(BCCscript* script)
+{
+  int result = script->compiler.compile();
+  if (result)
+    script->setError(BCC_INVALID_OPERATION);
+}
+
+extern "C"
+void bccGetScriptInfoLog(BCCscript* script,
+                         BCCsizei maxLength,
+                         BCCsizei* length,
+                         BCCchar* infoLog)
+{
+  char* message = script->compiler.getErrorMessage();
+  int messageLength = strlen(message) + 1;
+  if (length)
+    *length = messageLength;
+
+  if (infoLog && maxLength > 0) {
+    int trimmedLength = maxLength < messageLength ? maxLength : messageLength;
+    memcpy(infoLog, message, trimmedLength);
+    infoLog[trimmedLength] = 0;
+  }
+}
+
+extern "C"
+void bccGetScriptLabel(BCCscript* script,
+                       const BCCchar * name,
+                       BCCvoid ** address)
+{
+  void* value = script->compiler.lookup(name);
+  if (value)
+    *address = value;
+  else
+    script->setError(BCC_INVALID_VALUE);
+}
+
+extern "C"
+void bccGetPragmas(BCCscript* script,
+                   BCCsizei* actualStringCount,
+                   BCCsizei maxStringCount,
+                   BCCchar** strings)
+{
+  script->compiler.getPragmas(actualStringCount, maxStringCount, strings);
+}
+
+extern "C"
+void bccGetVars(BCCscript* script,
+                BCCsizei* actualVarCount,
+                BCCsizei maxVarCount,
+                void** vars)
+{
+  script->compiler.getVars(actualVarCount,
+                           maxVarCount,
+                           vars);
+}
+
+extern "C"
+void bccGetFunctions(BCCscript* script,
+                     BCCsizei* actualFunctionCount,
+                     BCCsizei maxFunctionCount,
+                     BCCchar** functions)
+{
+  script->compiler.getFunctions(actualFunctionCount,
+                                maxFunctionCount,
+                                functions);
+}
+
+extern "C"
+void bccGetFunctionBinary(BCCscript* script,
+                          BCCchar* function,
+                          BCCvoid** base,
+                          BCCsizei* length)
+{
+  script->compiler.getFunctionBinary(function, base, length);
+}
+
+struct BCCtype {
+  const Compiler* compiler;
+  const llvm::Type* t;
+};
+
+}  /* End of namespace bcc */
diff --git a/bcc_runtime.c b/bcc_runtime.c
new file mode 100644
index 0000000..c5bb33d
--- /dev/null
+++ b/bcc_runtime.c
@@ -0,0 +1,114 @@
+#include "runtime/lib/absvdi2.c"
+#include "runtime/lib/absvsi2.c"
+#include "runtime/lib/addvdi3.c"
+#include "runtime/lib/addvsi3.c"
+#include "runtime/lib/ashldi3.c"
+#ifndef ANDROID
+#   include "runtime/lib/ashrdi3.c"
+#endif
+#include "runtime/lib/clzdi2.c"
+#include "runtime/lib/clzsi2.c"
+#include "runtime/lib/cmpdi2.c"
+#include "runtime/lib/ctzdi2.c"
+#include "runtime/lib/ctzsi2.c"
+#ifndef ANDROID // no complex.h
+#   include "runtime/lib/divdc3.c"
+#endif
+#include "runtime/lib/divdi3.c"
+#ifndef ANDROID // no complex.h
+#   include "runtime/lib/divsc3.c"
+#endif
+#include "runtime/lib/ffsdi2.c"
+#include "runtime/lib/fixdfdi.c"
+#include "runtime/lib/fixsfdi.c"
+#include "runtime/lib/fixunsdfdi.c"
+#include "runtime/lib/fixunsdfsi.c"
+#include "runtime/lib/fixunssfdi.c"
+#include "runtime/lib/fixunssfsi.c"
+#include "runtime/lib/floatdidf.c"
+#include "runtime/lib/floatdisf.c"
+#include "runtime/lib/floatundidf.c"
+#include "runtime/lib/floatundisf.c"
+#include "runtime/lib/lshrdi3.c"
+#include "runtime/lib/moddi3.c"
+#ifndef ANDROID // no complex.h
+#   include "runtime/lib/muldc3.c"
+#endif
+#include "runtime/lib/muldi3.c"
+#ifndef ANDROID // no complex.h
+#   include "runtime/lib/mulsc3.c"
+#endif
+#include "runtime/lib/mulvdi3.c"
+#include "runtime/lib/mulvsi3.c"
+#include "runtime/lib/negdi2.c"
+#include "runtime/lib/negvdi2.c"
+#include "runtime/lib/negvsi2.c"
+#include "runtime/lib/paritydi2.c"
+#include "runtime/lib/paritysi2.c"
+#include "runtime/lib/popcountdi2.c"
+#include "runtime/lib/popcountsi2.c"
+#include "runtime/lib/powidf2.c"
+#include "runtime/lib/powisf2.c"
+#include "runtime/lib/subvdi3.c"
+#include "runtime/lib/subvsi3.c"
+#include "runtime/lib/ucmpdi2.c"
+#include "runtime/lib/udivdi3.c"
+#include "runtime/lib/udivmoddi4.c"
+#include "runtime/lib/umoddi3.c"
+#include "runtime/lib/eprintf.c"
+
+#include <string.h>
+#include <stdlib.h>
+
+typedef struct {
+  const char* mName; 
+  void* mPtr;
+} RuntimeFunction;
+
+#define USE_VFP_RUNTIME 1
+
+#if defined(__arm__)
+  #define DEF_GENERIC_RUNTIME(func)   \
+    extern void* func;
+  #define DEF_VFP_RUNTIME(func) \
+    extern void* func ## vfp;
+  #define DEF_LLVM_RUNTIME(func)
+#include "bcc_runtime.def"
+#endif
+
+static const RuntimeFunction Runtimes[] = {
+#if defined(__arm__)
+  #define DEF_GENERIC_RUNTIME(func)   \
+    { #func, (void*) &func },
+  // TODO: enable only when target support VFP
+  #define DEF_VFP_RUNTIME(func) \
+    { #func, (void*) &func ## vfp },
+#else
+  // host compiler library must contain generic runtime
+  #define DEF_GENERIC_RUNTIME(func)
+  #define DEF_VFP_RUNTIME(func)
+#endif
+#define DEF_LLVM_RUNTIME(func)   \
+  { #func, (void*) &func },
+#include "bcc_runtime.def"
+};
+
+static int CompareRuntimeFunction(const void* a, const void* b) {
+  return strcmp(((const RuntimeFunction*) a)->mName, 
+               ((const RuntimeFunction*) b)->mName);
+}
+
+void* FindRuntimeFunction(const char* Name) {
+  /* binary search */
+  const RuntimeFunction Key = { Name, NULL };
+  const RuntimeFunction* R = 
+      bsearch(&Key, 
+              Runtimes, 
+              sizeof(Runtimes) / sizeof(RuntimeFunction), 
+              sizeof(RuntimeFunction),
+              CompareRuntimeFunction);
+  if(R)
+    return R->mPtr;
+  else
+    return NULL;
+}
diff --git a/bcc_runtime.def b/bcc_runtime.def
new file mode 100644
index 0000000..9742bfd
--- /dev/null
+++ b/bcc_runtime.def
@@ -0,0 +1,157 @@
+#ifdef USE_VFP_RUNTIME
+#   define DEF_GENERIC_OR_VFP_RUNTIME(func) DEF_VFP_RUNTIME(func)
+#   define DEF_LLVM_OR_VFP_RUNTIME(func) DEF_VFP_RUNTIME(func)
+#else
+#   undef DEF_VFP_RUNTIME
+#   define DEF_VFP_RUNTIME(func)
+#   define DEF_GENERIC_OR_VFP_RUNTIME(func) DEF_GENERIC_RUNTIME(func)
+#   define DEF_LLVM_OR_VFP_RUNTIME(func) DEF_LLVM_RUNTIME(func)
+#endif
+
+// Sorted
+DEF_LLVM_RUNTIME(__absvdi2)
+DEF_LLVM_RUNTIME(__absvsi2)
+
+DEF_GENERIC_OR_VFP_RUNTIME(__adddf3)
+DEF_GENERIC_OR_VFP_RUNTIME(__addsf3)
+
+DEF_LLVM_RUNTIME(__addvdi3)
+DEF_LLVM_RUNTIME(__addvsi3)
+DEF_LLVM_RUNTIME(__ashldi3)
+#ifndef ANDROID // has one in bionic
+    DEF_LLVM_RUNTIME(__ashrdi3)
+#endif
+
+#ifdef USE_VFP_RUNTIME
+//    DEF_GENERIC_RUNTIME(__bswapdi2)
+//    DEF_GENERIC_RUNTIME(__bswapsi2)
+#endif
+
+DEF_LLVM_RUNTIME(__clzdi2)
+DEF_LLVM_RUNTIME(__clzsi2)
+DEF_LLVM_RUNTIME(__cmpdi2)
+DEF_LLVM_RUNTIME(__ctzdi2)
+DEF_LLVM_RUNTIME(__ctzsi2)
+
+#ifndef ANDROID // no complex extension
+    DEF_LLVM_RUNTIME(__divdc3)
+#endif
+
+DEF_GENERIC_OR_VFP_RUNTIME(__divdf3)
+
+DEF_LLVM_RUNTIME(__divdi3)
+
+#ifndef ANDROID // no complex extension
+    DEF_LLVM_RUNTIME(__divsc3)
+#endif
+
+DEF_GENERIC_OR_VFP_RUNTIME(__divsf3)
+
+DEF_LLVM_RUNTIME(__eprintf)
+
+DEF_GENERIC_OR_VFP_RUNTIME(__eqdf2)
+DEF_GENERIC_OR_VFP_RUNTIME(__eqsf2)
+DEF_GENERIC_OR_VFP_RUNTIME(__extendsfdf2)
+
+DEF_LLVM_RUNTIME(__ffsdi2)
+DEF_LLVM_RUNTIME(__fixdfdi)
+
+DEF_GENERIC_OR_VFP_RUNTIME(__fixdfsi)
+
+DEF_LLVM_RUNTIME(__fixsfdi)
+
+DEF_GENERIC_OR_VFP_RUNTIME(__fixsfsi)
+
+DEF_LLVM_RUNTIME(__fixunsdfdi)
+DEF_LLVM_OR_VFP_RUNTIME(__fixunsdfsi)
+DEF_LLVM_RUNTIME(__fixunssfdi)
+
+DEF_LLVM_OR_VFP_RUNTIME(__fixunssfsi)
+
+DEF_LLVM_RUNTIME(__floatdidf)
+DEF_LLVM_RUNTIME(__floatdisf)
+
+DEF_GENERIC_OR_VFP_RUNTIME(__floatsidf)
+DEF_GENERIC_OR_VFP_RUNTIME(__floatsisf)
+
+DEF_LLVM_RUNTIME(__floatundidf)
+DEF_LLVM_RUNTIME(__floatundisf)
+
+DEF_GENERIC_RUNTIME(__floatunsidf)
+DEF_GENERIC_RUNTIME(__floatunsisf)
+
+DEF_VFP_RUNTIME(__floatunssidf)
+DEF_VFP_RUNTIME(__floatunssisf)
+
+DEF_GENERIC_OR_VFP_RUNTIME(__gedf2)
+DEF_GENERIC_OR_VFP_RUNTIME(__gesf2)
+DEF_VFP_RUNTIME(__gtdf2)
+DEF_VFP_RUNTIME(__gtsf2)
+
+DEF_GENERIC_OR_VFP_RUNTIME(__ledf2)
+DEF_GENERIC_OR_VFP_RUNTIME(__lesf2)
+
+DEF_LLVM_RUNTIME(__lshrdi3)
+
+DEF_VFP_RUNTIME(__ltdf2)
+DEF_VFP_RUNTIME(__ltsf2)
+
+DEF_LLVM_RUNTIME(__moddi3)
+
+#ifndef ANDROID // no complex extension
+    DEF_LLVM_RUNTIME(__muldc3)
+#endif
+
+DEF_GENERIC_OR_VFP_RUNTIME(__muldf3)
+DEF_LLVM_RUNTIME(__muldi3)
+DEF_LLVM_RUNTIME(__muldsi3)
+                              
+#ifndef ANDROID // no complex extension
+    DEF_LLVM_RUNTIME(__mulsc3)
+#endif
+
+DEF_GENERIC_OR_VFP_RUNTIME(__mulsf3)
+
+DEF_LLVM_RUNTIME(__mulvdi3)
+DEF_LLVM_RUNTIME(__mulvsi3)
+
+DEF_VFP_RUNTIME(__nedf2)
+
+DEF_GENERIC_OR_VFP_RUNTIME(__negdf2)
+
+DEF_LLVM_RUNTIME(__negdi2)
+
+DEF_GENERIC_OR_VFP_RUNTIME(__negsf2)
+
+DEF_LLVM_RUNTIME(__negvdi2)
+DEF_LLVM_RUNTIME(__negvsi2)
+
+DEF_VFP_RUNTIME(__nesf2)
+
+DEF_LLVM_RUNTIME(__paritydi2)
+DEF_LLVM_RUNTIME(__paritysi2)
+DEF_LLVM_RUNTIME(__popcountdi2)
+DEF_LLVM_RUNTIME(__popcountsi2)
+DEF_LLVM_RUNTIME(__powidf2)
+DEF_LLVM_RUNTIME(__powisf2)
+
+DEF_GENERIC_OR_VFP_RUNTIME(__subdf3)
+DEF_GENERIC_OR_VFP_RUNTIME(__subsf3)
+
+DEF_LLVM_RUNTIME(__subvdi3)
+DEF_LLVM_RUNTIME(__subvsi3)
+
+DEF_GENERIC_OR_VFP_RUNTIME(__truncdfsf2)
+
+DEF_LLVM_RUNTIME(__ucmpdi2)
+DEF_LLVM_RUNTIME(__udivdi3)
+DEF_LLVM_RUNTIME(__udivmoddi4)
+DEF_LLVM_RUNTIME(__umoddi3)
+
+DEF_GENERIC_OR_VFP_RUNTIME(__unorddf2)
+DEF_GENERIC_OR_VFP_RUNTIME(__unordsf2)
+
+
+#undef DEF_GENERIC_RUNTIME
+#undef DEF_LLVM_RUNTIME
+#undef DEF_VFP_RUNTIME
diff --git a/bcc_runtime.h b/bcc_runtime.h
new file mode 100644
index 0000000..8ab9b79
--- /dev/null
+++ b/bcc_runtime.h
@@ -0,0 +1,15 @@
+#ifndef _BCC_RUNTIME_H_
+#   define _BCC_RUNTIME_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+    void ListRuntimeFunction();
+void* FindRuntimeFunction(const char* Name);
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif  /* _BCC_RUNTIME_H_ */
diff --git a/include/bcc/bcc.h b/include/bcc/bcc.h
new file mode 100644
index 0000000..c8de954
--- /dev/null
+++ b/include/bcc/bcc.h
@@ -0,0 +1,134 @@
+/*
+ * Copyright (C) 2009 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.
+ */
+
+#ifndef ANDROID_BCC_BCC_H
+#define ANDROID_BCC_BCC_H
+
+#include <stdint.h>
+#include <sys/types.h>
+
+typedef char                        BCCchar;
+typedef int32_t                     BCCint;
+typedef uint32_t                    BCCuint;
+typedef ssize_t                     BCCsizei;
+typedef unsigned int                BCCenum;
+typedef void                        BCCvoid;
+typedef struct BCCscript            BCCscript;
+typedef struct BCCtype              BCCtype;
+
+#define BCC_NO_ERROR                0x0000
+#define BCC_INVALID_ENUM            0x0500
+#define BCC_INVALID_OPERATION       0x0502
+#define BCC_INVALID_VALUE           0x0501
+#define BCC_OUT_OF_MEMORY           0x0505
+
+#define BCC_COMPILE_STATUS          0x8B81
+#define BCC_INFO_LOG_LENGTH         0x8B84
+
+
+// ----------------------------------------------------------------------------
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+BCCscript* bccCreateScript();
+
+void bccDeleteScript(BCCscript* script);
+
+typedef BCCvoid* (*BCCSymbolLookupFn)(BCCvoid* pContext, const BCCchar* name);
+
+void bccRegisterSymbolCallback(BCCscript* script,
+                               BCCSymbolLookupFn pFn,
+                               BCCvoid* pContext);
+
+BCCenum bccGetError( BCCscript* script );
+
+void bccScriptBitcode(BCCscript* script,
+                 const BCCchar* bitcode,
+                 BCCint size);
+
+void bccCompileScript(BCCscript* script);
+
+void bccGetScriptInfoLog(BCCscript* script,
+                         BCCsizei maxLength,
+                         BCCsizei* length,
+                         BCCchar* infoLog);
+
+void bccGetScriptLabel(BCCscript* script,
+                       const BCCchar* name,
+                       BCCvoid** address);
+
+void bccGetPragmas(BCCscript* script,
+                   BCCsizei* actualStringCount,
+                   BCCsizei maxStringCount,
+                   BCCchar** strings);
+
+void bccGetVars(BCCscript* script,
+                BCCsizei* actualVarCount,
+                BCCsizei maxVarCount,
+                void** vars);
+
+void bccGetFunctions(BCCscript* script,
+                     BCCsizei* actualFunctionCount,
+                     BCCsizei maxFunctionCount,
+                     BCCchar** functions);
+
+void bccGetFunctionBinary(BCCscript* script,
+                          BCCchar* function,
+                          BCCvoid** base,
+                          BCCsizei* length);
+
+#if 0
+/* Type-reflection functions below */
+BCCuint bccGetNumTypes(BCCscript* script);
+BCCtype* bccGetTypeOfName(BCCscript* script,
+                          BCCtype* resultType,
+                          const BCCchar* name);
+BCCtype* bccGetTypeOfIdx(BCCscript* script,
+                         BCCtype* resultType,
+                         BCCuint i);
+
+/* APIs to BCCtype (all with prefix "bccType") */
+const BCCchar* bccTypeGetName(const BCCtype* type);
+
+/*
+ * Depending on its usage model, a type reflection (or a type system) needs
+ *  to provide both structural equivalence or name equivalence information.
+ *
+ * bccTypeGetStruct() provides the former, while
+ * bccTypeGetFieldNames(), the latter.
+ */
+const BCCchar* bccTypeGetStruct(const BCCtype* h);
+const BCCchar* bccTypeGetFieldNames(const BCCtype* h);
+
+BCCuint bccTypeGetNumFields(const BCCtype* h);
+const BCCtype* bccTypeGetFieldType(const BCCtype* type,
+                                   BCCtype* resultType,
+                                   BCCuint i);
+BCCchar* bccTypeGetFieldName(const BCCtype* type, BCCuint i);
+
+BCCuint bccTypeGetFieldSizeInBits(const BCCtype* type, BCCuint i);
+BCCuint bccTypeGetFieldOffsetInBits(const BCCtype* type, BCCuint i);
+#endif
+
+#ifdef __cplusplus
+};
+#endif
+
+// ----------------------------------------------------------------------------
+
+#endif
diff --git a/runtime/.gitignore b/runtime/.gitignore
new file mode 100644
index 0000000..8f99959
--- /dev/null
+++ b/runtime/.gitignore
@@ -0,0 +1,4 @@
+*~
+Debug
+Release
+Profile
diff --git a/runtime/BlocksRuntime/Block.h b/runtime/BlocksRuntime/Block.h
new file mode 100644
index 0000000..2f2920a
--- /dev/null
+++ b/runtime/BlocksRuntime/Block.h
@@ -0,0 +1,59 @@
+/*
+ * Block.h
+ *
+ * Copyright 2008-2009 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/runtime/BlocksRuntime/Block_private.h b/runtime/BlocksRuntime/Block_private.h
new file mode 100644
index 0000000..f7cad03
--- /dev/null
+++ b/runtime/BlocksRuntime/Block_private.h
@@ -0,0 +1,172 @@
+/*
+ * Block_private.h
+ *
+ * Copyright 2008-2009 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
+
+#include <stdbool.h>
+
+#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/runtime/BlocksRuntime/CMakeLists.txt b/runtime/BlocksRuntime/CMakeLists.txt
new file mode 100644
index 0000000..5b4686b
--- /dev/null
+++ b/runtime/BlocksRuntime/CMakeLists.txt
@@ -0,0 +1,13 @@
+PROJECT( BlocksRuntime C )
+
+SET( SRCS
+ runtime.c
+ data.c
+ )
+
+ADD_LIBRARY( ${PROJECT_NAME} SHARED ${SRCS})
+SET_TARGET_PROPERTIES( ${PROJECT_NAME} PROPERTIES
+  INSTALL_NAME_DIR ${CMAKE_INSTALL_PREFIX}/lib )
+
+INSTALL( TARGETS ${PROJECT_NAME} DESTINATION lib )
+INSTALL( FILES Block.h Block_private.h DESTINATION include )
diff --git a/runtime/BlocksRuntime/data.c b/runtime/BlocksRuntime/data.c
new file mode 100644
index 0000000..7d76270
--- /dev/null
+++ b/runtime/BlocksRuntime/data.c
@@ -0,0 +1,41 @@
+/*
+ * data.c
+ *
+ * Copyright 2008-2009 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/runtime/BlocksRuntime/runtime.c b/runtime/BlocksRuntime/runtime.c
new file mode 100644
index 0000000..175357b
--- /dev/null
+++ b/runtime/BlocksRuntime/runtime.c
@@ -0,0 +1,701 @@
+/*
+ * runtime.c
+ *
+ * Copyright 2008-2009 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 <stdbool.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__)
+#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/runtime/CMakeLists.txt b/runtime/CMakeLists.txt
new file mode 100644
index 0000000..483b673
--- /dev/null
+++ b/runtime/CMakeLists.txt
@@ -0,0 +1,55 @@
+# See docs/CMake.html for instructions about how to build Compiler-RT with CMake.
+
+PROJECT( CompilerRT C )
+CMAKE_MINIMUM_REQUIRED( VERSION 2.6 )
+
+set(PACKAGE_NAME compiler-rt)
+set(PACKAGE_VERSION 1.0svn)
+set(PACKAGE_STRING "${PACKAGE_NAME} ${PACKAGE_VERSION}")
+set(PACKAGE_BUGREPORT "llvmbugs@cs.uiuc.edu")
+
+SET( CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake/Modules )
+
+# add definitions
+include(DefineCompilerFlags)
+
+# Disallow in-source build
+INCLUDE( MacroEnsureOutOfSourceBuild )
+MACRO_ENSURE_OUT_OF_SOURCE_BUILD(
+ "${PROJECT_NAME} requires an out of source build. Please create a separate build directory and run 'cmake /path/to/${PROJECT_NAME} [options]' there."
+ )
+
+INCLUDE( ${CMAKE_SOURCE_DIR}/cmake/ConfigureChecks.cmake )
+CONFIGURE_FILE( ${CMAKE_SOURCE_DIR}/cmake/config.h.cmake
+                ${CMAKE_CURRENT_BINARY_DIR}/config.h )
+
+INCLUDE_DIRECTORIES(
+ ${CMAKE_CURRENT_BINARY_DIR}
+)
+
+SET( Achitectures
+ i386 x86_64 ppc arm
+ )
+
+SET( Configurations
+ Debug Release Profile
+ )
+
+# Only build Blocks Runtime if the compiler has enough support
+IF( WIN32 OR MSVC OR HAVE_OSATOMIC_COMPARE_AND_SWAP_INT OR HAVE_SYNC_BOOL_COMPARE_AND_SWAP_INT )
+  SET(BUILD_BLOCKS_RUNTIME TRUE)
+ELSE( WIN32 OR MSVC OR HAVE_OSATOMIC_COMPARE_AND_SWAP_INT OR HAVE_SYNC_BOOL_COMPARE_AND_SWAP_INT )
+  SET(BUILD_BLOCKS_RUNTIME FALSE)
+ENDIF( WIN32 OR MSVC OR HAVE_OSATOMIC_COMPARE_AND_SWAP_INT OR HAVE_SYNC_BOOL_COMPARE_AND_SWAP_INT )
+
+IF( BUILD_BLOCKS_RUNTIME )
+  ADD_SUBDIRECTORY( BlocksRuntime )
+ELSE( BUILD_BLOCKS_RUNTIME )
+  MESSAGE(STATUS "No suitable atomic operation routines detected, skipping Blocks Runtime")
+ENDIF( BUILD_BLOCKS_RUNTIME )
+
+ADD_SUBDIRECTORY( lib )
+
+# Enable Test Suit:
+INCLUDE( MacroAddCheckTest )
+ADD_SUBDIRECTORY( test )
diff --git a/runtime/CREDITS.TXT b/runtime/CREDITS.TXT
new file mode 100644
index 0000000..8b07b82
--- /dev/null
+++ b/runtime/CREDITS.TXT
@@ -0,0 +1,21 @@
+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
+
diff --git a/runtime/LICENSE.TXT b/runtime/LICENSE.TXT
new file mode 100644
index 0000000..a5e1345
--- /dev/null
+++ b/runtime/LICENSE.TXT
@@ -0,0 +1,63 @@
+==============================================================================
+LLVM Release License
+==============================================================================
+University of Illinois/NCSA
+Open Source License
+
+Copyright (c) 2003-2009 University of Illinois at Urbana-Champaign.
+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.
+
+==============================================================================
+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.
+
+The following pieces of software have additional or alternate copyrights,
+licenses, and/or restrictions:
+
+Program             Directory
+-------             ---------
diff --git a/runtime/Makefile b/runtime/Makefile
new file mode 100644
index 0000000..95c02a6
--- /dev/null
+++ b/runtime/Makefile
@@ -0,0 +1,237 @@
+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) $(DATE) > $@
+
+# 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.ObjPath)/%/libcompiler_rt.a)
+.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))
+
+# 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.a))
+$(Tmp.ObjPath)/libcompiler_rt.a: $(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.a
+.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 \
+  $(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.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))))
+
+# 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) $$@
+.PRECIOUS: $(Tmp.ObjPath)/.dir
+
+# Per-Config-Arch Targets
+$(Tmp.Name)-$(Tmp.Config)-$(Tmp.Arch):: $(Tmp.ObjPath)/libcompiler_rt.a
+.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.CFLAGS,$(strip \
+  $(if $(call IsDefined,$(Tmp.Key).UniversalArchs),-arch $(Tmp.Arch),)\
+  $(if $(call streq,$($(Tmp.Key).VISIBILITY_HIDDEN),1),\
+       -fvisibility=hidden -DVISIBILITY_HIDDEN,)\
+  $(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) $(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) $(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) $(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/runtime/README.txt b/runtime/README.txt
new file mode 100644
index 0000000..64cef65
--- /dev/null
+++ b/runtime/README.txt
@@ -0,0 +1,331 @@
+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
+tu_int __udivmodti4(tu_int a, tu_int b, tu_int* rem);  // a / b, *rem = a % b
+
+//  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 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 instuction 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);
+				
+
+
+//   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/runtime/cmake/ConfigureChecks.cmake b/runtime/cmake/ConfigureChecks.cmake
new file mode 100644
index 0000000..b72a390
--- /dev/null
+++ b/runtime/cmake/ConfigureChecks.cmake
@@ -0,0 +1,38 @@
+INCLUDE( CheckIncludeFile )
+INCLUDE( CheckFunctionExists )
+INCLUDE( CheckSymbolExists )
+INCLUDE( CheckCSourceCompiles )
+
+SET( PACKAGE ${PACKAGE_NAME} )
+SET( VERSION ${PACKAGE_VERSION} )
+
+SET( BINARYDIR ${CMAKE_BINARY_DIR} )
+SET( SOURCEDIR ${CMAKE_SOURCE_DIR} )
+
+# HEADER FILES
+CHECK_INCLUDE_FILE( sys/byteorder.h HAVE_SYS_BYTEORDER_H )
+CHECK_INCLUDE_FILE( AvailabilityMacros.h HAVE_AVAILABILITY_MACROS_H )
+CHECK_INCLUDE_FILE( TargetConditionals.h HAVE_TARGET_CONDITIONALS_H )
+CHECK_INCLUDE_FILE( libkern/OSAtomic.h HAVE_LIBKERN_OSATOMIC_H )
+
+# FUNCTIONS
+CHECK_FUNCTION_EXISTS( sysconf HAVE_SYSCONF )
+CHECK_SYMBOL_EXISTS( OSAtomicCompareAndSwapInt libkern/OSAtomic.h HAVE_OSATOMIC_COMPARE_AND_SWAP_INT )
+CHECK_SYMBOL_EXISTS( OSAtomicCompareAndSwapLong libkern/OSAtomic.h HAVE_OSATOMIC_COMPARE_AND_SWAP_LONG )
+
+# BUILTIN
+CHECK_C_SOURCE_COMPILES( "
+volatile int a;
+int main(int argc, char *argv[]) {
+  (void)__sync_bool_compare_and_swap(&a, 1, 2);
+  return 0;
+}
+" HAVE_SYNC_BOOL_COMPARE_AND_SWAP_INT )
+
+CHECK_C_SOURCE_COMPILES( "
+volatile long a;
+int main(int argc, char *argv[]) {
+  (void)__sync_bool_compare_and_swap(&a, 1, 2);
+  return 0;
+}
+" HAVE_SYNC_BOOL_COMPARE_AND_SWAP_LONG )
diff --git a/runtime/cmake/Modules/DefineCompilerFlags.cmake b/runtime/cmake/Modules/DefineCompilerFlags.cmake
new file mode 100644
index 0000000..9e262b9
--- /dev/null
+++ b/runtime/cmake/Modules/DefineCompilerFlags.cmake
@@ -0,0 +1,6 @@
+# Define compiler flags
+
+if( CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX )
+  #ADD_DEFINITIONS( -Wall -W -Werror -pedantic )
+  ADD_DEFINITIONS( -std=c99 -Wall -Wextra -W -pedantic -Wno-unused-parameter )
+endif( CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX )
diff --git a/runtime/cmake/Modules/MacroAddCheckTest.cmake b/runtime/cmake/Modules/MacroAddCheckTest.cmake
new file mode 100644
index 0000000..a139121
--- /dev/null
+++ b/runtime/cmake/Modules/MacroAddCheckTest.cmake
@@ -0,0 +1,12 @@
+# - macro_add_check_test(test_name test_source linklib1 ... linklibN)
+
+ENABLE_TESTING()
+include(CTest)
+set(CMAKE_C_FLAGS_PROFILING "-g -pg")
+
+macro (MACRO_ADD_CHECK_TEST _testName _testSource)
+  add_executable(${_testName} ${_testSource})
+  target_link_libraries(${_testName} ${ARGN})
+  get_target_property(_targetLocation ${_testName} LOCATION) 
+  add_test(${_testName} ${_targetLocation})
+endmacro (MACRO_ADD_CHECK_TEST)
diff --git a/runtime/cmake/Modules/MacroEnsureOutOfSourceBuild.cmake b/runtime/cmake/Modules/MacroEnsureOutOfSourceBuild.cmake
new file mode 100644
index 0000000..a066936
--- /dev/null
+++ b/runtime/cmake/Modules/MacroEnsureOutOfSourceBuild.cmake
@@ -0,0 +1,18 @@
+# MACRO_ENSURE_OUT_OF_SOURCE_BUILD(<errorMessage>)
+
+macro( MACRO_ENSURE_OUT_OF_SOURCE_BUILD _errorMessage )
+
+string( COMPARE EQUAL "${CMAKE_SOURCE_DIR}" "${CMAKE_BINARY_DIR}" _insource )
+if( _insource )
+ message( SEND_ERROR "${_errorMessage}" )
+ message( FATAL_ERROR
+ "In-source builds are not allowed.
+ CMake would overwrite the makefiles distributed with Compiler-RT.
+ Please create a directory and run cmake from there, passing the path
+ to this source directory as the last argument.
+ This process created the file `CMakeCache.txt' and the directory `CMakeFiles'.
+ Please delete them."
+ )
+endif( _insource )
+
+endmacro( MACRO_ENSURE_OUT_OF_SOURCE_BUILD )
diff --git a/runtime/cmake/config.h.cmake b/runtime/cmake/config.h.cmake
new file mode 100644
index 0000000..307e277
--- /dev/null
+++ b/runtime/cmake/config.h.cmake
@@ -0,0 +1,12 @@
+#cmakedefine HAVE_SYS_BYTEORDER_H ${HAVE_SYS_BYTEORDER}
+#cmakedefine HAVE_AVAILABILITY_MACROS_H ${HAVE_AVAILABILITY_MACROS_H}
+#cmakedefine HAVE_TARGET_CONDITIONALS_H ${HAVE_TARGET_CONDITIONALS_H}
+#cmakedefine HAVE_LIBKERN_OSATOMIC_H ${HAVE_LIBKERN_OSATOMIC_H}
+
+#cmakedefine HAVE_SYSCONF ${HAVE_SYSCONF}
+
+#cmakedefine HAVE_OSATOMIC_COMPARE_AND_SWAP_INT ${HAVE_OSATOMIC_COMPARE_AND_SWAP_INT}
+#cmakedefine HAVE_OSATOMIC_COMPARE_AND_SWAP_LONG ${HAVE_OSATOMIC_COMPARE_AND_SWAP_LONG}
+
+#cmakedefine HAVE_SYNC_BOOL_COMPARE_AND_SWAP_INT ${HAVE_SYNC_BOOL_COMPARE_AND_SWAP_INT}
+#cmakedefine HAVE_SYNC_BOOL_COMPARE_AND_SWAP_LONG ${HAVE_SYNC_BOOL_COMPARE_AND_SWAP_LONG}
diff --git a/runtime/lib/CMakeLists.txt b/runtime/lib/CMakeLists.txt
new file mode 100644
index 0000000..e29474a
--- /dev/null
+++ b/runtime/lib/CMakeLists.txt
@@ -0,0 +1,81 @@
+#
+# Create a library called "CompilerRT" which includes the source files.
+
+#INCLUDE_DIRECTORIES(
+# ${CMAKE_CURRENT_BINARY_DIR}
+#)
+
+# Generic functions needed for each architecture
+# libcompiler_rt.Generic.a    libcompiler_rt.Optimized.a
+
+# Generic
+SET( Generic_SRCS
+ absvdi2.c absvsi2.c addvdi3.c addvsi3.c ashldi3.c ashrdi3.c
+ clzdi2.c clzsi2.c cmpdi2.c ctzdi2.c ctzsi2.c
+ divdc3.c divdi3.c divsc3.c ffsdi2.c
+ fixdfdi.c fixsfdi.c fixunsdfdi.c fixunsdfsi.c fixunssfdi.c
+ fixunssfsi.c floatdidf.c floatdisf.c floatundidf.c floatundisf.c
+ gcc_personality_v0.c lshrdi3.c moddi3.c muldc3.c muldi3.c
+ mulsc3.c mulvdi3.c mulvsi3.c negdi2.c negvdi2.c negvsi2.c
+ paritydi2.c paritysi2.c popcountdi2.c popcountsi2.c powidf2.c
+ powisf2.c subvdi3.c subvsi3.c ucmpdi2.c udivdi3.c
+ udivmoddi4.c umoddi3.c apple_versioning.c eprintf.c
+ )
+
+# Optimized functions for each architecture
+
+# Commenting out for the min until the basics are working first.
+# ADD_SUBDIRECTORY( ppc )
+# ADD_SUBDIRECTORY( x86_64 )
+# ADD_SUBDIRECTORY( i386 )
+# ADD_SUBDIRECTORY( arm )
+
+# List of functions needed for each architecture.
+SET( i386_Functions
+ divxc3.c fixunsxfdi.c fixunsxfsi.c fixxfdi.c floatdixf.c
+ floatundixf.c mulxc3.c powixf2.c clear_cache.c enable_execute_stack.c 
+ )
+
+SET( x86_64_Functions
+ absvti2.c addvti3.c ashlti3.c ashrti3.c clzti2.c cmpti2.c
+ ctzti2.c divti3.c divxc3.c ffsti2.c fixdfti.c fixsfti.c
+ fixunsdfti.c fixunssfti.c fixunsxfdi.c fixunsxfsi.c
+ fixunsxfti.c fixxfdi.c fixxfti.c floatdixf.c floattidf.c
+ floattisf.c floattixf.c floatundixf.c floatuntidf.c
+ floatuntisf.c floatuntixf.c lshrti3.c modti3.c multi3.c
+ mulvti3.c mulxc3.c negti2.c negvti2.c parityti2.c
+ popcountti2.c powixf2.c subvti3.c ucmpti2.c udivmodti4.c
+ udivti3.c umodti3.c clear_cache.c enable_execute_stack.c
+ )
+
+SET( PPC_Functions
+ divtc3.c fixtfdi.c fixunstfdi.c floatditf.c floatunditf.c
+ gcc_qadd.c gcc_qdiv.c gcc_qmul.c gcc_qsub.c multc3.c
+ powitf2.c restFP.c saveFP.c trampoline_setup.c
+ clear_cache.c enable_execute_stack.c
+ )
+
+SET( ARM_Functions
+ adddf3vfp.c addsf3vfp.c bswapdi2.c bswapsi2.c divdf3vfp.c
+ divsf3vfp.c eqdf2vfp.c eqsf2vfp.c extendsfdf2vfp.c
+ fixdfsivfp.c fixsfsivfp.c fixunsdfsivfp.c fixunssfsivfp.c
+ floatsidfvfp.c floatsisfvfp.c floatunssidfvfp.c floatunssisfvfp.c
+ gedf2vfp.c gesf2vfp.c gtdf2vfp.c gtsf2vfp.c
+ ledf2vfp.c lesf2vfp.c ltdf2vfp.c ltsf2vfp.c
+ muldf3vfp.c mulsf3vfp.c
+ nedf2vfp.c negdf2vfp.c negsf2vfp.c nesf2vfp.c
+ subdf3vfp.c subsf3vfp.c truncdfsf2vfp.c unorddf2vfp.c unordsf2vfp.c
+ modsi3.c umodsi3.c udivsi3.c divsi3.c switch.c
+ )
+
+#FOREACH( LOOP_VAR ${Achitectures} )
+# See ARCHIVE_OUTPUT_DIRECTORY docs.
+#${CMAKE_ARCHIVE_OUTPUT_DIRECTORY}/${LOOP_VAR}
+#ENDFOREACH
+
+ADD_LIBRARY( ${PROJECT_NAME}-Generic STATIC ${Generic_SRCS} )
+#ADD_LIBRARY( ${PROJECT_NAME}-i386 STATIC ${i386_Functions} )
+
+# [[debug|optimized|general]
+#TARGET_LINK_LIBRARIES( ${PROJECT_NAME} ${PROJECT_NAME}-Common optimized ${PROJECT_NAME}-i386 )
+
diff --git a/runtime/lib/Makefile.mk b/runtime/lib/Makefile.mk
new file mode 100644
index 0000000..1ed8c11
--- /dev/null
+++ b/runtime/lib/Makefile.mk
@@ -0,0 +1,17 @@
+#===- 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 := i386 ppc x86_64 arm
+
+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/runtime/lib/absvdi2.c b/runtime/lib/absvdi2.c
new file mode 100644
index 0000000..396802c
--- /dev/null
+++ b/runtime/lib/absvdi2.c
@@ -0,0 +1,30 @@
+/*===-- absvdi2.c - Implement __absvdi2 -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ *===----------------------------------------------------------------------===
+ *
+ * This file implements __absvdi2 for the compiler_rt library.
+ *
+ *===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+#include <stdlib.h>
+
+/* Returns: absolute value */
+
+/* Effects: aborts if abs(x) < 0 */
+
+di_int
+__absvdi2(di_int a)
+{
+    const int N = (int)(sizeof(di_int) * CHAR_BIT);
+    if (a == ((di_int)1 << (N-1)))
+        abort();
+    const di_int t = a >> (N - 1);
+    return (a ^ t) - t;
+}
diff --git a/runtime/lib/absvsi2.c b/runtime/lib/absvsi2.c
new file mode 100644
index 0000000..0c08bf0
--- /dev/null
+++ b/runtime/lib/absvsi2.c
@@ -0,0 +1,30 @@
+/* ===-- absvsi2.c - Implement __absvsi2 -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __absvsi2 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */ 
+
+#include "int_lib.h"
+#include <stdlib.h>
+
+/* Returns: absolute value */
+
+/* Effects: aborts if abs(x) < 0 */
+
+si_int
+__absvsi2(si_int a)
+{
+    const int N = (int)(sizeof(si_int) * CHAR_BIT);
+    if (a == (1 << (N-1)))
+        abort();
+    const si_int t = a >> (N - 1);
+    return (a ^ t) - t;
+}
diff --git a/runtime/lib/absvti2.c b/runtime/lib/absvti2.c
new file mode 100644
index 0000000..c71275e
--- /dev/null
+++ b/runtime/lib/absvti2.c
@@ -0,0 +1,34 @@
+/* ===-- absvti2.c - Implement __absvdi2 -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __absvti2 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#if __x86_64
+
+#include "int_lib.h"
+#include <stdlib.h>
+
+/* Returns: absolute value */
+
+/* Effects: aborts if abs(x) < 0 */
+
+ti_int
+__absvti2(ti_int a)
+{
+    const int N = (int)(sizeof(ti_int) * CHAR_BIT);
+    if (a == ((ti_int)1 << (N-1)))
+        abort();
+    const ti_int s = a >> (N - 1);
+    return (a ^ s) - s;
+}
+
+#endif
diff --git a/runtime/lib/addvdi3.c b/runtime/lib/addvdi3.c
new file mode 100644
index 0000000..8b885f5
--- /dev/null
+++ b/runtime/lib/addvdi3.c
@@ -0,0 +1,37 @@
+/* ===-- addvdi3.c - Implement __addvdi3 -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __addvdi3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+#include <stdlib.h>
+
+/* Returns: a + b */
+
+/* Effects: aborts if a + b overflows */
+
+di_int
+__addvdi3(di_int a, di_int b)
+{
+    di_int s = a + b;
+    if (b >= 0)
+    {
+        if (s < a)
+            abort();
+    }
+    else
+    {
+        if (s >= a)
+            abort();
+    }
+    return s;
+}
diff --git a/runtime/lib/addvsi3.c b/runtime/lib/addvsi3.c
new file mode 100644
index 0000000..603c680
--- /dev/null
+++ b/runtime/lib/addvsi3.c
@@ -0,0 +1,37 @@
+/* ===-- addvsi3.c - Implement __addvsi3 -----------------------------------===
+ *
+ *                    The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __addvsi3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+#include <stdlib.h>
+
+/* Returns: a + b */
+
+/* Effects: aborts if a + b overflows */
+
+si_int
+__addvsi3(si_int a, si_int b)
+{
+    si_int s = a + b;
+    if (b >= 0)
+    {
+        if (s < a)
+            abort();
+    }
+    else
+    {
+        if (s >= a)
+            abort();
+    }
+    return s;
+}
diff --git a/runtime/lib/addvti3.c b/runtime/lib/addvti3.c
new file mode 100644
index 0000000..afc3e3b
--- /dev/null
+++ b/runtime/lib/addvti3.c
@@ -0,0 +1,41 @@
+/* ===-- addvti3.c - Implement __addvti3 -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __addvti3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#if __x86_64
+
+#include "int_lib.h"
+#include <stdlib.h>
+
+/* Returns: a + b */
+
+/* Effects: aborts if a + b overflows */
+
+ti_int
+__addvti3(ti_int a, ti_int b)
+{
+    ti_int s = a + b;
+    if (b >= 0)
+    {
+        if (s < a)
+            abort();
+    }
+    else
+    {
+        if (s >= a)
+            abort();
+    }
+    return s;
+}
+
+#endif
diff --git a/runtime/lib/apple_versioning.c b/runtime/lib/apple_versioning.c
new file mode 100644
index 0000000..0360026
--- /dev/null
+++ b/runtime/lib/apple_versioning.c
@@ -0,0 +1,150 @@
+/* ===-- apple_versioning.c - Adds versioning symbols for ld ---------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+
+
+#if __APPLE__
+  #if __arm__
+    #define NOT_HERE_BEFORE_10_6(sym) 
+  #elif __ppc__
+    #define NOT_HERE_BEFORE_10_6(sym) \
+        extern const char sym##_tmp3 __asm("$ld$hide$os10.3$_" #sym ); \
+            __attribute__((visibility("default"))) const char sym##_tmp3 = 0; \
+         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; 
+  #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; 
+  #endif /* __ppc__ */
+
+
+/* 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__ */
+
+#else /* !__APPLE__ */
+
+extern int avoid_empty_file;
+
+#endif /* !__APPLE__*/
diff --git a/runtime/lib/arm/CMakeLists.txt b/runtime/lib/arm/CMakeLists.txt
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/runtime/lib/arm/CMakeLists.txt
diff --git a/runtime/lib/arm/Makefile.mk b/runtime/lib/arm/Makefile.mk
new file mode 100644
index 0000000..1dade0f
--- /dev/null
+++ b/runtime/lib/arm/Makefile.mk
@@ -0,0 +1,19 @@
+#===- lib/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.
+#
+#===------------------------------------------------------------------------===#
+
+SubDirs := 
+OnlyArchs := armv6 armv7
+
+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/runtime/lib/arm/adddf3vfp.S b/runtime/lib/arm/adddf3vfp.S
new file mode 100644
index 0000000..1b49daa
--- /dev/null
+++ b/runtime/lib/arm/adddf3vfp.S
@@ -0,0 +1,23 @@
+//===-- adddf3vfp.S - Implement adddf3vfp ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+//
+DEFINE_COMPILERRT_FUNCTION(__adddf3vfp)
+	fmdrr	d6, r0, r1		// move first param from r0/r1 pair into d6
+	fmdrr	d7, r2, r3		// move second param from r2/r3 pair into d7
+	faddd	d6, d6, d7		
+	fmrrd	r0, r1, d6		// move result back to r0/r1 pair
+	bx	lr
diff --git a/runtime/lib/arm/addsf3vfp.S b/runtime/lib/arm/addsf3vfp.S
new file mode 100644
index 0000000..292d052
--- /dev/null
+++ b/runtime/lib/arm/addsf3vfp.S
@@ -0,0 +1,23 @@
+//===-- addsf3vfp.S - Implement addsf3vfp ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+//
+DEFINE_COMPILERRT_FUNCTION(__addsf3vfp)
+	fmsr	s14, r0		// move first param from r0 into float register
+	fmsr	s15, r1		// move second param from r1 into float register
+	fadds	s14, s14, s15
+	fmrs	r0, s14		// move result back to r0
+	bx	lr
diff --git a/runtime/lib/arm/bswapdi2.S b/runtime/lib/arm/bswapdi2.S
new file mode 100644
index 0000000..2a3465b
--- /dev/null
+++ b/runtime/lib/arm/bswapdi2.S
@@ -0,0 +1,22 @@
+//===------- bswapdi2 - Implement bswapdi2 ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+//
+// extern uint64_t __bswapdi2(uint64_t);
+//
+// Reverse all the bytes in a 64-bit integer.
+//
+DEFINE_COMPILERRT_FUNCTION(__bswapdi2)
+	rev	r2, r1		// reverse bytes in high 32-bits into temp2
+	rev	r3, r0		// reverse bytes in low 32-bit into temp3
+	mov	r0, r2		// set low 32-bits of result to temp2
+	mov	r1, r3		// set high 32-bits of result to temp3
+	bx	lr
diff --git a/runtime/lib/arm/bswapsi2.S b/runtime/lib/arm/bswapsi2.S
new file mode 100644
index 0000000..dd9faf1
--- /dev/null
+++ b/runtime/lib/arm/bswapsi2.S
@@ -0,0 +1,19 @@
+//===------- bswapsi2 - Implement bswapsi2 ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+//
+// extern uint32_t __bswapsi2(uint32_t);
+//
+// Reverse all the bytes in a 32-bit integer.
+//
+DEFINE_COMPILERRT_FUNCTION(__bswapsi2)
+	rev	r0, r0		// reverse bytes in parameter and put into result register
+	bx	lr
diff --git a/runtime/lib/arm/divdf3vfp.S b/runtime/lib/arm/divdf3vfp.S
new file mode 100644
index 0000000..a809427
--- /dev/null
+++ b/runtime/lib/arm/divdf3vfp.S
@@ -0,0 +1,23 @@
+//===-- divdf3vfp.S - Implement divdf3vfp ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+//
+DEFINE_COMPILERRT_FUNCTION(__divdf3vfp)
+	fmdrr	d6, r0, r1		// move first param from r0/r1 pair into d6
+	fmdrr	d7, r2, r3		// move second param from r2/r3 pair into d7
+	fdivd	d5, d6, d7		
+	fmrrd	r0, r1, d5		// move result back to r0/r1 pair
+	bx	lr
diff --git a/runtime/lib/arm/divsf3vfp.S b/runtime/lib/arm/divsf3vfp.S
new file mode 100644
index 0000000..67b8a0c
--- /dev/null
+++ b/runtime/lib/arm/divsf3vfp.S
@@ -0,0 +1,23 @@
+//===-- divsf3vfp.S - Implement divsf3vfp ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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.
+//
+DEFINE_COMPILERRT_FUNCTION(__divsf3vfp)
+	fmsr	s14, r0		// move first param from r0 into float register
+	fmsr	s15, r1		// move second param from r1 into float register
+	fdivs	s13, s14, s15
+	fmrs	r0, s13		// move result back to r0
+	bx	lr
diff --git a/runtime/lib/arm/eqdf2vfp.S b/runtime/lib/arm/eqdf2vfp.S
new file mode 100644
index 0000000..771d853
--- /dev/null
+++ b/runtime/lib/arm/eqdf2vfp.S
@@ -0,0 +1,26 @@
+//===-- eqdf2vfp.S - Implement eqdf2vfp -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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.
+//
+DEFINE_COMPILERRT_FUNCTION(__eqdf2vfp)
+	fmdrr	d6, r0, r1	// load r0/r1 pair in double register
+	fmdrr	d7, r2, r3	// load r2/r3 pair in double register
+	fcmpd	d6, d7		
+	fmstat
+	moveq	r0, #1		// set result register to 1 if equal
+	movne	r0, #0
+	bx	lr
diff --git a/runtime/lib/arm/eqsf2vfp.S b/runtime/lib/arm/eqsf2vfp.S
new file mode 100644
index 0000000..bf4cd1f
--- /dev/null
+++ b/runtime/lib/arm/eqsf2vfp.S
@@ -0,0 +1,27 @@
+//===-- eqsf2vfp.S - Implement eqsf2vfp -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+//
+DEFINE_COMPILERRT_FUNCTION(__eqsf2vfp)
+	fmsr	s14, r0     // move from GPR 0 to float register
+	fmsr	s15, r1	    // move from GPR 1 to float register
+	fcmps	s14, s15
+	fmstat
+	moveq	r0, #1      // set result register to 1 if equal
+	movne	r0, #0
+	bx	lr
+
diff --git a/runtime/lib/arm/extendsfdf2vfp.S b/runtime/lib/arm/extendsfdf2vfp.S
new file mode 100644
index 0000000..8df97b5
--- /dev/null
+++ b/runtime/lib/arm/extendsfdf2vfp.S
@@ -0,0 +1,23 @@
+//===-- extendsfdf2vfp.S - Implement extendsfdf2vfp -----------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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.
+//
+DEFINE_COMPILERRT_FUNCTION(__extendsfdf2vfp)
+	fmsr	s15, r0      // load float register from R0
+	fcvtds	d7, s15      // convert single to double
+	fmrrd	r0, r1, d7   // return result in r0/r1 pair
+	bx	lr
diff --git a/runtime/lib/arm/fixdfsivfp.S b/runtime/lib/arm/fixdfsivfp.S
new file mode 100644
index 0000000..70d8027
--- /dev/null
+++ b/runtime/lib/arm/fixdfsivfp.S
@@ -0,0 +1,23 @@
+//===-- fixdfsivfp.S - Implement fixdfsivfp -----------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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.
+//
+DEFINE_COMPILERRT_FUNCTION(__fixdfsivfp)
+	fmdrr	d7, r0, r1    // load double register from R0/R1
+	ftosizd	s15, d7       // convert double to 32-bit int into s15
+	fmrs	r0, s15	      // move s15 to result register
+	bx	lr
diff --git a/runtime/lib/arm/fixsfsivfp.S b/runtime/lib/arm/fixsfsivfp.S
new file mode 100644
index 0000000..17d016c
--- /dev/null
+++ b/runtime/lib/arm/fixsfsivfp.S
@@ -0,0 +1,23 @@
+//===-- fixsfsivfp.S - Implement fixsfsivfp -----------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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..
+//
+DEFINE_COMPILERRT_FUNCTION(__fixsfsivfp)
+	fmsr	s15, r0      // load float register from R0
+	ftosizs	s15, s15     // convert single to 32-bit int into s15
+	fmrs	r0, s15	     // move s15 to result register
+	bx	lr
diff --git a/runtime/lib/arm/fixunsdfsivfp.S b/runtime/lib/arm/fixunsdfsivfp.S
new file mode 100644
index 0000000..a7299f4
--- /dev/null
+++ b/runtime/lib/arm/fixunsdfsivfp.S
@@ -0,0 +1,24 @@
+//===-- fixunsdfsivfp.S - Implement fixunsdfsivfp -------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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.
+//
+DEFINE_COMPILERRT_FUNCTION(__fixunsdfsivfp)
+	fmdrr	d7, r0, r1    // load double register from R0/R1
+	ftouizd	s15, d7       // convert double to 32-bit int into s15
+	fmrs	r0, s15	      // move s15 to result register
+	bx	lr
diff --git a/runtime/lib/arm/fixunssfsivfp.S b/runtime/lib/arm/fixunssfsivfp.S
new file mode 100644
index 0000000..166a2ad
--- /dev/null
+++ b/runtime/lib/arm/fixunssfsivfp.S
@@ -0,0 +1,24 @@
+//===-- fixunssfsivfp.S - Implement fixunssfsivfp -------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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..
+//
+DEFINE_COMPILERRT_FUNCTION(__fixunssfsivfp)
+	fmsr	s15, r0      // load float register from R0
+	ftouizs	s15, s15     // convert single to 32-bit unsigned into s15
+	fmrs	r0, s15	     // move s15 to result register
+	bx	lr
diff --git a/runtime/lib/arm/floatsidfvfp.S b/runtime/lib/arm/floatsidfvfp.S
new file mode 100644
index 0000000..45bfa34
--- /dev/null
+++ b/runtime/lib/arm/floatsidfvfp.S
@@ -0,0 +1,23 @@
+//===-- floatsidfvfp.S - Implement floatsidfvfp ---------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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.
+//
+DEFINE_COMPILERRT_FUNCTION(__floatsidfvfp)
+	fmsr	s15, r0		   // move int to float register s15
+	fsitod	d7, s15        // convert 32-bit int in s15 to double in d7
+	fmrrd	r0, r1, d7     // move d7 to result register pair r0/r1
+	bx	lr
diff --git a/runtime/lib/arm/floatsisfvfp.S b/runtime/lib/arm/floatsisfvfp.S
new file mode 100644
index 0000000..1b74299
--- /dev/null
+++ b/runtime/lib/arm/floatsisfvfp.S
@@ -0,0 +1,23 @@
+//===-- floatsisfvfp.S - Implement floatsisfvfp ---------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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..
+//
+DEFINE_COMPILERRT_FUNCTION(__floatsisfvfp)
+	fmsr	s15, r0	     // move int to float register s15
+	fsitos	s15, s15     // convert 32-bit int in s15 to float in s15
+	fmrs	r0, s15      // move s15 to result register
+	bx	lr
diff --git a/runtime/lib/arm/floatunssidfvfp.S b/runtime/lib/arm/floatunssidfvfp.S
new file mode 100644
index 0000000..9866a66
--- /dev/null
+++ b/runtime/lib/arm/floatunssidfvfp.S
@@ -0,0 +1,23 @@
+//===-- floatunssidfvfp.S - Implement floatunssidfvfp ---------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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.
+//
+DEFINE_COMPILERRT_FUNCTION(__floatunssidfvfp)
+	fmsr	s15, r0		   // move int to float register s15
+	fuitod	d7, s15        // convert 32-bit int in s15 to double in d7
+	fmrrd	r0, r1, d7     // move d7 to result register pair r0/r1
+	bx	lr
diff --git a/runtime/lib/arm/floatunssisfvfp.S b/runtime/lib/arm/floatunssisfvfp.S
new file mode 100644
index 0000000..065742b
--- /dev/null
+++ b/runtime/lib/arm/floatunssisfvfp.S
@@ -0,0 +1,23 @@
+//===-- floatunssisfvfp.S - Implement floatunssisfvfp ---------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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..
+//
+DEFINE_COMPILERRT_FUNCTION(__floatunssisfvfp)
+	fmsr	s15, r0	     // move int to float register s15
+	fuitos 	s15, s15     // convert 32-bit int in s15 to float in s15
+	fmrs	r0, s15      // move s15 to result register
+	bx	lr
diff --git a/runtime/lib/arm/gedf2vfp.S b/runtime/lib/arm/gedf2vfp.S
new file mode 100644
index 0000000..cb8c716
--- /dev/null
+++ b/runtime/lib/arm/gedf2vfp.S
@@ -0,0 +1,26 @@
+//===-- gedf2vfp.S - Implement gedf2vfp -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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.
+//
+DEFINE_COMPILERRT_FUNCTION(__gedf2vfp)
+	fmdrr	d6, r0, r1	// load r0/r1 pair in double register
+	fmdrr	d7, r2, r3	// load r2/r3 pair in double register
+	fcmpd	d6, d7		
+	fmstat
+	movge	r0, #1      // set result register to 1 if greater than or equal
+	movlt	r0, #0
+	bx	lr
diff --git a/runtime/lib/arm/gesf2vfp.S b/runtime/lib/arm/gesf2vfp.S
new file mode 100644
index 0000000..24b66e1
--- /dev/null
+++ b/runtime/lib/arm/gesf2vfp.S
@@ -0,0 +1,27 @@
+//===-- gesf2vfp.S - Implement gesf2vfp -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+//
+DEFINE_COMPILERRT_FUNCTION(__gesf2vfp)
+	fmsr	s14, r0	    // move from GPR 0 to float register
+	fmsr	s15, r1	    // move from GPR 1 to float register
+	fcmps	s14, s15
+	fmstat
+	movge	r0, #1      // set result register to 1 if greater than or equal
+	movlt	r0, #0
+	bx	lr
+
diff --git a/runtime/lib/arm/gtdf2vfp.S b/runtime/lib/arm/gtdf2vfp.S
new file mode 100644
index 0000000..afd6d05
--- /dev/null
+++ b/runtime/lib/arm/gtdf2vfp.S
@@ -0,0 +1,26 @@
+//===-- gtdf2vfp.S - Implement gtdf2vfp -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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.
+//
+DEFINE_COMPILERRT_FUNCTION(__gtdf2vfp)
+	fmdrr	d6, r0, r1	// load r0/r1 pair in double register
+	fmdrr	d7, r2, r3	// load r2/r3 pair in double register
+	fcmpd	d6, d7		
+	fmstat
+	movgt	r0, #1		// set result register to 1 if equal
+	movle	r0, #0
+	bx	lr
diff --git a/runtime/lib/arm/gtsf2vfp.S b/runtime/lib/arm/gtsf2vfp.S
new file mode 100644
index 0000000..a4a03c6
--- /dev/null
+++ b/runtime/lib/arm/gtsf2vfp.S
@@ -0,0 +1,27 @@
+//===-- gtsf2vfp.S - Implement gtsf2vfp -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+//
+DEFINE_COMPILERRT_FUNCTION(__gtsf2vfp)
+	fmsr	s14, r0		// move from GPR 0 to float register
+	fmsr	s15, r1		// move from GPR 1 to float register
+	fcmps	s14, s15
+	fmstat
+	movgt	r0, #1		// set result register to 1 if equal
+	movle	r0, #0
+	bx	lr
+
diff --git a/runtime/lib/arm/ledf2vfp.S b/runtime/lib/arm/ledf2vfp.S
new file mode 100644
index 0000000..188dc6a
--- /dev/null
+++ b/runtime/lib/arm/ledf2vfp.S
@@ -0,0 +1,26 @@
+//===-- ledf2vfp.S - Implement ledf2vfp -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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.
+//
+DEFINE_COMPILERRT_FUNCTION(__ledf2vfp)
+	fmdrr	d6, r0, r1	// load r0/r1 pair in double register
+	fmdrr	d7, r2, r3	// load r2/r3 pair in double register
+	fcmpd	d6, d7		
+	fmstat
+	movls	r0, #1		// set result register to 1 if equal
+	movhi	r0, #0
+	bx	lr
diff --git a/runtime/lib/arm/lesf2vfp.S b/runtime/lib/arm/lesf2vfp.S
new file mode 100644
index 0000000..fe3ec64
--- /dev/null
+++ b/runtime/lib/arm/lesf2vfp.S
@@ -0,0 +1,27 @@
+//===-- lesf2vfp.S - Implement lesf2vfp -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+//
+DEFINE_COMPILERRT_FUNCTION(__lesf2vfp)
+	fmsr	s14, r0     // move from GPR 0 to float register
+	fmsr	s15, r1     // move from GPR 1 to float register
+	fcmps	s14, s15
+	fmstat
+	movls	r0, #1      // set result register to 1 if equal
+	movhi	r0, #0
+	bx	lr
+
diff --git a/runtime/lib/arm/ltdf2vfp.S b/runtime/lib/arm/ltdf2vfp.S
new file mode 100644
index 0000000..15a799b
--- /dev/null
+++ b/runtime/lib/arm/ltdf2vfp.S
@@ -0,0 +1,26 @@
+//===-- ltdf2vfp.S - Implement ltdf2vfp -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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.
+//
+DEFINE_COMPILERRT_FUNCTION(__ltdf2vfp)
+	fmdrr	d6, r0, r1	// load r0/r1 pair in double register
+	fmdrr	d7, r2, r3	// load r2/r3 pair in double register
+	fcmpd	d6, d7		
+	fmstat
+	movmi	r0, #1		// set result register to 1 if equal
+	movpl	r0, #0
+	bx	lr
diff --git a/runtime/lib/arm/ltsf2vfp.S b/runtime/lib/arm/ltsf2vfp.S
new file mode 100644
index 0000000..6ae0658
--- /dev/null
+++ b/runtime/lib/arm/ltsf2vfp.S
@@ -0,0 +1,27 @@
+//===-- ltsf2vfp.S - Implement ltsf2vfp -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+//
+DEFINE_COMPILERRT_FUNCTION(__ltsf2vfp)
+	fmsr	s14, r0     // move from GPR 0 to float register
+	fmsr	s15, r1     // move from GPR 1 to float register
+	fcmps	s14, s15
+	fmstat
+	movmi	r0, #1      // set result register to 1 if equal
+	movpl	r0, #0
+	bx	lr
+
diff --git a/runtime/lib/arm/muldf3vfp.S b/runtime/lib/arm/muldf3vfp.S
new file mode 100644
index 0000000..bb0fd43
--- /dev/null
+++ b/runtime/lib/arm/muldf3vfp.S
@@ -0,0 +1,23 @@
+//===-- muldf3vfp.S - Implement muldf3vfp ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+//
+DEFINE_COMPILERRT_FUNCTION(__muldf3vfp)
+	fmdrr	d6, r0, r1		// move first param from r0/r1 pair into d6
+	fmdrr	d7, r2, r3		// move second param from r2/r3 pair into d7
+	fmuld	d6, d6, d7		
+	fmrrd	r0, r1, d6		// move result back to r0/r1 pair
+	bx	lr
diff --git a/runtime/lib/arm/mulsf3vfp.S b/runtime/lib/arm/mulsf3vfp.S
new file mode 100644
index 0000000..69396a1
--- /dev/null
+++ b/runtime/lib/arm/mulsf3vfp.S
@@ -0,0 +1,23 @@
+//===-- mulsf3vfp.S - Implement mulsf3vfp ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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.
+//
+DEFINE_COMPILERRT_FUNCTION(__mulsf3vfp)
+	fmsr	s14, r0		// move first param from r0 into float register
+	fmsr	s15, r1		// move second param from r1 into float register
+	fmuls	s13, s14, s15
+	fmrs	r0, s13		// move result back to r0
+	bx	lr
diff --git a/runtime/lib/arm/nedf2vfp.S b/runtime/lib/arm/nedf2vfp.S
new file mode 100644
index 0000000..a445cda
--- /dev/null
+++ b/runtime/lib/arm/nedf2vfp.S
@@ -0,0 +1,26 @@
+//===-- nedf2vfp.S - Implement nedf2vfp -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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.
+//
+DEFINE_COMPILERRT_FUNCTION(__nedf2vfp)
+	fmdrr	d6, r0, r1	// load r0/r1 pair in double register
+	fmdrr	d7, r2, r3	// load r2/r3 pair in double register
+	fcmpd	d6, d7		
+	fmstat
+	movne	r0, #1		// set result register to 0 if unequal
+	moveq	r0, #0
+	bx	lr
diff --git a/runtime/lib/arm/negdf2vfp.S b/runtime/lib/arm/negdf2vfp.S
new file mode 100644
index 0000000..9cbfc6a
--- /dev/null
+++ b/runtime/lib/arm/negdf2vfp.S
@@ -0,0 +1,20 @@
+//===-- negdf2vfp.S - Implement negdf2vfp ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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.
+//
+DEFINE_COMPILERRT_FUNCTION(__negdf2vfp)
+	eor	r1, r1, #-2147483648	// flip sign bit on double in r0/r1 pair
+	bx	lr
diff --git a/runtime/lib/arm/negsf2vfp.S b/runtime/lib/arm/negsf2vfp.S
new file mode 100644
index 0000000..6d78ef1
--- /dev/null
+++ b/runtime/lib/arm/negsf2vfp.S
@@ -0,0 +1,20 @@
+//===-- negsf2vfp.S - Implement negsf2vfp ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+//
+DEFINE_COMPILERRT_FUNCTION(__negsf2vfp)
+	eor	r0, r0, #-2147483648	// flip sign bit on float in r0
+	bx	lr
diff --git a/runtime/lib/arm/nesf2vfp.S b/runtime/lib/arm/nesf2vfp.S
new file mode 100644
index 0000000..62d80a5
--- /dev/null
+++ b/runtime/lib/arm/nesf2vfp.S
@@ -0,0 +1,27 @@
+//===-- nesf2vfp.S - Implement nesf2vfp -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+//
+DEFINE_COMPILERRT_FUNCTION(__nesf2vfp)
+	fmsr	s14, r0	    // move from GPR 0 to float register
+	fmsr	s15, r1	    // move from GPR 1 to float register
+	fcmps	s14, s15
+	fmstat
+	movne	r0, #1      // set result register to 1 if unequal
+	moveq	r0, #0
+	bx	lr
+
diff --git a/runtime/lib/arm/restore_vfp_d8_d15_regs.S b/runtime/lib/arm/restore_vfp_d8_d15_regs.S
new file mode 100644
index 0000000..3c742f6
--- /dev/null
+++ b/runtime/lib/arm/restore_vfp_d8_d15_regs.S
@@ -0,0 +1,36 @@
+//===-- save_restore_regs.S - Implement save/restore* ---------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+//
+DEFINE_COMPILERRT_PRIVATE_FUNCTION(__restore_vfp_d8_d15_regs)
+	vldmia	sp!, {d8-d15}           // pop registers d8-d15 off stack
+	bx      lr                      // return to prolog
+
+
+
+	// tell linker it can break up file at label boundaries
+	.subsections_via_symbols
+
diff --git a/runtime/lib/arm/save_vfp_d8_d15_regs.S b/runtime/lib/arm/save_vfp_d8_d15_regs.S
new file mode 100644
index 0000000..97ceac1
--- /dev/null
+++ b/runtime/lib/arm/save_vfp_d8_d15_regs.S
@@ -0,0 +1,34 @@
+//===-- save_restore_regs.S - Implement save/restore* ---------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+//
+DEFINE_COMPILERRT_PRIVATE_FUNCTION(__save_vfp_d8_d15_regs)
+	vstmdb	sp!, {d8-d15}           // push registers d8-d15 onto stack
+	bx      lr                      // return to prolog
+
+	// tell linker it can break up file at label boundaries
+	.subsections_via_symbols
+
diff --git a/runtime/lib/arm/subdf3vfp.S b/runtime/lib/arm/subdf3vfp.S
new file mode 100644
index 0000000..b9cb29e
--- /dev/null
+++ b/runtime/lib/arm/subdf3vfp.S
@@ -0,0 +1,23 @@
+//===-- subdf3vfp.S - Implement subdf3vfp ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+//
+DEFINE_COMPILERRT_FUNCTION(__subdf3vfp)
+	fmdrr	d6, r0, r1		// move first param from r0/r1 pair into d6
+	fmdrr	d7, r2, r3		// move second param from r2/r3 pair into d7
+	fsubd	d6, d6, d7		
+	fmrrd	r0, r1, d6		// move result back to r0/r1 pair
+	bx	lr
diff --git a/runtime/lib/arm/subsf3vfp.S b/runtime/lib/arm/subsf3vfp.S
new file mode 100644
index 0000000..b6942bd
--- /dev/null
+++ b/runtime/lib/arm/subsf3vfp.S
@@ -0,0 +1,24 @@
+//===-- subsf3vfp.S - Implement subsf3vfp ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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.
+//
+DEFINE_COMPILERRT_FUNCTION(__subsf3vfp)
+	fmsr	s14, r0		// move first param from r0 into float register
+	fmsr	s15, r1		// move second param from r1 into float register
+	fsubs	s14, s14, s15
+	fmrs	r0, s14		// move result back to r0
+	bx	lr
diff --git a/runtime/lib/arm/switch16.S b/runtime/lib/arm/switch16.S
new file mode 100644
index 0000000..7255401
--- /dev/null
+++ b/runtime/lib/arm/switch16.S
@@ -0,0 +1,43 @@
+//===-- switch.S - Implement switch* --------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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.
+//
+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
+	ldrshcc r0, [r0, #1]            // load 16-bit element if r0 is in range
+	add     ip, lr, ip, lsl #1      // compute address of last element in table
+	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
+
+	// tell linker it can break up file at label boundaries
+	.subsections_via_symbols
diff --git a/runtime/lib/arm/switch32.S b/runtime/lib/arm/switch32.S
new file mode 100644
index 0000000..2a36fef
--- /dev/null
+++ b/runtime/lib/arm/switch32.S
@@ -0,0 +1,45 @@
+//===-- switch.S - Implement switch* --------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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.
+//
+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
+	ldrcc   r0, [r0, #3]             // load 32-bit element if r0 is in range
+	add     ip, lr, ip, lsl #2       // compute address of last element in table
+	ldrcs   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
+
+
+	// tell linker it can break up file at label boundaries
+	.subsections_via_symbols
+
diff --git a/runtime/lib/arm/switch8.S b/runtime/lib/arm/switch8.S
new file mode 100644
index 0000000..530acfd
--- /dev/null
+++ b/runtime/lib/arm/switch8.S
@@ -0,0 +1,42 @@
+//===-- switch.S - Implement switch* --------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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.
+//
+DEFINE_COMPILERRT_PRIVATE_FUNCTION(__switch8)
+	ldrb    ip, [lr, #-1]           // get first byte in table
+	cmp     r0, ip                  // signed compare with index
+	ldrsbcc 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
+
+	// tell linker it can break up file at label boundaries
+	.subsections_via_symbols
+
diff --git a/runtime/lib/arm/switchu8.S b/runtime/lib/arm/switchu8.S
new file mode 100644
index 0000000..e161c41
--- /dev/null
+++ b/runtime/lib/arm/switchu8.S
@@ -0,0 +1,42 @@
+//===-- switch.S - Implement switch* --------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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.
+//
+DEFINE_COMPILERRT_PRIVATE_FUNCTION(__switchu8)
+	ldrb    ip, [lr, #-1]           // get first byte in table
+	cmp     r0, ip                  // compare with index
+	ldrbcc  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
+
+	// tell linker it can break up file at label boundaries
+	.subsections_via_symbols
+
diff --git a/runtime/lib/arm/sync_synchronize.S b/runtime/lib/arm/sync_synchronize.S
new file mode 100644
index 0000000..40b584e
--- /dev/null
+++ b/runtime/lib/arm/sync_synchronize.S
@@ -0,0 +1,33 @@
+//===-- sync_synchronize - Implement memory barrier * ----------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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__
+
+DEFINE_COMPILERRT_PRIVATE_FUNCTION(__sync_synchronize)
+	stmfd	sp!, {r7, lr}
+	add		r7, sp, #0
+	bl		_OSMemoryBarrier
+	ldmfd	sp!, {r7, pc}
+
+	// tell linker it can break up file at label boundaries
+	.subsections_via_symbols
+		
+#endif
diff --git a/runtime/lib/arm/truncdfsf2vfp.S b/runtime/lib/arm/truncdfsf2vfp.S
new file mode 100644
index 0000000..26f8b82
--- /dev/null
+++ b/runtime/lib/arm/truncdfsf2vfp.S
@@ -0,0 +1,23 @@
+//===-- truncdfsf2vfp.S - Implement truncdfsf2vfp -------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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.
+//
+DEFINE_COMPILERRT_FUNCTION(__truncdfsf2vfp)
+	fmdrr	d7, r0, r1   // load double from r0/r1 pair
+	fcvtsd	s15, d7      // convert double to single (trucate precision)
+	fmrs	r0, s15      // return result in r0
+	bx	lr
diff --git a/runtime/lib/arm/unorddf2vfp.S b/runtime/lib/arm/unorddf2vfp.S
new file mode 100644
index 0000000..6b4bcb6
--- /dev/null
+++ b/runtime/lib/arm/unorddf2vfp.S
@@ -0,0 +1,26 @@
+//===-- unorddf2vfp.S - Implement unorddf2vfp ------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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.
+//
+DEFINE_COMPILERRT_FUNCTION(__unorddf2vfp)
+	fmdrr	d6, r0, r1	// load r0/r1 pair in double register
+	fmdrr	d7, r2, r3	// load r2/r3 pair in double register
+	fcmpd	d6, d7		
+	fmstat
+	movvs	r0, #1      // set result register to 1 if "overflow" (any NaNs)
+	movvc	r0, #0
+	bx	lr
diff --git a/runtime/lib/arm/unordsf2vfp.S b/runtime/lib/arm/unordsf2vfp.S
new file mode 100644
index 0000000..811d8cb
--- /dev/null
+++ b/runtime/lib/arm/unordsf2vfp.S
@@ -0,0 +1,27 @@
+//===-- unordsf2vfp.S - Implement unordsf2vfp -----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+//
+DEFINE_COMPILERRT_FUNCTION(__unordsf2vfp)
+	fmsr	s14, r0     // move from GPR 0 to float register
+	fmsr	s15, r1	    // move from GPR 1 to float register
+	fcmps	s14, s15
+	fmstat
+	movvs	r0, #1      // set result register to 1 if "overflow" (any NaNs)
+	movvc	r0, #0
+	bx	lr
+
diff --git a/runtime/lib/ashldi3.c b/runtime/lib/ashldi3.c
new file mode 100644
index 0000000..993f71c
--- /dev/null
+++ b/runtime/lib/ashldi3.c
@@ -0,0 +1,41 @@
+/* ====-- ashldi3.c - Implement __ashldi3 -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. 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 */
+
+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/runtime/lib/ashlti3.c b/runtime/lib/ashlti3.c
new file mode 100644
index 0000000..317de66
--- /dev/null
+++ b/runtime/lib/ashlti3.c
@@ -0,0 +1,45 @@
+/* ===-- ashlti3.c - Implement __ashlti3 -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __ashlti3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#if __x86_64
+
+#include "int_lib.h"
+
+/* Returns: a << b */
+
+/* Precondition:  0 <= b < bits_in_tword */
+
+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 /* __x86_64 */
diff --git a/runtime/lib/ashrdi3.c b/runtime/lib/ashrdi3.c
new file mode 100644
index 0000000..8e27a11
--- /dev/null
+++ b/runtime/lib/ashrdi3.c
@@ -0,0 +1,42 @@
+/*===-- ashrdi3.c - Implement __ashrdi3 -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. 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 */
+
+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/runtime/lib/ashrti3.c b/runtime/lib/ashrti3.c
new file mode 100644
index 0000000..4eab247
--- /dev/null
+++ b/runtime/lib/ashrti3.c
@@ -0,0 +1,46 @@
+/* ===-- ashrti3.c - Implement __ashrti3 -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __ashrti3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#if __x86_64
+
+#include "int_lib.h"
+
+/* Returns: arithmetic a >> b */
+
+/* Precondition:  0 <= b < bits_in_tword */
+
+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 /* __x86_64 */
diff --git a/runtime/lib/assembly.h b/runtime/lib/assembly.h
new file mode 100644
index 0000000..c2d5a34
--- /dev/null
+++ b/runtime/lib/assembly.h
@@ -0,0 +1,54 @@
+/* ===-- assembly.h - compiler-rt assembler support macros -----------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. 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
+
+/* We can't use __USER_LABEL_PREFIX__ here, it isn't possible to concatenate the
+   *values* of two macros. This is quite brittle, though. */
+#if defined(__APPLE__)
+#define SYMBOL_NAME(name) _##name
+#else
+#define SYMBOL_NAME(name) name
+#endif
+
+#ifdef VISIBILITY_HIDDEN
+#define DEFINE_COMPILERRT_FUNCTION(name) \
+  .globl SYMBOL_NAME(name) SEPARATOR     \
+  .private_extern SYMBOL_NAME(name) SEPARATOR    \
+  SYMBOL_NAME(name):
+#else
+#define DEFINE_COMPILERRT_FUNCTION(name) \
+  .globl SYMBOL_NAME(name) SEPARATOR     \
+  SYMBOL_NAME(name):
+#endif
+
+#define DEFINE_COMPILERRT_PRIVATE_FUNCTION(name) \
+  .globl SYMBOL_NAME(name) SEPARATOR             \
+  .private_extern SYMBOL_NAME(name) SEPARATOR    \
+  SYMBOL_NAME(name):
+
+#define DEFINE_COMPILERRT_PRIVATE_FUNCTION_UNMANGLED(name) \
+  .globl name SEPARATOR             \
+  .private_extern name SEPARATOR    \
+  name:
+
+#endif /* COMPILERRT_ASSEMBLY_H */
diff --git a/runtime/lib/clear_cache.c b/runtime/lib/clear_cache.c
new file mode 100644
index 0000000..1456823
--- /dev/null
+++ b/runtime/lib/clear_cache.c
@@ -0,0 +1,40 @@
+/* ===-- clear_cache.c - Implement __clear_cache ---------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include <stdlib.h>
+
+#if __APPLE__
+  #include <libkern/OSCacheControl.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
+ */
+#else
+    #if __APPLE__
+        /* On Darwin, sys_icache_invalidate() provides this functionality */
+        sys_icache_invalidate(start, end-start);
+    #else
+        abort();
+    #endif
+#endif
+}
+
diff --git a/runtime/lib/clzdi2.c b/runtime/lib/clzdi2.c
new file mode 100644
index 0000000..ea95396
--- /dev/null
+++ b/runtime/lib/clzdi2.c
@@ -0,0 +1,29 @@
+/* ===-- clzdi2.c - Implement __clzdi2 -------------------------------------===
+ *
+ *      	       The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. 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 */
+
+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/runtime/lib/clzsi2.c b/runtime/lib/clzsi2.c
new file mode 100644
index 0000000..7e14af2
--- /dev/null
+++ b/runtime/lib/clzsi2.c
@@ -0,0 +1,53 @@
+/* ===-- clzsi2.c - Implement __clzsi2 -------------------------------------===
+ *
+ *      	       The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. 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 */
+
+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/runtime/lib/clzti2.c b/runtime/lib/clzti2.c
new file mode 100644
index 0000000..805688f
--- /dev/null
+++ b/runtime/lib/clzti2.c
@@ -0,0 +1,33 @@
+/* ===-- clzti2.c - Implement __clzti2 -------------------------------------===
+ *
+ *      	       The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __clzti2 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#if __x86_64
+
+#include "int_lib.h"
+
+/* Returns: the number of leading 0-bits */
+
+/* Precondition: a != 0 */
+
+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 /* __x86_64 */
diff --git a/runtime/lib/cmpdi2.c b/runtime/lib/cmpdi2.c
new file mode 100644
index 0000000..0b87352
--- /dev/null
+++ b/runtime/lib/cmpdi2.c
@@ -0,0 +1,38 @@
+/* ===-- cmpdi2.c - Implement __cmpdi2 -------------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. 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
+*/
+
+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;
+}
diff --git a/runtime/lib/cmpti2.c b/runtime/lib/cmpti2.c
new file mode 100644
index 0000000..90b3b75
--- /dev/null
+++ b/runtime/lib/cmpti2.c
@@ -0,0 +1,42 @@
+/* ===-- cmpti2.c - Implement __cmpti2 -------------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __cmpti2 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#if __x86_64
+
+#include "int_lib.h"
+
+/* Returns:  if (a <  b) returns 0
+ *           if (a == b) returns 1
+ *           if (a >  b) returns 2
+ */
+
+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
diff --git a/runtime/lib/ctzdi2.c b/runtime/lib/ctzdi2.c
new file mode 100644
index 0000000..b49f2c7
--- /dev/null
+++ b/runtime/lib/ctzdi2.c
@@ -0,0 +1,29 @@
+/* ===-- ctzdi2.c - Implement __ctzdi2 -------------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. 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 */
+
+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/runtime/lib/ctzsi2.c b/runtime/lib/ctzsi2.c
new file mode 100644
index 0000000..30d34c8
--- /dev/null
+++ b/runtime/lib/ctzsi2.c
@@ -0,0 +1,57 @@
+/* ===-- ctzsi2.c - Implement __ctzsi2 -------------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. 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 */
+
+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/runtime/lib/ctzti2.c b/runtime/lib/ctzti2.c
new file mode 100644
index 0000000..f2d41fe
--- /dev/null
+++ b/runtime/lib/ctzti2.c
@@ -0,0 +1,33 @@
+/* ===-- ctzti2.c - Implement __ctzti2 -------------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __ctzti2 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#if __x86_64
+
+#include "int_lib.h"
+
+/* Returns: the number of trailing 0-bits */
+
+/* Precondition: a != 0 */
+
+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
diff --git a/runtime/lib/divdc3.c b/runtime/lib/divdc3.c
new file mode 100644
index 0000000..c96aefd
--- /dev/null
+++ b/runtime/lib/divdc3.c
@@ -0,0 +1,59 @@
+/* ===-- divdc3.c - Implement __divdc3 -------------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __divdc3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+#include <math.h>
+#include <complex.h>
+
+/* Returns: the quotient of (a + ib) / (c + id) */
+
+double _Complex
+__divdc3(double __a, double __b, double __c, double __d)
+{
+    int __ilogbw = 0;
+    double __logbw = logb(fmax(fabs(__c), fabs(__d)));
+    if (isfinite(__logbw))
+    {
+        __ilogbw = (int)__logbw;
+        __c = scalbn(__c, -__ilogbw);
+        __d = scalbn(__d, -__ilogbw);
+    }
+    double __denom = __c * __c + __d * __d;
+    double _Complex z;
+    __real__ z = scalbn((__a * __c + __b * __d) / __denom, -__ilogbw);
+    __imag__ z = scalbn((__b * __c - __a * __d) / __denom, -__ilogbw);
+    if (isnan(__real__ z) && isnan(__imag__ z))
+    {
+        if ((__denom == 0.0) && (!isnan(__a) || !isnan(__b)))
+        {
+            __real__ z = copysign(INFINITY, __c) * __a;
+            __imag__ z = copysign(INFINITY, __c) * __b;
+        }
+        else if ((isinf(__a) || isinf(__b)) && isfinite(__c) && isfinite(__d))
+        {
+            __a = copysign(isinf(__a) ? 1.0 : 0.0, __a);
+            __b = copysign(isinf(__b) ? 1.0 : 0.0, __b);
+            __real__ z = INFINITY * (__a * __c + __b * __d);
+            __imag__ z = INFINITY * (__b * __c - __a * __d);
+        }
+        else if (isinf(__logbw) && __logbw > 0.0 && isfinite(__a) && isfinite(__b))
+        {
+            __c = copysign(isinf(__c) ? 1.0 : 0.0, __c);
+            __d = copysign(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/runtime/lib/divdi3.c b/runtime/lib/divdi3.c
new file mode 100644
index 0000000..fccfb8b
--- /dev/null
+++ b/runtime/lib/divdi3.c
@@ -0,0 +1,31 @@
+/* ===-- divdi3.c - Implement __divdi3 -------------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __divdi3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+du_int __udivmoddi4(du_int a, du_int b, du_int* rem);
+
+/* Returns: a / b */
+
+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/runtime/lib/divsc3.c b/runtime/lib/divsc3.c
new file mode 100644
index 0000000..c38c863
--- /dev/null
+++ b/runtime/lib/divsc3.c
@@ -0,0 +1,59 @@
+/*===-- divsc3.c - Implement __divsc3 -------------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __divsc3 for the compiler_rt library.
+ *
+ *===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+#include <math.h>
+#include <complex.h>
+
+/* Returns: the quotient of (a + ib) / (c + id) */
+
+float _Complex
+__divsc3(float __a, float __b, float __c, float __d)
+{
+    int __ilogbw = 0;
+    float __logbw = logbf(fmaxf(fabsf(__c), fabsf(__d)));
+    if (isfinite(__logbw))
+    {
+        __ilogbw = (int)__logbw;
+        __c = scalbnf(__c, -__ilogbw);
+        __d = scalbnf(__d, -__ilogbw);
+    }
+    float __denom = __c * __c + __d * __d;
+    float _Complex z;
+    __real__ z = scalbnf((__a * __c + __b * __d) / __denom, -__ilogbw);
+    __imag__ z = scalbnf((__b * __c - __a * __d) / __denom, -__ilogbw);
+    if (isnan(__real__ z) && isnan(__imag__ z))
+    {
+        if ((__denom == 0) && (!isnan(__a) || !isnan(__b)))
+        {
+            __real__ z = copysignf(INFINITY, __c) * __a;
+            __imag__ z = copysignf(INFINITY, __c) * __b;
+        }
+        else if ((isinf(__a) || isinf(__b)) && isfinite(__c) && isfinite(__d))
+        {
+            __a = copysignf(isinf(__a) ? 1 : 0, __a);
+            __b = copysignf(isinf(__b) ? 1 : 0, __b);
+            __real__ z = INFINITY * (__a * __c + __b * __d);
+            __imag__ z = INFINITY * (__b * __c - __a * __d);
+        }
+        else if (isinf(__logbw) && __logbw > 0 && isfinite(__a) && isfinite(__b))
+        {
+            __c = copysignf(isinf(__c) ? 1 : 0, __c);
+            __d = copysignf(isinf(__d) ? 1 : 0, __d);
+            __real__ z = 0 * (__a * __c + __b * __d);
+            __imag__ z = 0 * (__b * __c - __a * __d);
+        }
+    }
+    return z;
+}
diff --git a/runtime/lib/divsi3.c b/runtime/lib/divsi3.c
new file mode 100644
index 0000000..0eff6ef
--- /dev/null
+++ b/runtime/lib/divsi3.c
@@ -0,0 +1,31 @@
+/* ===-- divsi3.c - Implement __divsi3 -------------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __divsi3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+su_int __udivsi3(su_int n, su_int d);
+
+/* Returns: a / b */
+
+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 */
+    return (__udivsi3(a, b) ^ s_a) - s_a;        /* negate if s_a == -1 */
+}
diff --git a/runtime/lib/divti3.c b/runtime/lib/divti3.c
new file mode 100644
index 0000000..c752f6c
--- /dev/null
+++ b/runtime/lib/divti3.c
@@ -0,0 +1,35 @@
+/* ===-- divti3.c - Implement __divti3 -------------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __divti3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#if __x86_64
+
+#include "int_lib.h"
+
+tu_int __udivmodti4(tu_int a, tu_int b, tu_int* rem);
+
+/* Returns: a / b */
+
+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
diff --git a/runtime/lib/divxc3.c b/runtime/lib/divxc3.c
new file mode 100644
index 0000000..03357ae
--- /dev/null
+++ b/runtime/lib/divxc3.c
@@ -0,0 +1,62 @@
+/* ===-- divxc3.c - Implement __divxc3 -------------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __divxc3 for the compiler_rt library.
+ *
+ */
+
+#if !_ARCH_PPC
+
+#include "int_lib.h"
+#include <math.h>
+#include <complex.h>
+
+/* Returns: the quotient of (a + ib) / (c + id) */
+
+long double _Complex
+__divxc3(long double __a, long double __b, long double __c, long double __d)
+{
+    int __ilogbw = 0;
+    long double __logbw = logbl(fmaxl(fabsl(__c), fabsl(__d)));
+    if (isfinite(__logbw))
+    {
+        __ilogbw = (int)__logbw;
+        __c = scalbnl(__c, -__ilogbw);
+        __d = scalbnl(__d, -__ilogbw);
+    }
+    long double __denom = __c * __c + __d * __d;
+    long double _Complex z;
+    __real__ z = scalbnl((__a * __c + __b * __d) / __denom, -__ilogbw);
+    __imag__ z = scalbnl((__b * __c - __a * __d) / __denom, -__ilogbw);
+    if (isnan(__real__ z) && isnan(__imag__ z))
+    {
+        if ((__denom == 0) && (!isnan(__a) || !isnan(__b)))
+        {
+            __real__ z = copysignl(INFINITY, __c) * __a;
+            __imag__ z = copysignl(INFINITY, __c) * __b;
+        }
+        else if ((isinf(__a) || isinf(__b)) && isfinite(__c) && isfinite(__d))
+        {
+            __a = copysignl(isinf(__a) ? 1 : 0, __a);
+            __b = copysignl(isinf(__b) ? 1 : 0, __b);
+            __real__ z = INFINITY * (__a * __c + __b * __d);
+            __imag__ z = INFINITY * (__b * __c - __a * __d);
+        }
+        else if (isinf(__logbw) && __logbw > 0 && isfinite(__a) && isfinite(__b))
+        {
+            __c = copysignl(isinf(__c) ? 1 : 0, __c);
+            __d = copysignl(isinf(__d) ? 1 : 0, __d);
+            __real__ z = 0 * (__a * __c + __b * __d);
+            __imag__ z = 0 * (__b * __c - __a * __d);
+        }
+    }
+    return z;
+}
+
+#endif
diff --git a/runtime/lib/enable_execute_stack.c b/runtime/lib/enable_execute_stack.c
new file mode 100644
index 0000000..b349d2f
--- /dev/null
+++ b/runtime/lib/enable_execute_stack.c
@@ -0,0 +1,53 @@
+/* ===-- enable_execute_stack.c - Implement __enable_execute_stack ---------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include <stdint.h>
+#include <sys/mman.h>
+
+/* #include "config.h"
+ * FIXME: CMake - include when cmake system is ready.
+ * Remove #define HAVE_SYSCONF 1 line.
+ */
+#define HAVE_SYSCONF 1
+
+#ifndef __APPLE__
+#include <unistd.h>
+#endif /* __APPLE__ */
+
+
+/*
+ * 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. 
+ */
+
+void __enable_execute_stack(void* addr)
+{
+
+#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+48+pageSize) & pageAlignMask);
+	size_t length = endPage - startPage;
+	(void) mprotect((void *)startPage, length, PROT_READ | PROT_WRITE | PROT_EXEC);
+}
+
+
diff --git a/runtime/lib/endianness.h b/runtime/lib/endianness.h
new file mode 100644
index 0000000..6d2587d
--- /dev/null
+++ b/runtime/lib/endianness.h
@@ -0,0 +1,94 @@
+/* ===-- endianness.h - configuration header for compiler-rt ---------------===
+ *
+ *		       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 configuration header for compiler-rt.
+ * 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(__DragonFly__)
+#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 */
+
+/* .. */
+
+/* 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/runtime/lib/eprintf.c b/runtime/lib/eprintf.c
new file mode 100644
index 0000000..8d9ce32
--- /dev/null
+++ b/runtime/lib/eprintf.c
@@ -0,0 +1,32 @@
+/* ===---------- eprintf.c - Implements __eprintf --------------------------===
+ *
+ *                     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 <stdlib.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.
+ */
+__attribute__((visibility("hidden")))
+void __eprintf(const char* format, const char* assertion_expression,
+				const char* line, const char* file)
+{
+	fprintf(stderr, format, assertion_expression, line, file);
+	fflush(stderr);
+	abort();
+}
diff --git a/runtime/lib/ffsdi2.c b/runtime/lib/ffsdi2.c
new file mode 100644
index 0000000..8c03d19
--- /dev/null
+++ b/runtime/lib/ffsdi2.c
@@ -0,0 +1,33 @@
+/* ===-- ffsdi2.c - Implement __ffsdi2 -------------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. 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.
+ */
+
+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/runtime/lib/ffsti2.c b/runtime/lib/ffsti2.c
new file mode 100644
index 0000000..0139eb1
--- /dev/null
+++ b/runtime/lib/ffsti2.c
@@ -0,0 +1,37 @@
+/* ===-- ffsti2.c - Implement __ffsti2 -------------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __ffsti2 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#if __x86_64
+
+#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.
+ */
+
+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 /* __x86_64 */
diff --git a/runtime/lib/fixdfdi.c b/runtime/lib/fixdfdi.c
new file mode 100644
index 0000000..3d3116c
--- /dev/null
+++ b/runtime/lib/fixdfdi.c
@@ -0,0 +1,43 @@
+/* ===-- fixdfdi.c - Implement __fixdfdi -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __fixdfdi for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.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 */
+
+di_int
+__fixdfdi(double a)
+{
+    double_bits fb;
+    fb.f = a;
+    int e = ((fb.u.s.high & 0x7FF00000) >> 20) - 1023;
+    if (e < 0)
+        return 0;
+    di_int s = (si_int)(fb.u.s.high & 0x80000000) >> 31;
+    dwords r;
+    r.s.high = (fb.u.s.high & 0x000FFFFF) | 0x00100000;
+    r.s.low = fb.u.s.low;
+    if (e > 52)
+        r.all <<= (e - 52);
+    else
+        r.all >>= (52 - e);
+    return (r.all ^ s) - s;
+} 
diff --git a/runtime/lib/fixdfti.c b/runtime/lib/fixdfti.c
new file mode 100644
index 0000000..359b84e
--- /dev/null
+++ b/runtime/lib/fixdfti.c
@@ -0,0 +1,45 @@
+/* ===-- fixdfti.c - Implement __fixdfti -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __fixdfti for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#if __x86_64
+
+#include "int_lib.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 ti_int (no range checking performed)
+ */
+
+/* seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm */
+
+ti_int
+__fixdfti(double a)
+{
+    double_bits fb;
+    fb.f = a;
+    int e = ((fb.u.s.high & 0x7FF00000) >> 20) - 1023;
+    if (e < 0)
+        return 0;
+    ti_int s = (si_int)(fb.u.s.high & 0x80000000) >> 31;
+    ti_int r = 0x0010000000000000uLL | (0x000FFFFFFFFFFFFFuLL & fb.u.all);
+    if (e > 52)
+        r <<= (e - 52);
+    else
+        r >>= (52 - e);
+    return (r ^ s) - s;
+}
+
+#endif
diff --git a/runtime/lib/fixsfdi.c b/runtime/lib/fixsfdi.c
new file mode 100644
index 0000000..08f1524
--- /dev/null
+++ b/runtime/lib/fixsfdi.c
@@ -0,0 +1,41 @@
+/* ===-- fixsfdi.c - Implement __fixsfdi -----------------------------------===
+ *
+ *                    The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __fixsfdi for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.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 */
+
+di_int
+__fixsfdi(float a)
+{
+    float_bits fb;
+    fb.f = a;
+    int e = ((fb.u & 0x7F800000) >> 23) - 127;
+    if (e < 0)
+        return 0;
+    di_int s = (si_int)(fb.u & 0x80000000) >> 31;
+    di_int r = (fb.u & 0x007FFFFF) | 0x00800000;
+    if (e > 23)
+        r <<= (e - 23);
+    else
+        r >>= (23 - e);
+    return (r ^ s) - s;
+}
diff --git a/runtime/lib/fixsfti.c b/runtime/lib/fixsfti.c
new file mode 100644
index 0000000..95992fe
--- /dev/null
+++ b/runtime/lib/fixsfti.c
@@ -0,0 +1,45 @@
+/* ===-- fixsfti.c - Implement __fixsfti -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __fixsfti for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#if __x86_64
+
+#include "int_lib.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 ti_int (no range checking performed)
+ */
+
+/* seee eeee emmm mmmm mmmm mmmm mmmm mmmm */
+
+ti_int
+__fixsfti(float a)
+{
+    float_bits fb;
+    fb.f = a;
+    int e = ((fb.u & 0x7F800000) >> 23) - 127;
+    if (e < 0)
+        return 0;
+    ti_int s = (si_int)(fb.u & 0x80000000) >> 31;
+    ti_int r = (fb.u & 0x007FFFFF) | 0x00800000;
+    if (e > 23)
+        r <<= (e - 23);
+    else
+        r >>= (23 - e);
+    return (r ^ s) - s;
+}
+
+#endif
diff --git a/runtime/lib/fixunsdfdi.c b/runtime/lib/fixunsdfdi.c
new file mode 100644
index 0000000..bdcee13
--- /dev/null
+++ b/runtime/lib/fixunsdfdi.c
@@ -0,0 +1,45 @@
+/* ===-- fixunsdfdi.c - Implement __fixunsdfdi -----------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __fixunsdfdi for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.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 */
+
+du_int
+__fixunsdfdi(double a)
+{
+    double_bits fb;
+    fb.f = a;
+    int e = ((fb.u.s.high & 0x7FF00000) >> 20) - 1023;
+    if (e < 0 || (fb.u.s.high & 0x80000000))
+        return 0;
+    udwords r;
+    r.s.high = (fb.u.s.high & 0x000FFFFF) | 0x00100000;
+    r.s.low = fb.u.s.low;
+    if (e > 52)
+        r.all <<= (e - 52);
+    else
+        r.all >>= (52 - e);
+    return r.all;
+}
diff --git a/runtime/lib/fixunsdfsi.c b/runtime/lib/fixunsdfsi.c
new file mode 100644
index 0000000..a0cba79
--- /dev/null
+++ b/runtime/lib/fixunsdfsi.c
@@ -0,0 +1,42 @@
+/* ===-- fixunsdfsi.c - Implement __fixunsdfsi -----------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __fixunsdfsi for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.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 */
+
+su_int
+__fixunsdfsi(double a)
+{
+    double_bits fb;
+    fb.f = a;
+    int e = ((fb.u.s.high & 0x7FF00000) >> 20) - 1023;
+    if (e < 0 || (fb.u.s.high & 0x80000000))
+        return 0;
+    return (
+                0x80000000u                      |
+                ((fb.u.s.high & 0x000FFFFF) << 11) |
+                (fb.u.s.low >> 21)
+           ) >> (31 - e);
+}
diff --git a/runtime/lib/fixunsdfti.c b/runtime/lib/fixunsdfti.c
new file mode 100644
index 0000000..c1cd72d
--- /dev/null
+++ b/runtime/lib/fixunsdfti.c
@@ -0,0 +1,47 @@
+/* ===-- fixunsdfti.c - Implement __fixunsdfti -----------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __fixunsdfti for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#if __x86_64
+
+#include "int_lib.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 */
+
+tu_int
+__fixunsdfti(double a)
+{
+    double_bits fb;
+    fb.f = a;
+    int e = ((fb.u.s.high & 0x7FF00000) >> 20) - 1023;
+    if (e < 0 || (fb.u.s.high & 0x80000000))
+        return 0;
+    tu_int r = 0x0010000000000000uLL | (fb.u.all & 0x000FFFFFFFFFFFFFuLL);
+    if (e > 52)
+        r <<= (e - 52);
+    else
+        r >>= (52 - e);
+    return r;
+}
+
+#endif
diff --git a/runtime/lib/fixunssfdi.c b/runtime/lib/fixunssfdi.c
new file mode 100644
index 0000000..3837bd8
--- /dev/null
+++ b/runtime/lib/fixunssfdi.c
@@ -0,0 +1,43 @@
+/* ===-- fixunssfdi.c - Implement __fixunssfdi -----------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __fixunssfdi for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.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 */
+
+du_int
+__fixunssfdi(float a)
+{
+    float_bits fb;
+    fb.f = a;
+    int e = ((fb.u & 0x7F800000) >> 23) - 127;
+    if (e < 0 || (fb.u & 0x80000000))
+        return 0;
+    du_int r = (fb.u & 0x007FFFFF) | 0x00800000;
+    if (e > 23)
+        r <<= (e - 23);
+    else
+        r >>= (23 - e);
+    return r;
+}
diff --git a/runtime/lib/fixunssfsi.c b/runtime/lib/fixunssfsi.c
new file mode 100644
index 0000000..a001cd4
--- /dev/null
+++ b/runtime/lib/fixunssfsi.c
@@ -0,0 +1,43 @@
+/* ===-- fixunssfsi.c - Implement __fixunssfsi -----------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __fixunssfsi for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.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 */
+
+su_int
+__fixunssfsi(float a)
+{
+    float_bits fb;
+    fb.f = a;
+    int e = ((fb.u & 0x7F800000) >> 23) - 127;
+    if (e < 0 || (fb.u & 0x80000000))
+        return 0;
+    su_int r = (fb.u & 0x007FFFFF) | 0x00800000;
+    if (e > 23)
+        r <<= (e - 23);
+    else
+        r >>= (23 - e);
+    return r;
+}
diff --git a/runtime/lib/fixunssfti.c b/runtime/lib/fixunssfti.c
new file mode 100644
index 0000000..20b7e76
--- /dev/null
+++ b/runtime/lib/fixunssfti.c
@@ -0,0 +1,47 @@
+/* ===-- fixunssfti.c - Implement __fixunssfti -----------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __fixunssfti for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#if __x86_64
+
+#include "int_lib.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 
+ *             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 */
+
+tu_int
+__fixunssfti(float a)
+{
+    float_bits fb;
+    fb.f = a;
+    int e = ((fb.u & 0x7F800000) >> 23) - 127;
+    if (e < 0 || (fb.u & 0x80000000))
+        return 0;
+    tu_int r = (fb.u & 0x007FFFFF) | 0x00800000;
+    if (e > 23)
+        r <<= (e - 23);
+    else
+        r >>= (23 - e);
+    return r;
+}
+
+#endif
diff --git a/runtime/lib/fixunsxfdi.c b/runtime/lib/fixunsxfdi.c
new file mode 100644
index 0000000..872727b
--- /dev/null
+++ b/runtime/lib/fixunsxfdi.c
@@ -0,0 +1,44 @@
+/* ===-- fixunsxfdi.c - Implement __fixunsxfdi -----------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. 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
+ */
+
+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;
+    return fb.u.low.all >> (63 - e);
+}
+
+#endif
diff --git a/runtime/lib/fixunsxfsi.c b/runtime/lib/fixunsxfsi.c
new file mode 100644
index 0000000..c9a607a
--- /dev/null
+++ b/runtime/lib/fixunsxfsi.c
@@ -0,0 +1,44 @@
+/* ===-- fixunsxfsi.c - Implement __fixunsxfsi -----------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. 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 
+ *                 (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
+ */
+
+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;
+    return fb.u.low.s.high >> (31 - e);
+}
+
+#endif /* !_ARCH_PPC */
diff --git a/runtime/lib/fixunsxfti.c b/runtime/lib/fixunsxfti.c
new file mode 100644
index 0000000..d0bd512
--- /dev/null
+++ b/runtime/lib/fixunsxfti.c
@@ -0,0 +1,49 @@
+/* ===-- fixunsxfti.c - Implement __fixunsxfti -----------------------------===
+ *
+ *      	       The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __fixunsxfti for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#if __x86_64
+
+#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
+ *             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
+ */
+
+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;
+    tu_int r = fb.u.low.all;
+    if (e > 63)
+        r <<= (e - 63);
+    else
+        r >>= (63 - e);
+    return r;
+}
+
+#endif
diff --git a/runtime/lib/fixxfdi.c b/runtime/lib/fixxfdi.c
new file mode 100644
index 0000000..de6f818
--- /dev/null
+++ b/runtime/lib/fixxfdi.c
@@ -0,0 +1,44 @@
+/* ===-- fixxfdi.c - Implement __fixxfdi -----------------------------------===
+ *
+ *      	       The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. 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
+ *             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
+ */
+
+di_int
+__fixxfdi(long double a)
+{
+    long_double_bits fb;
+    fb.f = a;
+    int e = (fb.u.high.s.low & 0x00007FFF) - 16383;
+    if (e < 0)
+        return 0;
+    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/runtime/lib/fixxfti.c b/runtime/lib/fixxfti.c
new file mode 100644
index 0000000..c224801
--- /dev/null
+++ b/runtime/lib/fixxfti.c
@@ -0,0 +1,47 @@
+/* ===-- fixxfti.c - Implement __fixxfti -----------------------------------===
+ *
+ *      	       The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __fixxfti for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#if __x86_64
+
+#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
+ *             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
+ */
+
+ti_int
+__fixxfti(long double a)
+{
+    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 (e > 63)
+        r <<= (e - 63);
+    else
+        r >>= (63 - e);
+    return (r ^ s) - s;
+}
+
+#endif /* __x86_64 */
diff --git a/runtime/lib/floatdidf.c b/runtime/lib/floatdidf.c
new file mode 100644
index 0000000..a0f501b
--- /dev/null
+++ b/runtime/lib/floatdidf.c
@@ -0,0 +1,107 @@
+/*===-- floatdidf.c - Implement __floatdidf -------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ *===----------------------------------------------------------------------===
+ *
+ * This file implements __floatdidf for the compiler_rt library.
+ *
+ *===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+#include <float.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 */
+
+#ifndef __SOFT_FP__
+/* Support for systems that have hardware floating-point; we'll set the inexact flag
+ * as a side-effect of this computation.
+ */
+#include <stdint.h>
+
+double
+__floatdidf(di_int a)
+{
+	static const double twop52 = 0x1.0p52;
+	static const double twop32 = 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.
+ */
+
+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/runtime/lib/floatdisf.c b/runtime/lib/floatdisf.c
new file mode 100644
index 0000000..1925f15
--- /dev/null
+++ b/runtime/lib/floatdisf.c
@@ -0,0 +1,79 @@
+/*===-- floatdisf.c - Implement __floatdisf -------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ *===----------------------------------------------------------------------===
+ *
+ * This file implements __floatdisf for the compiler_rt library.
+ *
+ *===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+#include <float.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 */
+
+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/runtime/lib/floatdixf.c b/runtime/lib/floatdixf.c
new file mode 100644
index 0000000..bfda367
--- /dev/null
+++ b/runtime/lib/floatdixf.c
@@ -0,0 +1,46 @@
+/* ===-- floatdixf.c - Implement __floatdixf -------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. 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
+ */
+
+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/runtime/lib/floattidf.c b/runtime/lib/floattidf.c
new file mode 100644
index 0000000..274f585
--- /dev/null
+++ b/runtime/lib/floattidf.c
@@ -0,0 +1,86 @@
+/* ===-- floattidf.c - Implement __floattidf -------------------------------===
+ *
+ *                    The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __floattidf for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */ 
+
+#if __x86_64
+
+#include "int_lib.h"
+#include <float.h>
+
+/* 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 */ 
+
+si_int __clzti2(ti_int a);
+
+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
diff --git a/runtime/lib/floattisf.c b/runtime/lib/floattisf.c
new file mode 100644
index 0000000..72f3748
--- /dev/null
+++ b/runtime/lib/floattisf.c
@@ -0,0 +1,85 @@
+/* ===-- floattisf.c - Implement __floattisf -------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __floattisf for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#if __x86_64
+
+#include "int_lib.h"
+#include <float.h>
+
+/* 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 */
+
+si_int __clzti2(ti_int a);
+
+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
diff --git a/runtime/lib/floattixf.c b/runtime/lib/floattixf.c
new file mode 100644
index 0000000..77d9060
--- /dev/null
+++ b/runtime/lib/floattixf.c
@@ -0,0 +1,87 @@
+/* ===-- floattixf.c - Implement __floattixf -------------------------------===
+ *
+ *      	       The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __floattixf for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#if __x86_64
+
+#include "int_lib.h"
+#include <float.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
+ *             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
+ */
+
+si_int __clzti2(ti_int a);
+
+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
diff --git a/runtime/lib/floatundidf.c b/runtime/lib/floatundidf.c
new file mode 100644
index 0000000..1f304c5
--- /dev/null
+++ b/runtime/lib/floatundidf.c
@@ -0,0 +1,107 @@
+/* ===-- floatundidf.c - Implement __floatundidf ---------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __floatundidf for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+#include <float.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 */
+
+#ifndef __SOFT_FP__
+/* Support for systems that have hardware floating-point; we'll set the inexact flag
+ * as a side-effect of this computation.
+ */
+
+#include <stdint.h>
+
+double
+__floatundidf(du_int a)
+{
+	static const double twop52 = 0x1.0p52;
+	static const double twop84 = 0x1.0p84;
+	static const double twop84_plus_twop52 = 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.
+ */ 
+
+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/runtime/lib/floatundisf.c b/runtime/lib/floatundisf.c
new file mode 100644
index 0000000..79b4b82
--- /dev/null
+++ b/runtime/lib/floatundisf.c
@@ -0,0 +1,76 @@
+/*===-- floatundisf.c - Implement __floatundisf ---------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __floatundisf for the compiler_rt library.
+ *
+ *===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+#include <float.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 */
+
+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/runtime/lib/floatundixf.c b/runtime/lib/floatundixf.c
new file mode 100644
index 0000000..bc9582f
--- /dev/null
+++ b/runtime/lib/floatundixf.c
@@ -0,0 +1,42 @@
+/* ===-- floatundixf.c - Implement __floatundixf ---------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. 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
+ */
+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/runtime/lib/floatuntidf.c b/runtime/lib/floatuntidf.c
new file mode 100644
index 0000000..51d8b28
--- /dev/null
+++ b/runtime/lib/floatuntidf.c
@@ -0,0 +1,83 @@
+/* ===-- floatuntidf.c - Implement __floatuntidf ---------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __floatuntidf for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#if __x86_64
+
+#include "int_lib.h"
+#include <float.h>
+
+/* 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 */
+
+si_int __clzti2(ti_int a);
+
+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
diff --git a/runtime/lib/floatuntisf.c b/runtime/lib/floatuntisf.c
new file mode 100644
index 0000000..328f39b
--- /dev/null
+++ b/runtime/lib/floatuntisf.c
@@ -0,0 +1,82 @@
+/* ===-- floatuntisf.c - Implement __floatuntisf ---------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __floatuntisf for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#if __x86_64
+
+#include "int_lib.h"
+#include <float.h>
+
+/* 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 */
+
+si_int __clzti2(ti_int a);
+
+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
diff --git a/runtime/lib/floatuntixf.c b/runtime/lib/floatuntixf.c
new file mode 100644
index 0000000..e82d0c1
--- /dev/null
+++ b/runtime/lib/floatuntixf.c
@@ -0,0 +1,84 @@
+/* ===-- floatuntixf.c - Implement __floatuntixf ---------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __floatuntixf for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#if __x86_64
+
+#include "int_lib.h"
+#include <float.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
+ *             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
+ */
+
+si_int __clzti2(ti_int a);
+
+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/runtime/lib/gcc_personality_v0.c b/runtime/lib/gcc_personality_v0.c
new file mode 100644
index 0000000..b0d93b8
--- /dev/null
+++ b/runtime/lib/gcc_personality_v0.c
@@ -0,0 +1,243 @@
+/* ===-- gcc_personality_v0.c - Implement __gcc_personality_v0 -------------===
+ *
+ *      	       The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ */
+
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+/*
+ * _Unwind_* stuff based on C++ ABI public documentation
+ * http://refspecs.freestandards.org/abi-eh-1.21.html
+ */
+
+typedef enum {
+    _URC_NO_REASON = 0,
+    _URC_FOREIGN_EXCEPTION_CAUGHT = 1,
+    _URC_FATAL_PHASE2_ERROR = 2,
+    _URC_FATAL_PHASE1_ERROR = 3,
+    _URC_NORMAL_STOP = 4,
+    _URC_END_OF_STACK = 5,
+    _URC_HANDLER_FOUND = 6,
+    _URC_INSTALL_CONTEXT = 7,
+    _URC_CONTINUE_UNWIND = 8
+} _Unwind_Reason_Code;
+
+typedef enum {
+    _UA_SEARCH_PHASE = 1,
+    _UA_CLEANUP_PHASE = 2,
+    _UA_HANDLER_FRAME = 4,
+    _UA_FORCE_UNWIND = 8,
+    _UA_END_OF_STACK = 16
+} _Unwind_Action;
+
+typedef struct _Unwind_Context* _Unwind_Context_t;
+
+struct _Unwind_Exception {
+    uint64_t                exception_class;
+    void                    (*exception_cleanup)(_Unwind_Reason_Code reason, 
+                                                 struct _Unwind_Exception* exc);
+    uintptr_t                private_1;    
+    uintptr_t                private_2;    
+};
+
+extern const uint8_t*    _Unwind_GetLanguageSpecificData(_Unwind_Context_t c);
+extern void              _Unwind_SetGR(_Unwind_Context_t c, int i, uintptr_t n);
+extern void              _Unwind_SetIP(_Unwind_Context_t, uintptr_t new_value);
+extern uintptr_t         _Unwind_GetIP(_Unwind_Context_t context);
+extern uintptr_t         _Unwind_GetRegionStart(_Unwind_Context_t context);
+
+
+/*
+ * 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 = *((uintptr_t*)p);
+            p += sizeof(uintptr_t);
+            break;
+        case DW_EH_PE_uleb128:
+            result = readULEB128(&p);
+            break;
+        case DW_EH_PE_udata2:
+            result = *((uint16_t*)p);
+            p += sizeof(uint16_t);
+            break;
+        case DW_EH_PE_udata4:
+            result = *((uint32_t*)p);
+            p += sizeof(uint32_t);
+            break;
+        case DW_EH_PE_udata8:
+            result = *((uint64_t*)p);
+            p += sizeof(uint64_t);
+            break;
+        case DW_EH_PE_sdata2:
+            result = *((int16_t*)p);
+            p += sizeof(int16_t);
+            break;
+        case DW_EH_PE_sdata4:
+            result = *((int32_t*)p);
+            p += sizeof(int32_t);
+            break;
+        case DW_EH_PE_sdata8:
+            result = *((int64_t*)p);
+            p += sizeof(int64_t);
+            break;
+        case DW_EH_PE_sleb128:
+        default:
+            /* not supported */
+            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 */
+            abort();
+            break;
+    }
+
+    /* then apply indirection */
+    if (encoding & DW_EH_PE_indirect) {
+        result = *((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.
+ */
+
+_Unwind_Reason_Code __gcc_personality_v0(int version, _Unwind_Action actions,
+         uint64_t exceptionClass, struct _Unwind_Exception* exceptionObject,
+         _Unwind_Context_t context)
+{
+    /* 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 = _Unwind_GetLanguageSpecificData(context);
+    if ( lsda == NULL )
+        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/runtime/lib/i386/CMakeLists.txt b/runtime/lib/i386/CMakeLists.txt
new file mode 100644
index 0000000..1c2861a
--- /dev/null
+++ b/runtime/lib/i386/CMakeLists.txt
@@ -0,0 +1,3 @@
+SET( SRCS
+ 
+ )
diff --git a/runtime/lib/i386/Makefile.mk b/runtime/lib/i386/Makefile.mk
new file mode 100644
index 0000000..20f95e6
--- /dev/null
+++ b/runtime/lib/i386/Makefile.mk
@@ -0,0 +1,19 @@
+#===- lib/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.
+#
+#===------------------------------------------------------------------------===#
+
+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/runtime/lib/i386/ashldi3.S b/runtime/lib/i386/ashldi3.S
new file mode 100644
index 0000000..af6f98b
--- /dev/null
+++ b/runtime/lib/i386/ashldi3.S
@@ -0,0 +1,56 @@
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+.align 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
+
+#else // Use GPRs instead of SSE2 instructions, if they aren't available.
+
+.text
+.align 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
+	
+#endif // __SSE2__
+#endif // __i386__
diff --git a/runtime/lib/i386/ashrdi3.S b/runtime/lib/i386/ashrdi3.S
new file mode 100644
index 0000000..346f9b1
--- /dev/null
+++ b/runtime/lib/i386/ashrdi3.S
@@ -0,0 +1,67 @@
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+#include "../assembly.h"
+
+// di_int __ashrdi3(di_int input, int count);
+
+#ifdef __i386__
+#ifdef __SSE2__
+
+.text
+.align 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
+
+#else // Use GPRs instead of SSE2 instructions, if they aren't available.
+
+.text
+.align 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
+	
+#endif // __SSE2__
+#endif // __i386__
diff --git a/runtime/lib/i386/divdi3.S b/runtime/lib/i386/divdi3.S
new file mode 100644
index 0000000..5ad530c
--- /dev/null
+++ b/runtime/lib/i386/divdi3.S
@@ -0,0 +1,161 @@
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+.align 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
+
+#endif // __i386__
diff --git a/runtime/lib/i386/floatdidf.S b/runtime/lib/i386/floatdidf.S
new file mode 100644
index 0000000..3a526ea
--- /dev/null
+++ b/runtime/lib/i386/floatdidf.S
@@ -0,0 +1,35 @@
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+#include "../assembly.h"
+
+// double __floatundidf(du_int a);
+
+#ifdef __i386__
+
+#ifndef __ELF__
+.const
+#endif
+.align 4
+twop52: .quad 0x4330000000000000
+twop32: .quad 0x41f0000000000000
+
+#define REL_ADDR(_a)	(_a)-0b(%eax)
+
+.text
+.align 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
+	
+#endif // __i386__
diff --git a/runtime/lib/i386/floatdisf.S b/runtime/lib/i386/floatdisf.S
new file mode 100644
index 0000000..741e4a6
--- /dev/null
+++ b/runtime/lib/i386/floatdisf.S
@@ -0,0 +1,31 @@
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+.align 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
+
+#endif // __i386__
diff --git a/runtime/lib/i386/floatdixf.S b/runtime/lib/i386/floatdixf.S
new file mode 100644
index 0000000..f0271ab
--- /dev/null
+++ b/runtime/lib/i386/floatdixf.S
@@ -0,0 +1,29 @@
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+.align 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
+
+#endif // __i386__
diff --git a/runtime/lib/i386/floatundidf.S b/runtime/lib/i386/floatundidf.S
new file mode 100644
index 0000000..7186a35
--- /dev/null
+++ b/runtime/lib/i386/floatundidf.S
@@ -0,0 +1,46 @@
+//===-- floatundidf.S - Implement __floatundidf for i386 ------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements __floatundidf for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../assembly.h"
+
+// double __floatundidf(du_int a);
+
+#ifdef __i386__
+
+#ifndef __ELF__
+.const
+#endif
+.align 4
+twop52: .quad 0x4330000000000000
+twop84_plus_twop52:
+		.quad 0x4530000000100000
+twop84: .quad 0x4530000000000000
+
+#define REL_ADDR(_a)	(_a)-0b(%eax)
+
+.text
+.align 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
+	
+#endif // __i386__
diff --git a/runtime/lib/i386/floatundisf.S b/runtime/lib/i386/floatundisf.S
new file mode 100644
index 0000000..070820c
--- /dev/null
+++ b/runtime/lib/i386/floatundisf.S
@@ -0,0 +1,99 @@
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+.align 3
+
+		.quad	0x43f0000000000000
+twop64:	.quad	0x0000000000000000
+
+#define			TWOp64			twop64-0b(%ecx,%eax,8)
+
+.text
+.align 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
+	
+#endif // __i386__
+
+*/
+
+/* branch-free, x87-free implementation - faster at the expense of code size */
+
+#ifdef __i386__
+
+#ifndef __ELF__
+.const
+.align 3
+#else
+.align 8
+#endif
+twop52: .quad 0x4330000000000000
+		.quad 0x0000000000000fff
+sticky: .quad 0x0000000000000000
+		.long 0x00000012
+twelve:	.long 0x00000000
+
+#define			TWOp52			twop52-0b(%ecx)
+#define			STICKY			sticky-0b(%ecx,%eax,8)
+
+.text
+.align 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
+	
+#endif // __i386__
diff --git a/runtime/lib/i386/floatundixf.S b/runtime/lib/i386/floatundixf.S
new file mode 100644
index 0000000..2cf6d5c
--- /dev/null
+++ b/runtime/lib/i386/floatundixf.S
@@ -0,0 +1,37 @@
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+#include "../assembly.h"
+
+// long double __floatundixf(du_int a);16
+
+#ifdef __i386__
+
+#ifndef __ELF__
+.const
+#endif
+.align 4
+twop52: .quad 0x4330000000000000
+twop84_plus_twop52_neg:
+		.quad 0xc530000000100000
+twop84: .quad 0x4530000000000000
+
+#define REL_ADDR(_a)	(_a)-0b(%eax)
+
+.text
+.align 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
+	
+#endif // __i386__
diff --git a/runtime/lib/i386/lshrdi3.S b/runtime/lib/i386/lshrdi3.S
new file mode 100644
index 0000000..74937d2
--- /dev/null
+++ b/runtime/lib/i386/lshrdi3.S
@@ -0,0 +1,57 @@
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+.align 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
+
+#else // Use GPRs instead of SSE2 instructions, if they aren't available.
+
+.text
+.align 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
+	
+#endif // __SSE2__
+#endif // __i386__
diff --git a/runtime/lib/i386/moddi3.S b/runtime/lib/i386/moddi3.S
new file mode 100644
index 0000000..85f5b38
--- /dev/null
+++ b/runtime/lib/i386/moddi3.S
@@ -0,0 +1,166 @@
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+.align 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
+
+	
+#endif // __i386__
diff --git a/runtime/lib/i386/muldi3.S b/runtime/lib/i386/muldi3.S
new file mode 100644
index 0000000..5f99f6a
--- /dev/null
+++ b/runtime/lib/i386/muldi3.S
@@ -0,0 +1,29 @@
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+#include "../assembly.h"
+
+// di_int __muldi3(di_int a, di_int b);
+
+#ifdef __i386__
+
+.text
+.align 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
+	
+#endif // __i386__
diff --git a/runtime/lib/i386/udivdi3.S b/runtime/lib/i386/udivdi3.S
new file mode 100644
index 0000000..77936f8
--- /dev/null
+++ b/runtime/lib/i386/udivdi3.S
@@ -0,0 +1,114 @@
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+.align 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
+	
+#endif // __i386__
diff --git a/runtime/lib/i386/umoddi3.S b/runtime/lib/i386/umoddi3.S
new file mode 100644
index 0000000..3cf8aeb
--- /dev/null
+++ b/runtime/lib/i386/umoddi3.S
@@ -0,0 +1,125 @@
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+.align 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								// 
+	
+#endif // __i386__
diff --git a/runtime/lib/int_lib.h b/runtime/lib/int_lib.h
new file mode 100644
index 0000000..f37d500
--- /dev/null
+++ b/runtime/lib/int_lib.h
@@ -0,0 +1,146 @@
+/* ===-- int_lib.h - configuration header for compiler-rt  -----------------===
+ *
+ *                     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 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 */
+
+#include <limits.h>
+#include "endianness.h"
+#include <math.h>
+
+#if !defined(INFINITY) && defined(HUGE_VAL)
+#define INFINITY HUGE_VAL
+#endif /* INFINITY */
+
+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;
+
+#if __x86_64
+
+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 /* __x86_64 */
+
+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;
+
+#endif /* INT_LIB_H */
diff --git a/runtime/lib/lshrdi3.c b/runtime/lib/lshrdi3.c
new file mode 100644
index 0000000..57484ee
--- /dev/null
+++ b/runtime/lib/lshrdi3.c
@@ -0,0 +1,41 @@
+/* ===-- lshrdi3.c - Implement __lshrdi3 -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. 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 */
+
+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/runtime/lib/lshrti3.c b/runtime/lib/lshrti3.c
new file mode 100644
index 0000000..3272c9c
--- /dev/null
+++ b/runtime/lib/lshrti3.c
@@ -0,0 +1,45 @@
+/* ===-- lshrti3.c - Implement __lshrti3 -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __lshrti3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#if __x86_64
+
+#include "int_lib.h"
+
+/* Returns: logical a >> b */
+
+/* Precondition:  0 <= b < bits_in_tword */
+
+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 /* __x86_64 */ 
diff --git a/runtime/lib/moddi3.c b/runtime/lib/moddi3.c
new file mode 100644
index 0000000..4533555
--- /dev/null
+++ b/runtime/lib/moddi3.c
@@ -0,0 +1,32 @@
+/*===-- moddi3.c - Implement __moddi3 -------------------------------------===
+ *
+ *                    The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __moddi3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+du_int __udivmoddi4(du_int a, du_int b, du_int* rem);
+
+/* Returns: a % b */
+
+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 */
+    di_int r;
+    __udivmoddi4(a, b, (du_int*)&r);
+    return (r ^ s) - s;                /* negate if s == -1 */
+}
diff --git a/runtime/lib/modsi3.c b/runtime/lib/modsi3.c
new file mode 100644
index 0000000..c9214a2
--- /dev/null
+++ b/runtime/lib/modsi3.c
@@ -0,0 +1,23 @@
+/* ===-- modsi3.c - Implement __modsi3 -------------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __modsi3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+/* Returns: a % b */
+
+si_int
+__modsi3(si_int a, si_int b)
+{
+    return a - (a / b) * b;
+}
diff --git a/runtime/lib/modti3.c b/runtime/lib/modti3.c
new file mode 100644
index 0000000..75d688e
--- /dev/null
+++ b/runtime/lib/modti3.c
@@ -0,0 +1,36 @@
+/* ===-- modti3.c - Implement __modti3 -------------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __modti3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#if __x86_64
+
+#include "int_lib.h"
+
+tu_int __udivmodti4(tu_int a, tu_int b, tu_int* rem);
+
+/*Returns: a % b */
+
+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 */
+    ti_int r;
+    __udivmodti4(a, b, (tu_int*)&r);
+    return (r ^ s) - s;                /* negate if s == -1 */
+}
+
+#endif
diff --git a/runtime/lib/muldc3.c b/runtime/lib/muldc3.c
new file mode 100644
index 0000000..c048d84
--- /dev/null
+++ b/runtime/lib/muldc3.c
@@ -0,0 +1,74 @@
+/* ===-- muldc3.c - Implement __muldc3 -------------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __muldc3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+#include <math.h>
+#include <complex.h>
+
+/* Returns: the product of a + ib and c + id */
+
+double _Complex
+__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;
+    double _Complex z;
+    __real__ z = __ac - __bd;
+    __imag__ z = __ad + __bc;
+    if (isnan(__real__ z) && isnan(__imag__ z))
+    {
+        int __recalc = 0;
+        if (isinf(__a) || isinf(__b))
+        {
+            __a = copysign(isinf(__a) ? 1 : 0, __a);
+            __b = copysign(isinf(__b) ? 1 : 0, __b);
+            if (isnan(__c))
+                __c = copysign(0, __c);
+            if (isnan(__d))
+                __d = copysign(0, __d);
+            __recalc = 1;
+        }
+        if (isinf(__c) || isinf(__d))
+        {
+            __c = copysign(isinf(__c) ? 1 : 0, __c);
+            __d = copysign(isinf(__d) ? 1 : 0, __d);
+            if (isnan(__a))
+                __a = copysign(0, __a);
+            if (isnan(__b))
+                __b = copysign(0, __b);
+            __recalc = 1;
+        }
+        if (!__recalc && (isinf(__ac) || isinf(__bd) ||
+                          isinf(__ad) || isinf(__bc)))
+        {
+            if (isnan(__a))
+                __a = copysign(0, __a);
+            if (isnan(__b))
+                __b = copysign(0, __b);
+            if (isnan(__c))
+                __c = copysign(0, __c);
+            if (isnan(__d))
+                __d = copysign(0, __d);
+            __recalc = 1;
+        }
+        if (__recalc)
+        {
+            __real__ z = INFINITY * (__a * __c - __b * __d);
+            __imag__ z = INFINITY * (__a * __d + __b * __c);
+        }
+    }
+    return z;
+}
diff --git a/runtime/lib/muldi3.c b/runtime/lib/muldi3.c
new file mode 100644
index 0000000..38963b7
--- /dev/null
+++ b/runtime/lib/muldi3.c
@@ -0,0 +1,54 @@
+/* ===-- muldi3.c - Implement __muldi3 -------------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. 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 */
+
+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/runtime/lib/mulsc3.c b/runtime/lib/mulsc3.c
new file mode 100644
index 0000000..c7b9f64
--- /dev/null
+++ b/runtime/lib/mulsc3.c
@@ -0,0 +1,74 @@
+/* ===-- mulsc3.c - Implement __mulsc3 -------------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __mulsc3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+#include <math.h>
+#include <complex.h>
+
+/* Returns: the product of a + ib and c + id */
+
+float _Complex
+__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;
+    float _Complex z;
+    __real__ z = __ac - __bd;
+    __imag__ z = __ad + __bc;
+    if (isnan(__real__ z) && isnan(__imag__ z))
+    {
+        int __recalc = 0;
+        if (isinf(__a) || isinf(__b))
+        {
+            __a = copysignf(isinf(__a) ? 1 : 0, __a);
+            __b = copysignf(isinf(__b) ? 1 : 0, __b);
+            if (isnan(__c))
+                __c = copysignf(0, __c);
+            if (isnan(__d))
+                __d = copysignf(0, __d);
+            __recalc = 1;
+        }
+        if (isinf(__c) || isinf(__d))
+        {
+            __c = copysignf(isinf(__c) ? 1 : 0, __c);
+            __d = copysignf(isinf(__d) ? 1 : 0, __d);
+            if (isnan(__a))
+                __a = copysignf(0, __a);
+            if (isnan(__b))
+                __b = copysignf(0, __b);
+            __recalc = 1;
+        }
+        if (!__recalc && (isinf(__ac) || isinf(__bd) ||
+                          isinf(__ad) || isinf(__bc)))
+        {
+            if (isnan(__a))
+                __a = copysignf(0, __a);
+            if (isnan(__b))
+                __b = copysignf(0, __b);
+            if (isnan(__c))
+                __c = copysignf(0, __c);
+            if (isnan(__d))
+                __d = copysignf(0, __d);
+            __recalc = 1;
+        }
+        if (__recalc)
+        {
+            __real__ z = INFINITY * (__a * __c - __b * __d);
+            __imag__ z = INFINITY * (__a * __d + __b * __c);
+        }
+    }
+    return z;
+}
diff --git a/runtime/lib/multi3.c b/runtime/lib/multi3.c
new file mode 100644
index 0000000..13a3867
--- /dev/null
+++ b/runtime/lib/multi3.c
@@ -0,0 +1,58 @@
+/* ===-- multi3.c - Implement __multi3 -------------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+
+ * This file implements __multi3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#if __x86_64
+
+#include "int_lib.h"
+
+/* 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 */
+
+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 /* __x86_64 */
diff --git a/runtime/lib/mulvdi3.c b/runtime/lib/mulvdi3.c
new file mode 100644
index 0000000..ebb7769
--- /dev/null
+++ b/runtime/lib/mulvdi3.c
@@ -0,0 +1,57 @@
+/*===-- mulvdi3.c - Implement __mulvdi3 -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __mulvdi3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+#include <stdlib.h>
+
+/* Returns: a * b */
+
+/* Effects: aborts if a * b overflows */
+
+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;
+        abort();
+    }
+    if (b == MIN)
+    {
+        if (a == 0 || a == 1)
+            return a * b;
+        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)
+            abort();
+    }
+    else
+    {
+        if (abs_a > MIN / -abs_b)
+            abort();
+    }
+    return a * b;
+}
diff --git a/runtime/lib/mulvsi3.c b/runtime/lib/mulvsi3.c
new file mode 100644
index 0000000..9edeee2
--- /dev/null
+++ b/runtime/lib/mulvsi3.c
@@ -0,0 +1,57 @@
+/* ===-- mulvsi3.c - Implement __mulvsi3 -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __mulvsi3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+#include <stdlib.h>
+
+/* Returns: a * b */
+
+/* Effects: aborts if a * b overflows */
+
+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;
+        abort();
+    }
+    if (b == MIN)
+    {
+        if (a == 0 || a == 1)
+            return a * b;
+        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)
+            abort();
+    }
+    else
+    {
+        if (abs_a > MIN / -abs_b)
+            abort();
+    }
+    return a * b;
+}
diff --git a/runtime/lib/mulvti3.c b/runtime/lib/mulvti3.c
new file mode 100644
index 0000000..080cd63
--- /dev/null
+++ b/runtime/lib/mulvti3.c
@@ -0,0 +1,61 @@
+/* ===-- mulvti3.c - Implement __mulvti3 -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __mulvti3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#if __x86_64
+
+#include "int_lib.h"
+#include <stdlib.h>
+
+/* Returns: a * b */
+
+/* Effects: aborts if a * b overflows */
+
+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;
+        abort();
+    }
+    if (b == MIN)
+    {
+        if (a == 0 || a == 1)
+            return a * b;
+        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)
+            abort();
+    }
+    else
+    {
+        if (abs_a > MIN / -abs_b)
+            abort();
+    }
+    return a * b;
+}
+
+#endif
diff --git a/runtime/lib/mulxc3.c b/runtime/lib/mulxc3.c
new file mode 100644
index 0000000..94895f2
--- /dev/null
+++ b/runtime/lib/mulxc3.c
@@ -0,0 +1,78 @@
+/* ===-- mulxc3.c - Implement __mulxc3 -------------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __mulxc3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#if !_ARCH_PPC
+
+#include "int_lib.h"
+#include <math.h>
+#include <complex.h>
+
+/* Returns: the product of a + ib and c + id */
+
+long double _Complex
+__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;
+    long double _Complex z;
+    __real__ z = __ac - __bd;
+    __imag__ z = __ad + __bc;
+    if (isnan(__real__ z) && isnan(__imag__ z))
+    {
+        int __recalc = 0;
+        if (isinf(__a) || isinf(__b))
+        {
+            __a = copysignl(isinf(__a) ? 1 : 0, __a);
+            __b = copysignl(isinf(__b) ? 1 : 0, __b);
+            if (isnan(__c))
+                __c = copysignl(0, __c);
+            if (isnan(__d))
+                __d = copysignl(0, __d);
+            __recalc = 1;
+        }
+        if (isinf(__c) || isinf(__d))
+        {
+            __c = copysignl(isinf(__c) ? 1 : 0, __c);
+            __d = copysignl(isinf(__d) ? 1 : 0, __d);
+            if (isnan(__a))
+                __a = copysignl(0, __a);
+            if (isnan(__b))
+                __b = copysignl(0, __b);
+            __recalc = 1;
+        }
+        if (!__recalc && (isinf(__ac) || isinf(__bd) ||
+                          isinf(__ad) || isinf(__bc)))
+        {
+            if (isnan(__a))
+                __a = copysignl(0, __a);
+            if (isnan(__b))
+                __b = copysignl(0, __b);
+            if (isnan(__c))
+                __c = copysignl(0, __c);
+            if (isnan(__d))
+                __d = copysignl(0, __d);
+            __recalc = 1;
+        }
+        if (__recalc)
+        {
+            __real__ z = INFINITY * (__a * __c - __b * __d);
+            __imag__ z = INFINITY * (__a * __d + __b * __c);
+        }
+    }
+    return z;
+}
+
+#endif
diff --git a/runtime/lib/negdi2.c b/runtime/lib/negdi2.c
new file mode 100644
index 0000000..707b0dd
--- /dev/null
+++ b/runtime/lib/negdi2.c
@@ -0,0 +1,26 @@
+/* ===-- negdi2.c - Implement __negdi2 -------------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __negdi2 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+/* Returns: -a */
+
+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/runtime/lib/negti2.c b/runtime/lib/negti2.c
new file mode 100644
index 0000000..6ce6a04
--- /dev/null
+++ b/runtime/lib/negti2.c
@@ -0,0 +1,30 @@
+/* ===-- negti2.c - Implement __negti2 -------------------------------------===
+ *
+ *      	       The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __negti2 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#if __x86_64
+
+#include "int_lib.h"
+
+/* Returns: -a */
+
+ti_int
+__negti2(ti_int a)
+{
+    /* Note: this routine is here for API compatibility; any sane compiler
+     * should expand it inline.
+     */
+    return -a;
+}
+
+#endif
diff --git a/runtime/lib/negvdi2.c b/runtime/lib/negvdi2.c
new file mode 100644
index 0000000..df8a698
--- /dev/null
+++ b/runtime/lib/negvdi2.c
@@ -0,0 +1,29 @@
+/* ===-- negvdi2.c - Implement __negvdi2 -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __negvdi2 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+#include <stdlib.h>
+
+/* Returns: -a */
+
+/* Effects: aborts if -a overflows */
+
+di_int
+__negvdi2(di_int a)
+{
+    const di_int MIN = (di_int)1 << ((int)(sizeof(di_int) * CHAR_BIT)-1);
+    if (a == MIN)
+        abort();
+    return -a;
+}
diff --git a/runtime/lib/negvsi2.c b/runtime/lib/negvsi2.c
new file mode 100644
index 0000000..a7fbbbd
--- /dev/null
+++ b/runtime/lib/negvsi2.c
@@ -0,0 +1,29 @@
+/* ===-- negvsi2.c - Implement __negvsi2 -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __negvsi2 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+#include <stdlib.h>
+
+/* Returns: -a */
+
+/* Effects: aborts if -a overflows */
+
+si_int
+__negvsi2(si_int a)
+{
+    const si_int MIN = (si_int)1 << ((int)(sizeof(si_int) * CHAR_BIT)-1);
+    if (a == MIN)
+        abort();
+    return -a;
+}
diff --git a/runtime/lib/negvti2.c b/runtime/lib/negvti2.c
new file mode 100644
index 0000000..df44935
--- /dev/null
+++ b/runtime/lib/negvti2.c
@@ -0,0 +1,33 @@
+/*===-- negvti2.c - Implement __negvti2 -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ *===----------------------------------------------------------------------===
+ *
+ *This file implements __negvti2 for the compiler_rt library.
+ *
+ *===----------------------------------------------------------------------===
+ */
+
+#if __x86_64
+
+#include "int_lib.h"
+#include <stdlib.h>
+
+/* Returns: -a */
+
+/* Effects: aborts if -a overflows */
+
+ti_int
+__negvti2(ti_int a)
+{
+    const ti_int MIN = (ti_int)1 << ((int)(sizeof(ti_int) * CHAR_BIT)-1);
+    if (a == MIN)
+        abort();
+    return -a;
+}
+
+#endif
diff --git a/runtime/lib/paritydi2.c b/runtime/lib/paritydi2.c
new file mode 100644
index 0000000..90e5559
--- /dev/null
+++ b/runtime/lib/paritydi2.c
@@ -0,0 +1,27 @@
+/* ===-- paritydi2.c - Implement __paritydi2 -------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. 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 */
+
+si_int __paritysi2(si_int a);
+
+si_int
+__paritydi2(di_int a)
+{
+    dwords x;
+    x.all = a;
+    return __paritysi2(x.s.high ^ x.s.low);
+}
diff --git a/runtime/lib/paritysi2.c b/runtime/lib/paritysi2.c
new file mode 100644
index 0000000..ba05782
--- /dev/null
+++ b/runtime/lib/paritysi2.c
@@ -0,0 +1,27 @@
+/* ===-- paritysi2.c - Implement __paritysi2 -------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. 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 */
+
+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/runtime/lib/parityti2.c b/runtime/lib/parityti2.c
new file mode 100644
index 0000000..650d417
--- /dev/null
+++ b/runtime/lib/parityti2.c
@@ -0,0 +1,31 @@
+/* ===-- parityti2.c - Implement __parityti2 -------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __parityti2 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */ 
+
+#if __x86_64
+
+#include "int_lib.h"
+
+/* Returns: 1 if number of bits is odd else returns 0 */
+
+si_int __paritydi2(di_int a);
+
+si_int
+__parityti2(ti_int a)
+{
+    twords x;
+    x.all = a;
+    return __paritydi2(x.s.high ^ x.s.low);
+}
+
+#endif
diff --git a/runtime/lib/popcountdi2.c b/runtime/lib/popcountdi2.c
new file mode 100644
index 0000000..78b6d88
--- /dev/null
+++ b/runtime/lib/popcountdi2.c
@@ -0,0 +1,36 @@
+/* ===-- popcountdi2.c - Implement __popcountdi2 ----------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __popcountdi2 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+/* Returns: count of 1 bits */
+
+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/runtime/lib/popcountsi2.c b/runtime/lib/popcountsi2.c
new file mode 100644
index 0000000..4f092ee
--- /dev/null
+++ b/runtime/lib/popcountsi2.c
@@ -0,0 +1,33 @@
+/* ===-- popcountsi2.c - Implement __popcountsi2 ---------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __popcountsi2 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+/* Returns: count of 1 bits */
+
+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/runtime/lib/popcountti2.c b/runtime/lib/popcountti2.c
new file mode 100644
index 0000000..16f89b7
--- /dev/null
+++ b/runtime/lib/popcountti2.c
@@ -0,0 +1,44 @@
+/* ===-- popcountti2.c - Implement __popcountti2 ----------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __popcountti2 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#if __x86_64
+
+#include "int_lib.h"
+
+/* Returns: count of 1 bits */
+
+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
diff --git a/runtime/lib/powidf2.c b/runtime/lib/powidf2.c
new file mode 100644
index 0000000..37972b6
--- /dev/null
+++ b/runtime/lib/powidf2.c
@@ -0,0 +1,34 @@
+/* ===-- powidf2.cpp - Implement __powidf2 ---------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __powidf2 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+/* Returns: a ^ b */
+
+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/runtime/lib/powisf2.c b/runtime/lib/powisf2.c
new file mode 100644
index 0000000..ace08c2
--- /dev/null
+++ b/runtime/lib/powisf2.c
@@ -0,0 +1,34 @@
+/*===-- powisf2.cpp - Implement __powisf2 ---------------------------------===
+ *
+ *                    The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __powisf2 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+/* Returns: a ^ b */
+
+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/runtime/lib/powitf2.c b/runtime/lib/powitf2.c
new file mode 100644
index 0000000..3dacbf6
--- /dev/null
+++ b/runtime/lib/powitf2.c
@@ -0,0 +1,38 @@
+/* ===-- powitf2.cpp - Implement __powitf2 ---------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __powitf2 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#if _ARCH_PPC
+
+#include "int_lib.h"
+
+/* Returns: a ^ b */
+
+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/runtime/lib/powixf2.c b/runtime/lib/powixf2.c
new file mode 100644
index 0000000..1a816e9
--- /dev/null
+++ b/runtime/lib/powixf2.c
@@ -0,0 +1,38 @@
+/* ===-- powixf2.cpp - Implement __powixf2 ---------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __powixf2 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#if !_ARCH_PPC
+
+#include "int_lib.h"
+
+/* Returns: a ^ b */
+
+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/runtime/lib/ppc/CMakeLists.txt b/runtime/lib/ppc/CMakeLists.txt
new file mode 100644
index 0000000..fb0fcd5
--- /dev/null
+++ b/runtime/lib/ppc/CMakeLists.txt
@@ -0,0 +1,12 @@
+SET( SRCS
+ fixtfdi.c
+ gcc_qdiv.c
+ gcc_qmul.c
+ divtc3.c
+ gcc_qsub.c
+ multc3.c
+ floatditf.c
+ gcc_qadd.c
+ fixunstfdi.c
+ floatunditf.c
+ )
diff --git a/runtime/lib/ppc/DD.h b/runtime/lib/ppc/DD.h
new file mode 100644
index 0000000..9ecd1f5
--- /dev/null
+++ b/runtime/lib/ppc/DD.h
@@ -0,0 +1,46 @@
+#ifndef __DD_HEADER
+#define __DD_HEADER
+
+#include <stdint.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 double __attribute__((always_inline))
+fabs(double x)
+{
+	doublebits result = { .d = x };
+	result.x &= UINT64_C(0x7fffffffffffffff);
+	return result.d;
+}
+
+static inline double __attribute__((always_inline))
+high26bits(double x)
+{
+	doublebits result = { .d = x };
+	result.x &= UINT64_C(0xfffffffff8000000);
+	return result.d;
+}
+
+static inline int __attribute__((always_inline))
+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;
+}
+
+#endif /* __DD_HEADER */
diff --git a/runtime/lib/ppc/Makefile.mk b/runtime/lib/ppc/Makefile.mk
new file mode 100644
index 0000000..519d654
--- /dev/null
+++ b/runtime/lib/ppc/Makefile.mk
@@ -0,0 +1,19 @@
+#===- lib/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.
+#
+#===------------------------------------------------------------------------===#
+
+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/runtime/lib/ppc/divtc3.c b/runtime/lib/ppc/divtc3.c
new file mode 100644
index 0000000..d41f621
--- /dev/null
+++ b/runtime/lib/ppc/divtc3.c
@@ -0,0 +1,93 @@
+/* This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ */
+
+#include "DD.h"
+#include <math.h>
+
+#if !defined(INFINITY) && defined(HUGE_VAL)
+#define INFINITY HUGE_VAL
+#endif /* INFINITY */
+
+#define makeFinite(x)	{ \
+							(x).s.hi = __builtin_copysign(isinf((x).s.hi) ? 1.0 : 0.0, (x).s.hi); \
+							(x).s.lo = 0.0; \
+						}
+
+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);
+
+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 = logb(__builtin_fmax( __builtin_fabs(cDD.s.hi), __builtin_fabs(dDD.s.hi) ));
+	
+	if (isfinite(logbw))
+	{
+		ilogbw = (int)logbw;
+		
+		cDD.s.hi = scalbn(cDD.s.hi, -ilogbw);
+		cDD.s.lo = scalbn(cDD.s.lo, -ilogbw);
+		dDD.s.hi = scalbn(dDD.s.hi, -ilogbw);
+		dDD.s.lo = 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 = scalbn(real.s.hi, -ilogbw);
+	real.s.lo = scalbn(real.s.lo, -ilogbw);
+	imag.s.hi = scalbn(imag.s.hi, -ilogbw);
+	imag.s.lo = scalbn(imag.s.lo, -ilogbw);
+	
+	if (isnan(real.s.hi) && isnan(imag.s.hi))
+	{
+		DD aDD = { .ld = a };
+		DD bDD = { .ld = b };
+		DD rDD = { .ld = denom };
+		
+		if ((rDD.s.hi == 0.0) && (!isnan(aDD.s.hi) || !isnan(bDD.s.hi)))
+		{
+			real.s.hi = __builtin_copysign(INFINITY,cDD.s.hi) * aDD.s.hi;
+			real.s.lo = 0.0;
+			imag.s.hi = __builtin_copysign(INFINITY,cDD.s.hi) * bDD.s.hi;
+			imag.s.lo = 0.0;
+		}
+		
+		else if ((isinf(aDD.s.hi) || isinf(bDD.s.hi)) && isfinite(cDD.s.hi) && isfinite(dDD.s.hi))
+		{
+			makeFinite(aDD);
+			makeFinite(bDD);
+			real.s.hi = INFINITY * (aDD.s.hi*cDD.s.hi + bDD.s.hi*dDD.s.hi);
+			real.s.lo = 0.0;
+			imag.s.hi = INFINITY * (bDD.s.hi*cDD.s.hi - aDD.s.hi*dDD.s.hi);
+			imag.s.lo = 0.0;
+		}
+		
+		else if ((isinf(cDD.s.hi) || isinf(dDD.s.hi)) && isfinite(aDD.s.hi) && isfinite(bDD.s.hi))
+		{
+			makeFinite(cDD);
+			makeFinite(dDD);
+			real.s.hi = __builtin_copysign(0.0,(aDD.s.hi*cDD.s.hi + bDD.s.hi*dDD.s.hi));
+			real.s.lo = 0.0;
+			imag.s.hi = __builtin_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/runtime/lib/ppc/fixtfdi.c b/runtime/lib/ppc/fixtfdi.c
new file mode 100644
index 0000000..fa113a0
--- /dev/null
+++ b/runtime/lib/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 <stdint.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 preceeding 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 > __builtin_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/runtime/lib/ppc/fixunstfdi.c b/runtime/lib/ppc/fixunstfdi.c
new file mode 100644
index 0000000..1fb5248
--- /dev/null
+++ b/runtime/lib/ppc/fixunstfdi.c
@@ -0,0 +1,60 @@
+/* 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"
+#include <stdint.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/runtime/lib/ppc/floatditf.c b/runtime/lib/ppc/floatditf.c
new file mode 100644
index 0000000..ed23dc8
--- /dev/null
+++ b/runtime/lib/ppc/floatditf.c
@@ -0,0 +1,37 @@
+/* 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"
+#include <stdint.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/runtime/lib/ppc/floatunditf.c b/runtime/lib/ppc/floatunditf.c
new file mode 100644
index 0000000..20a3b71
--- /dev/null
+++ b/runtime/lib/ppc/floatunditf.c
@@ -0,0 +1,42 @@
+/* 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"
+#include <stdint.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/runtime/lib/ppc/gcc_qadd.c b/runtime/lib/ppc/gcc_qadd.c
new file mode 100644
index 0000000..c388c7e
--- /dev/null
+++ b/runtime/lib/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 (fabs(A) <= fabs(B))
+		w = (a + b) + h;
+	else
+		w = (a + b) + H;
+	
+	W = (A + B) + w;
+	Y = (A + B) - W;
+	Y += w;
+	
+	if (fabs(a) <= 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/runtime/lib/ppc/gcc_qdiv.c b/runtime/lib/ppc/gcc_qdiv.c
new file mode 100644
index 0000000..70aa00b
--- /dev/null
+++ b/runtime/lib/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/runtime/lib/ppc/gcc_qmul.c b/runtime/lib/ppc/gcc_qmul.c
new file mode 100644
index 0000000..fb4c516
--- /dev/null
+++ b/runtime/lib/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/runtime/lib/ppc/gcc_qsub.c b/runtime/lib/ppc/gcc_qsub.c
new file mode 100644
index 0000000..4f1f7ac
--- /dev/null
+++ b/runtime/lib/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 (fabs(A) <= fabs(B))
+		w = (a + b) + h;
+	else
+		w = (a + b) + H;
+	
+	W = (A + B) + w;
+	Y = (A + B) - W;
+	Y += w;
+	
+	if (fabs(a) <= 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/runtime/lib/ppc/multc3.c b/runtime/lib/ppc/multc3.c
new file mode 100644
index 0000000..9d17a2c
--- /dev/null
+++ b/runtime/lib/ppc/multc3.c
@@ -0,0 +1,97 @@
+/* This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ */
+
+#include "DD.h"
+#include <math.h>
+
+#if !defined(INFINITY) && defined(HUGE_VAL)
+#define INFINITY HUGE_VAL
+#endif /* INFINITY */
+
+#define makeFinite(x)	{ \
+							(x).s.hi = __builtin_copysign(isinf((x).s.hi) ? 1.0 : 0.0, (x).s.hi); \
+							(x).s.lo = 0.0; \
+						}
+
+#define zeroNaN(x)		{ \
+							if (isnan((x).s.hi)) { \
+								(x).s.hi = __builtin_copysign(0.0, (x).s.hi); \
+								(x).s.lo = 0.0; \
+							} \
+						}
+
+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 _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 (isnan(real.s.hi) && isnan(imag.s.hi))
+	{
+		int recalc = 0;
+		
+		DD aDD = { .ld = a };
+		DD bDD = { .ld = b };
+		DD cDD = { .ld = c };
+		DD dDD = { .ld = d };
+		
+		if (isinf(aDD.s.hi) || isinf(bDD.s.hi))
+		{
+			makeFinite(aDD);
+			makeFinite(bDD);
+			zeroNaN(cDD);
+			zeroNaN(dDD);
+			recalc = 1;
+		}
+		
+		if (isinf(cDD.s.hi) || 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 (isinf(acDD.s.hi) || isinf(bdDD.s.hi) || isinf(adDD.s.hi) || isinf(bcDD.s.hi))
+			{
+				zeroNaN(aDD);
+				zeroNaN(bDD);
+				zeroNaN(cDD);
+				zeroNaN(dDD);
+				recalc = 1;
+			}
+		}
+		
+		if (recalc)
+		{
+			real.s.hi = INFINITY * (aDD.s.hi*cDD.s.hi - bDD.s.hi*dDD.s.hi);
+			real.s.lo = 0.0;
+			imag.s.hi = 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/runtime/lib/ppc/restFP.S b/runtime/lib/ppc/restFP.S
new file mode 100644
index 0000000..00919c8
--- /dev/null
+++ b/runtime/lib/ppc/restFP.S
@@ -0,0 +1,43 @@
+//===-- restFP.S - Implement restFP ---------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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/runtime/lib/ppc/saveFP.S b/runtime/lib/ppc/saveFP.S
new file mode 100644
index 0000000..302da6e
--- /dev/null
+++ b/runtime/lib/ppc/saveFP.S
@@ -0,0 +1,40 @@
+//===-- saveFP.S - Implement saveFP ---------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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/runtime/lib/subvdi3.c b/runtime/lib/subvdi3.c
new file mode 100644
index 0000000..0261a5d
--- /dev/null
+++ b/runtime/lib/subvdi3.c
@@ -0,0 +1,37 @@
+/* ===-- subvdi3.c - Implement __subvdi3 -----------------------------------===
+ *
+ *      	       The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __subvdi3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+#include <stdlib.h>
+
+/* Returns: a - b */
+
+/* Effects: aborts if a - b overflows */
+
+di_int
+__subvdi3(di_int a, di_int b)
+{
+    di_int s = a - b;
+    if (b >= 0)
+    {
+        if (s > a)
+            abort();
+    }
+    else
+    {
+        if (s <= a)
+            abort();
+    }
+    return s;
+}
diff --git a/runtime/lib/subvsi3.c b/runtime/lib/subvsi3.c
new file mode 100644
index 0000000..3acb40d
--- /dev/null
+++ b/runtime/lib/subvsi3.c
@@ -0,0 +1,37 @@
+/* ===-- subvsi3.c - Implement __subvsi3 -----------------------------------===
+ *
+ *      	       The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __subvsi3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+#include <stdlib.h>
+
+/* Returns: a - b */
+
+/* Effects: aborts if a - b overflows */
+
+si_int
+__subvsi3(si_int a, si_int b)
+{
+    si_int s = a - b;
+    if (b >= 0)
+    {
+        if (s > a)
+            abort();
+    }
+    else
+    {
+        if (s <= a)
+            abort();
+    }
+    return s;
+}
diff --git a/runtime/lib/subvti3.c b/runtime/lib/subvti3.c
new file mode 100644
index 0000000..2446410
--- /dev/null
+++ b/runtime/lib/subvti3.c
@@ -0,0 +1,41 @@
+/* ===-- subvti3.c - Implement __subvti3 -----------------------------------===
+ *
+ *      	       The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __subvti3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#if __x86_64
+
+#include "int_lib.h"
+#include <stdlib.h>
+
+/* Returns: a - b */
+
+/* Effects: aborts if a - b overflows */
+
+ti_int
+__subvti3(ti_int a, ti_int b)
+{
+    ti_int s = a - b;
+    if (b >= 0)
+    {
+        if (s > a)
+            abort();
+    }
+    else
+    {
+        if (s <= a)
+            abort();
+    }
+    return s;
+}
+
+#endif /* __x86_64 */
diff --git a/runtime/lib/trampoline_setup.c b/runtime/lib/trampoline_setup.c
new file mode 100644
index 0000000..d62e36b
--- /dev/null
+++ b/runtime/lib/trampoline_setup.c
@@ -0,0 +1,48 @@
+/* ===----- trampoline_setup.c - Implement __trampoline_setup -------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include <stdint.h>
+#include <stdlib.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__
+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 )
+        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__ */
diff --git a/runtime/lib/ucmpdi2.c b/runtime/lib/ucmpdi2.c
new file mode 100644
index 0000000..d2900ca
--- /dev/null
+++ b/runtime/lib/ucmpdi2.c
@@ -0,0 +1,38 @@
+/* ===-- ucmpdi2.c - Implement __ucmpdi2 -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. 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
+ */
+
+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;
+}
diff --git a/runtime/lib/ucmpti2.c b/runtime/lib/ucmpti2.c
new file mode 100644
index 0000000..0e7eea3
--- /dev/null
+++ b/runtime/lib/ucmpti2.c
@@ -0,0 +1,42 @@
+/* ===-- ucmpti2.c - Implement __ucmpti2 -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __ucmpti2 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#if __x86_64
+
+#include "int_lib.h"
+
+/* Returns:  if (a <  b) returns 0
+ *           if (a == b) returns 1
+ *           if (a >  b) returns 2
+ */
+
+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
diff --git a/runtime/lib/udivdi3.c b/runtime/lib/udivdi3.c
new file mode 100644
index 0000000..25d1df6
--- /dev/null
+++ b/runtime/lib/udivdi3.c
@@ -0,0 +1,25 @@
+/* ===-- udivdi3.c - Implement __udivdi3 -----------------------------------===
+ *
+ *                    The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __udivdi3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+du_int __udivmoddi4(du_int a, du_int b, du_int* rem);
+
+/* Returns: a / b */
+
+du_int
+__udivdi3(du_int a, du_int b)
+{
+    return __udivmoddi4(a, b, 0);
+}
diff --git a/runtime/lib/udivmoddi4.c b/runtime/lib/udivmoddi4.c
new file mode 100644
index 0000000..9274230
--- /dev/null
+++ b/runtime/lib/udivmoddi4.c
@@ -0,0 +1,251 @@
+/* ===-- udivmoddi4.c - Implement __udivmoddi4 -----------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. 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 */
+
+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;
+                unsigned 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);
+             * }
+             */
+            q.s.low =  (n.s.low << (n_udword_bits - sr)) &
+                     ((si_int)(n_uword_bits - sr) >> (n_uword_bits-1));
+            q.s.high = ((n.s.low << ( n_uword_bits - sr))                       &
+                     ((si_int)(sr - n_uword_bits - 1) >> (n_uword_bits-1))) |
+                     (((n.s.high << (n_udword_bits - sr))                     |
+                     (n.s.low >> (sr - n_uword_bits)))                        &
+                     ((si_int)(n_uword_bits - sr) >> (n_uword_bits-1)));
+            r.s.high = (n.s.high >> sr) &
+                     ((si_int)(sr - n_uword_bits) >> (n_uword_bits-1));
+            r.s.low =  ((n.s.high >> (sr - n_uword_bits))                       &
+                     ((si_int)(n_uword_bits - sr - 1) >> (n_uword_bits-1))) |
+                     (((n.s.high << (n_uword_bits - sr))                      |
+                     (n.s.low >> sr))                                         &
+                     ((si_int)(sr - n_uword_bits) >> (n_uword_bits-1)));
+        }
+        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;
+            q.s.high = n.s.low << (n_uword_bits - sr);
+            /* r.all = n.all >> sr;
+             * if (sr < n_uword_bits)
+             * {
+             *     r.s.high = n.s.high >> sr;
+             *     r.s.low = (n.s.high << (n_uword_bits - sr)) | (n.s.low >> sr);
+             * }
+             * else
+             * {
+             *     r.s.high = 0;
+             *     r.s.low = n.s.high;
+             * }
+             */
+            r.s.high = (n.s.high >> sr) &
+                     ((si_int)(sr - n_uword_bits) >> (n_uword_bits-1));
+            r.s.low = (n.s.high << (n_uword_bits - sr)) |
+                    ((n.s.low >> sr)                  &
+                    ((si_int)(sr - n_uword_bits) >> (n_uword_bits-1)));
+        }
+    }
+    /* 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/runtime/lib/udivmodti4.c b/runtime/lib/udivmodti4.c
new file mode 100644
index 0000000..53b4072
--- /dev/null
+++ b/runtime/lib/udivmodti4.c
@@ -0,0 +1,256 @@
+/* ===-- udivmodti4.c - Implement __udivmodti4 -----------------------------===
+ *
+ *                    The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __udivmodti4 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */ 
+
+#if __x86_64
+
+#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 */
+
+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;
+                unsigned 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);
+             * }
+             */
+            q.s.low =  (n.s.low << (n_utword_bits - sr)) &
+                     ((di_int)(int)(n_udword_bits - sr) >> (n_udword_bits-1));
+            q.s.high = ((n.s.low << ( n_udword_bits - sr))                        &
+                     ((di_int)(int)(sr - n_udword_bits - 1) >> (n_udword_bits-1))) |
+                     (((n.s.high << (n_utword_bits - sr))                       |
+                     (n.s.low >> (sr - n_udword_bits)))                         &
+                     ((di_int)(int)(n_udword_bits - sr) >> (n_udword_bits-1)));
+            r.s.high = (n.s.high >> sr) &
+                     ((di_int)(int)(sr - n_udword_bits) >> (n_udword_bits-1));
+            r.s.low =  ((n.s.high >> (sr - n_udword_bits))                        &
+                     ((di_int)(int)(n_udword_bits - sr - 1) >> (n_udword_bits-1))) |
+                     (((n.s.high << (n_udword_bits - sr))                       |
+                     (n.s.low >> sr))                                           &
+                     ((di_int)(int)(sr - n_udword_bits) >> (n_udword_bits-1)));
+        }
+        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); */
+            q.s.low = 0;
+            q.s.high = n.s.low << (n_udword_bits - sr);
+            /* r.all = n.all >> sr;
+             * if (sr < n_udword_bits)
+             * {
+             *     r.s.high = n.s.high >> sr;
+             *     r.s.low = (n.s.high << (n_udword_bits - sr)) | (n.s.low >> sr);
+             * }
+             * else
+             * {
+             *     r.s.high = 0;
+             *     r.s.low = n.s.high;
+             * }
+             */
+            r.s.high = (n.s.high >> sr) &
+                     ((di_int)(int)(sr - n_udword_bits) >> (n_udword_bits-1));
+            r.s.low = (n.s.high << (n_udword_bits - sr)) |
+                    ((n.s.low >> sr)                   &
+                    ((di_int)(int)(sr - n_udword_bits) >> (n_udword_bits-1)));
+        }
+    }
+    /* 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 /* __x86_64 */
diff --git a/runtime/lib/udivsi3.c b/runtime/lib/udivsi3.c
new file mode 100644
index 0000000..70528b6
--- /dev/null
+++ b/runtime/lib/udivsi3.c
@@ -0,0 +1,63 @@
+/* ===-- udivsi3.c - Implement __udivsi3 -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. 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 */
+
+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/runtime/lib/udivti3.c b/runtime/lib/udivti3.c
new file mode 100644
index 0000000..fb810fd
--- /dev/null
+++ b/runtime/lib/udivti3.c
@@ -0,0 +1,29 @@
+/* ===-- udivti3.c - Implement __udivti3 -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __udivti3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#if __x86_64
+
+#include "int_lib.h"
+
+tu_int __udivmodti4(tu_int a, tu_int b, tu_int* rem);
+
+/* Returns: a / b */
+
+tu_int
+__udivti3(tu_int a, tu_int b)
+{
+    return __udivmodti4(a, b, 0);
+}
+
+#endif /* __x86_64 */
diff --git a/runtime/lib/umoddi3.c b/runtime/lib/umoddi3.c
new file mode 100644
index 0000000..807bb5c
--- /dev/null
+++ b/runtime/lib/umoddi3.c
@@ -0,0 +1,27 @@
+/* ===-- umoddi3.c - Implement __umoddi3 -----------------------------------===
+ *
+ *                    The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __umoddi3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+du_int __udivmoddi4(du_int a, du_int b, du_int* rem);
+
+/* Returns: a % b */
+
+du_int
+__umoddi3(du_int a, du_int b)
+{
+    du_int r;
+    __udivmoddi4(a, b, &r);
+    return r;
+}
diff --git a/runtime/lib/umodsi3.c b/runtime/lib/umodsi3.c
new file mode 100644
index 0000000..ead7737
--- /dev/null
+++ b/runtime/lib/umodsi3.c
@@ -0,0 +1,25 @@
+/* ===-- umodsi3.c - Implement __umodsi3 -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __umodsi3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+/* Returns: a % b */
+
+su_int __udivsi3(su_int a, su_int b);
+
+su_int
+__umodsi3(su_int a, su_int b)
+{
+    return a - __udivsi3(a, b) * b;
+}
diff --git a/runtime/lib/umodti3.c b/runtime/lib/umodti3.c
new file mode 100644
index 0000000..6c8a758
--- /dev/null
+++ b/runtime/lib/umodti3.c
@@ -0,0 +1,31 @@
+/* ===-- umodti3.c - Implement __umodti3 -----------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file implements __umodti3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#if __x86_64
+
+#include "int_lib.h"
+
+tu_int __udivmodti4(tu_int a, tu_int b, tu_int* rem);
+
+/* Returns: a % b */
+
+tu_int
+__umodti3(tu_int a, tu_int b)
+{
+    tu_int r;
+    __udivmodti4(a, b, &r);
+    return r;
+}
+
+#endif
diff --git a/runtime/lib/x86_64/CMakeLists.txt b/runtime/lib/x86_64/CMakeLists.txt
new file mode 100644
index 0000000..ee21308
--- /dev/null
+++ b/runtime/lib/x86_64/CMakeLists.txt
@@ -0,0 +1,5 @@
+SET( SRCS
+ floatdixf.c
+ floatdisf.c
+ floatdidf.c
+ )
diff --git a/runtime/lib/x86_64/Makefile.mk b/runtime/lib/x86_64/Makefile.mk
new file mode 100644
index 0000000..09037b9
--- /dev/null
+++ b/runtime/lib/x86_64/Makefile.mk
@@ -0,0 +1,19 @@
+#===- lib/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.
+#
+#===------------------------------------------------------------------------===#
+
+SubDirs := 
+OnlyArchs := x86_64
+
+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/runtime/lib/x86_64/floatdidf.c b/runtime/lib/x86_64/floatdidf.c
new file mode 100644
index 0000000..cce3cd5
--- /dev/null
+++ b/runtime/lib/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 <stdint.h>
+
+double __floatdidf(int64_t a)
+{
+	return (double)a;
+}
+
+#endif /* __x86_64__ */
diff --git a/runtime/lib/x86_64/floatdisf.c b/runtime/lib/x86_64/floatdisf.c
new file mode 100644
index 0000000..753ba90
--- /dev/null
+++ b/runtime/lib/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 <stdint.h>
+
+float __floatdisf(int64_t a)
+{
+	return (float)a;
+}
+
+#endif /* __x86_64__ */
diff --git a/runtime/lib/x86_64/floatdixf.c b/runtime/lib/x86_64/floatdixf.c
new file mode 100644
index 0000000..569f727
--- /dev/null
+++ b/runtime/lib/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 <stdint.h>
+
+long double __floatdixf(int64_t a)
+{
+	return (long double)a;
+}
+
+#endif /* __i386__ */
diff --git a/runtime/lib/x86_64/floatundidf.S b/runtime/lib/x86_64/floatundidf.S
new file mode 100644
index 0000000..6e684b2
--- /dev/null
+++ b/runtime/lib/x86_64/floatundidf.S
@@ -0,0 +1,43 @@
+//===-- floatundidf.S - Implement __floatundidf for x86_64 ----------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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__
+
+#ifndef __ELF__
+.const
+#endif
+.align 4
+twop52: .quad 0x4330000000000000
+twop84_plus_twop52:
+		.quad 0x4530000000100000
+twop84: .quad 0x4530000000000000
+
+#define REL_ADDR(_a)	(_a)(%rip)
+
+.text
+.align 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
+	
+#endif // __x86_64__
diff --git a/runtime/lib/x86_64/floatundisf.S b/runtime/lib/x86_64/floatundisf.S
new file mode 100644
index 0000000..fe20963
--- /dev/null
+++ b/runtime/lib/x86_64/floatundisf.S
@@ -0,0 +1,33 @@
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+#include "../assembly.h"
+
+// float __floatundisf(du_int a);
+
+#ifdef __x86_64__
+
+#ifndef __ELF__
+.literal4
+#endif
+two: .single 2.0
+
+#define REL_ADDR(_a)	(_a)(%rip)
+
+.text
+.align 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
+	
+#endif // __x86_64__
diff --git a/runtime/lib/x86_64/floatundixf.S b/runtime/lib/x86_64/floatundixf.S
new file mode 100644
index 0000000..246f026
--- /dev/null
+++ b/runtime/lib/x86_64/floatundixf.S
@@ -0,0 +1,62 @@
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+#include "../assembly.h"
+
+// long double __floatundixf(du_int a);
+
+#ifdef __x86_64__
+
+#ifndef __ELF__
+.const
+#endif
+.align 4
+twop64: .quad 0x43f0000000000000
+
+#define REL_ADDR(_a)	(_a)(%rip)
+
+.text
+.align 4
+DEFINE_COMPILERRT_FUNCTION(__floatundixf)
+	movq	%rdi,	 -8(%rsp)
+	fildq	-8(%rsp)
+	test	%rdi,		%rdi
+	js		1f
+	ret
+1:	faddl	REL_ADDR(twop64)
+	ret
+
+#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
+.align 4
+twop52: .quad 0x4330000000000000
+twop84_plus_twop52_neg:
+		.quad 0xc530000000100000
+twop84: .quad 0x4530000000000000
+
+#define REL_ADDR(_a)	(_a)(%rip)
+
+.text
+.align 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
+
+#endif // __x86_64__
+
+*/
diff --git a/runtime/make/AppleBI.mk b/runtime/make/AppleBI.mk
new file mode 100644
index 0000000..0817fd9
--- /dev/null
+++ b/runtime/make/AppleBI.mk
@@ -0,0 +1,54 @@
+
+#
+# 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
+
+# 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)
+
+
+# Copy results to DSTROOT.
+install:  $(SYMROOT)/usr/local/lib/system/libcompiler_rt.a
+	mkdir -p $(DSTROOT)/usr/local/lib/system
+	cp $(SYMROOT)/usr/local/lib/system/libcompiler_rt.a \
+	   $(DSTROOT)/usr/local/lib/system/libcompiler_rt.a
+	cd $(DSTROOT)/usr/local/lib/system; \
+	ln -s libcompiler_rt.a libcompiler_rt_profile.a; \
+	ln -s libcompiler_rt.a libcompiler_rt_debug.a
+
+
+# Rule to make fat libcompiler_rt.a.
+$(SYMROOT)/usr/local/lib/system/libcompiler_rt.a : $(foreach arch,$(RC_ARCHS), \
+                                                    $(OBJROOT)/$(arch)-pruned.a)
+	mkdir -p $(SYMROOT)/usr/local/lib/system
+	lipo -create $^ -o  $@
+
+
+# Rule to add project info so that "what /usr/lib/libSystem.B.dylib" will work.
+$(OBJROOT)/%-pruned.a : $(OBJROOT)/darwin_bni/Release/%/libcompiler_rt.a
+	mkdir -p $(OBJROOT)/$*.tmp
+	cd $(OBJROOT)/$*.tmp; \
+	/Developer/Makefiles/bin/version.pl $(RC_ProjectName) > $(OBJROOT)/version.c; \
+	gcc -arch $* -c ${OBJROOT}/version.c -o version.o; \
+	ar -x $<; \
+	libtool -static *.o -o $@
diff --git a/runtime/make/config.mk b/runtime/make/config.mk
new file mode 100644
index 0000000..d96b1b4
--- /dev/null
+++ b/runtime/make/config.mk
@@ -0,0 +1,36 @@
+###
+# 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)
+
+###
+# Tool configuration variables.
+
+# FIXME: LLVM uses autoconf/mkinstalldirs ?
+MKDIR := mkdir -p
+DATE := date
+LIPO := lipo
+CP := cp
+
+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
diff --git a/runtime/make/filter-inputs b/runtime/make/filter-inputs
new file mode 100755
index 0000000..8a6bbe2
--- /dev/null
+++ b/runtime/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/runtime/make/lib_info.mk b/runtime/make/lib_info.mk
new file mode 100644
index 0000000..a54152a
--- /dev/null
+++ b/runtime/make/lib_info.mk
@@ -0,0 +1,50 @@
+# 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.
+
+AvailableArchs := $(sort $(foreach key,$(SubDirKeys),\
+	$($(key).OnlyArchs)))
+
+AvailableFunctions := $(sort $(foreach key,$(SubDirKeys),\
+	$(basename $($(key).ObjNames))))
+
+CommonFunctions := $(sort\
+  $(foreach key,$(SubDirKeys),\
+    $(if $(call strneq,,$(strip $($(key).OnlyArchs) $($(key).OnlyConfigs))),,\
+         $(basename $($(key).ObjNames)))))
+
+# Compute common arch functions.
+$(foreach key,$(SubDirKeys),\
+  $(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 FUNCTIONS OPTIMIZED \
+                    RANLIB RANLIBFLAGS \
+                    VISIBILITY_HIDDEN
diff --git a/runtime/make/lib_platforms.mk b/runtime/make/lib_platforms.mk
new file mode 100644
index 0000000..9cf9704
--- /dev/null
+++ b/runtime/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/runtime/make/lib_util.mk b/runtime/make/lib_util.mk
new file mode 100644
index 0000000..089a0e2
--- /dev/null
+++ b/runtime/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/runtime/make/options.mk b/runtime/make/options.mk
new file mode 100644
index 0000000..f6a331b
--- /dev/null
+++ b/runtime/make/options.mk
@@ -0,0 +1,33 @@
+# 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
+
+# Miscellaneous tools.
+
+AR := ar
+# FIXME: Remove these pipes once ranlib errors are fixed.
+ARFLAGS := cru 2> /dev/null
+RANLIB := ranlib
+# FIXME: Remove these pipes once ranlib errors are fixed.
+RANLIBFLAGS := 2> /dev/null
diff --git a/runtime/make/platform/clang_darwin.mk b/runtime/make/platform/clang_darwin.mk
new file mode 100644
index 0000000..d3c96ba
--- /dev/null
+++ b/runtime/make/platform/clang_darwin.mk
@@ -0,0 +1,35 @@
+# These are the functions which clang needs when it is targetting 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.
+
+Configs :=
+UniversalArchs :=
+
+# Configuration for targetting 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 targetting PowerPC.
+Configs += 10.4
+UniversalArchs.10.4 := i386 x86_64
+
+# Configuration for targetting armv6. We need a few additional functions which
+# must be in the same linkage unit.
+Configs += armv6
+UniversalArchs.armv6 := armv6
+
+CC := gcc
+
+# 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
+
+FUNCTIONS.10.4 := eprintf floatundidf floatundisf floatundixf
+FUNCTIONS.armv6 := switch16 switch32 switch8 switchu8 \
+                   save_vfp_d8_d15_regs restore_vfp_d8_d15_regs
+
+VISIBILITY_HIDDEN := 1
diff --git a/runtime/make/platform/darwin_bni.mk b/runtime/make/platform/darwin_bni.mk
new file mode 100644
index 0000000..a7d8989
--- /dev/null
+++ b/runtime/make/platform/darwin_bni.mk
@@ -0,0 +1,60 @@
+
+Description := Target for Darwin using an Apple-style build.
+
+Configs := Debug Release Profile
+
+# 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)
+
+
+CFLAGS := -Wall -O3 -fomit-frame-pointer
+
+
+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 \
+             mulsc3 mulvdi3 mulvsi3 negdi2 negvdi2 negvsi2 \
+             paritydi2 paritysi2 popcountdi2 popcountsi2 powidf2 \
+             powisf2 subvdi3 subvsi3 ucmpdi2 udivdi3 \
+             udivmoddi4 umoddi3 apple_versioning eprintf
+
+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 \
+                mulvti3 mulxc3 negti2 negvti2 parityti2 \
+                popcountti2 powixf2 subvti3 ucmpti2 udivmodti4 \
+                udivti3 umodti3 clear_cache enable_execute_stack
+FUNCTIONS.armv6 := $(FUNCTIONS) \
+                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 negdf2vfp negsf2vfp nesf2vfp \
+                subdf3vfp subsf3vfp truncdfsf2vfp unorddf2vfp unordsf2vfp \
+                modsi3 umodsi3 udivsi3 divsi3 \
+				switch8 switchu8 switch16 switch32 \
+				restore_vfp_d8_d15_regs save_vfp_d8_d15_regs \
+				sync_synchronize 
+
+VISIBILITY_HIDDEN := 0
diff --git a/runtime/make/platform/darwin_fat.mk b/runtime/make/platform/darwin_fat.mk
new file mode 100644
index 0000000..3659e04
--- /dev/null
+++ b/runtime/make/platform/darwin_fat.mk
@@ -0,0 +1,55 @@
+# Configurations to build
+#
+# This section must define:
+#   Description - A description of this target.
+#   Configs - The names of each configuration to build; this is used to build
+#             multiple libraries inside a single configuration file (for
+#             example, Debug and Release builds, or builds with and without
+#             software floating point).
+#
+# This section must define one of:
+#   UniveralArchs - A list of architectures to build for, when using universal build
+#           support (e.g., on Darwin). This should only be used to build fat
+#           libraries, simply building multiple libraries for different
+#           architectures should do so using distinct configs, with the
+#           appropriate choices for CC and CFLAGS.
+#
+#   Arch - The target architecture; this must match the compiler-rt name for the
+#          architecture and is used to find the appropriate function
+#          implementations.
+#
+# When not universal builds, this section may define:
+#   Arch.<Config Name> - Set the target architecture on a per-config basis.
+
+Description := Target for building universal libraries for Darwin.
+
+Configs := Debug Release Profile
+UniversalArchs := i386 ppc x86_64
+
+# Platform Options
+#
+# This section may override any of the variables in make/options.mk, using:
+#   <Option Name> := ... option value ...
+#
+# See make/options.mk for the available options and their meanings. Options can
+# be override on a per-config, per-arch, or per-config-and-arch basis using:
+#   <Option Name>.<Config Name> := ...
+#   <Option Name>.<Arch Name> := ...
+#   <Option Name>.<Config Name>.<Arch Name> := ...
+
+CC := gcc
+
+CFLAGS := -Wall -Werror
+CFLAGS.Debug := $(CFLAGS) -g
+CFLAGS.Release := $(CFLAGS) -O3 -fomit-frame-pointer
+CFLAGS.Profile := $(CFLAGS) -pg -g
+
+FUNCTIONS.i386 := $(CommonFunctions) $(ArchFunctions.i386)
+FUNCTIONS.ppc := $(CommonFunctions) $(ArchFunctions.ppc)
+FUNCTIONS.x86_64 := $(CommonFunctions) $(ArchFunctions.x86_64)
+FUNCTIONS.armv6 := $(CommonFunctions) $(ArchFunctions.armv6)
+FUNCTIONS.armv7 := $(CommonFunctions) $(ArchFunctions.armv7)
+
+OPTIMIZED.Debug := 0
+
+VISIBILITY_HIDDEN := 1
diff --git a/runtime/make/platform/multi_arch.mk b/runtime/make/platform/multi_arch.mk
new file mode 100644
index 0000000..eebc7b2
--- /dev/null
+++ b/runtime/make/platform/multi_arch.mk
@@ -0,0 +1,16 @@
+Description := Example configuration for build two libraries for separate \
+architectures.
+
+Configs := m32 m64
+Arch := i386
+Arch.m64 := x86_64
+
+CC := gcc
+CC.m32 := 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/runtime/make/subdir.mk b/runtime/make/subdir.mk
new file mode 100644
index 0000000..900f7e6
--- /dev/null
+++ b/runtime/make/subdir.mk
@@ -0,0 +1,90 @@
+# This file is intended to be included from each subdirectory makefile.
+#
+# Subdirectory makefiles must define:
+#   SubDirs - The subdirectories to traverse.
+#   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.
+#
+# Subdirectory makefiles may define:
+#   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 ObjNames Implementation Dependencies
+OptionalSubdirVariables := OnlyArchs OnlyConfigs
+
+# 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/runtime/make/test/test-util.mk b/runtime/make/test/test-util.mk
new file mode 100644
index 0000000..c80c28d
--- /dev/null
+++ b/runtime/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/runtime/make/util.mk b/runtime/make/util.mk
new file mode 100644
index 0000000..57ff4da
--- /dev/null
+++ b/runtime/make/util.mk
@@ -0,0 +1,103 @@
+# 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)))
+
+###
+# 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/runtime/test/CMakeLists.txt b/runtime/test/CMakeLists.txt
new file mode 100644
index 0000000..eac7608
--- /dev/null
+++ b/runtime/test/CMakeLists.txt
@@ -0,0 +1,122 @@
+PROJECT( tests C )
+
+SET( CompilerRT_LIBRARY CompilerRT )
+INCLUDE_DIRECTORIES(${CompilerRT_SOURCE_DIR}/lib)
+
+# create test library
+# add_library(${CompilerRT_LIBRARY} STATIC support.c cmdline.c)
+TARGET_LINK_LIBRARIES( ${CompilerRT_LIBRARY} )
+
+# FIXME: We should check Optmized versions of CompilerRT-* here also.
+SET( TEST_TARGET_LIBRARIES ${CompilerRT_LIBRARY}-Generic )
+
+INCLUDE( MacroAddCheckTest )
+# create tests
+# MACRO_ADD_CHECK_TEST( foo foo.c ${TEST_TARGET_LIBRARIES} )
+
+
+# Create Unit/ tests
+
+MACRO_ADD_CHECK_TEST( ashldi3_test Unit/ashldi3_test.c ${TEST_TARGET_LIBRARIES} )
+# MACRO_ADD_CHECK_TEST( gcc_personality_test Unit/gcc_personality_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( udivmodti4_test Unit/udivmodti4_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( negvsi2_test Unit/negvsi2_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( fixdfdi_test Unit/fixdfdi_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( mulvsi3_test Unit/mulvsi3_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( fixdfti_test Unit/fixdfti_test.c ${TEST_TARGET_LIBRARIES} )
+# MACRO_ADD_CHECK_TEST( muldc3_test Unit/muldc3_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( popcountdi2_test Unit/popcountdi2_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( negti2_test Unit/negti2_test.c ${TEST_TARGET_LIBRARIES} )
+# MACRO_ADD_CHECK_TEST( divsc3_test Unit/divsc3_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( cmpti2_test Unit/cmpti2_test.c ${TEST_TARGET_LIBRARIES} )
+# MACRO_ADD_CHECK_TEST( trampoline_setup_test Unit/trampoline_setup_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( mulvti3_test Unit/mulvti3_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( fixunsxfdi_test Unit/fixunsxfdi_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( fixunsxfti_test Unit/fixunsxfti_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( paritydi2_test Unit/paritydi2_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( negvti2_test Unit/negvti2_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( divtc3_test Unit/divtc3_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( ucmpti2_test Unit/ucmpti2_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( multc3_test Unit/multc3_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( floatdixf_test Unit/floatdixf_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( popcountti2_test Unit/popcountti2_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( negdi2_test Unit/negdi2_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( floatdidf_test Unit/floatdidf_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( fixunstfdi_test Unit/fixunstfdi_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( shlti3_test Unit/ashlti3_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( enable_execute_stack_test Unit/enable_execute_stack_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( floatundixf_test Unit/floatundixf_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( udivmoddi4_test Unit/udivmoddi4_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( paritysi2_test Unit/paritysi2_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( floatundidf_test Unit/floatundidf_test.c ${TEST_TARGET_LIBRARIES} )
+# MACRO_ADD_CHECK_TEST( divdc3_test Unit/divdc3_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( floatuntisf_test Unit/floatuntisf_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( ucmpdi2_test Unit/ucmpdi2_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( powixf2_test Unit/powixf2_test.c ${TEST_TARGET_LIBRARIES} )
+# MACRO_ADD_CHECK_TEST( mulsc3_test Unit/mulsc3_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( popcountsi2_test Unit/popcountsi2_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( cmpdi2_test Unit/cmpdi2_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( floattisf_test Unit/floattisf_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( mulvdi3_test Unit/mulvdi3_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( fixunssfdi_test Unit/fixunssfdi_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( fixunsdfsi_test Unit/fixunsdfsi_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( fixunssfti_test Unit/fixunssfti_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( parityti2_test Unit/parityti2_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( negvdi2_test Unit/negvdi2_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( moddi3_test Unit/moddi3_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( clear_cache_test Unit/clear_cache_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( fixunsxfsi_test Unit/fixunsxfsi_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( subvdi3_test Unit/subvdi3_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( multi3_test Unit/multi3_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( addvdi3_test Unit/addvdi3_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( clzti2_test Unit/clzti2_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( umoddi3_test Unit/umoddi3_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( absvsi2_test Unit/absvsi2_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( ctzdi2_test Unit/ctzdi2_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( powitf2_test Unit/powitf2_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( fixsfdi_test Unit/fixsfdi_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( ffsti2_test Unit/ffsti2_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( divdi3_test Unit/divdi3_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( fixsfti_test Unit/fixsfti_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( absvti2_test Unit/absvti2_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( ashrti3_test Unit/ashrti3_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( powisf2_test Unit/powisf2_test.c ${TEST_TARGET_LIBRARIES} )
+# MACRO_ADD_CHECK_TEST( mulxc3_test Unit/mulxc3_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( lshrdi3_test Unit/lshrdi3_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( udivdi3_test Unit/udivdi3_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( clzsi2_test Unit/clzsi2_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( addvti3_test Unit/addvti3_test.c ${TEST_TARGET_LIBRARIES} )
+# MACRO_ADD_CHECK_TEST( udivsi3_test Unit/udivsi3_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( clzdi2_test Unit/clzdi2_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( floatuntidf_test Unit/floatuntidf_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( umodti3_test Unit/umodti3_test.c ${TEST_TARGET_LIBRARIES} )
+# MACRO_ADD_CHECK_TEST( divxc3_test Unit/divxc3_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( ctzti2_test Unit/ctzti2_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( floatuntixf_test Unit/floatuntixf_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( powidf2_test Unit/powidf2_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( floattidf_test Unit/floattidf_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( modti3_test Unit/modti3_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( fixunssfsi_test Unit/fixunssfsi_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( fixunsdfdi_test Unit/fixunsdfdi_test.c ${TEST_TARGET_LIBRARIES} )
+# MACRO_ADD_CHECK_TEST( divsi3_test Unit/divsi3_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( floattixf_test Unit/floattixf_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( fixunsdfti_test Unit/fixunsdfti_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( subvti3_test Unit/subvti3_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( muldi3_test Unit/muldi3_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( ctzsi2_test Unit/ctzsi2_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( absvdi2_test Unit/absvdi2_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( ashrdi3_test Unit/ashrdi3_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( lshrti3_test Unit/lshrti3_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( floatdisf_test Unit/floatdisf_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( addvsi3_test Unit/addvsi3_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( udivti3_test Unit/udivti3_test.c ${TEST_TARGET_LIBRARIES} )
+# MACRO_ADD_CHECK_TEST( umodsi3_test Unit/umodsi3_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( subvsi3_test Unit/subvsi3_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( fixxfdi_test Unit/fixxfdi_test.c ${TEST_TARGET_LIBRARIES} )
+# MACRO_ADD_CHECK_TEST( modsi3_test Unit/modsi3_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( fixxfti_test Unit/fixxfti_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( ffsdi2_test Unit/ffsdi2_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( divti3_test Unit/divti3_test.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( floatundisf_test Unit/floatundisf_test.c ${TEST_TARGET_LIBRARIES} )
+
+#ADD_SUBDIRECTORY( timing )
diff --git a/runtime/test/Unit/absvdi2_test.c b/runtime/test/Unit/absvdi2_test.c
new file mode 100644
index 0000000..5974f9c
--- /dev/null
+++ b/runtime/test/Unit/absvdi2_test.c
@@ -0,0 +1,65 @@
+//===-- absvdi2_test.c - Test __absvdi2 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+
+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/runtime/test/Unit/absvsi2_test.c b/runtime/test/Unit/absvsi2_test.c
new file mode 100644
index 0000000..d7406a0
--- /dev/null
+++ b/runtime/test/Unit/absvsi2_test.c
@@ -0,0 +1,65 @@
+//===-- absvsi2_test.c - Test __absvsi2 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+
+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/runtime/test/Unit/absvti2_test.c b/runtime/test/Unit/absvti2_test.c
new file mode 100644
index 0000000..1ab4f5f
--- /dev/null
+++ b/runtime/test/Unit/absvti2_test.c
@@ -0,0 +1,82 @@
+//===-- absvti2_test.c - Test __absvti2 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __absvti2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#if __x86_64
+
+#include "int_lib.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+// Returns: absolute value
+
+// Effects: aborts if abs(x) < 0
+
+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()
+{
+#if __x86_64
+
+//     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;
+#endif
+    return 0;
+}
diff --git a/runtime/test/Unit/adddf3vfp_test.c b/runtime/test/Unit/adddf3vfp_test.c
new file mode 100644
index 0000000..c5bec05
--- /dev/null
+++ b/runtime/test/Unit/adddf3vfp_test.c
@@ -0,0 +1,46 @@
+//===-- adddf3vfp_test.c - Test __adddf3vfp -------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __adddf3vfp for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+
+#if __arm__
+extern 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;
+#endif
+    return 0;
+}
diff --git a/runtime/test/Unit/addsf3vfp_test.c b/runtime/test/Unit/addsf3vfp_test.c
new file mode 100644
index 0000000..0a731a9
--- /dev/null
+++ b/runtime/test/Unit/addsf3vfp_test.c
@@ -0,0 +1,46 @@
+//===-- addsf3vfp_test.c - Test __addsf3vfp -------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __addsf3vfp for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+
+extern 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;
+#endif
+    return 0;
+}
diff --git a/runtime/test/Unit/addvdi3_test.c b/runtime/test/Unit/addvdi3_test.c
new file mode 100644
index 0000000..b4247bd
--- /dev/null
+++ b/runtime/test/Unit/addvdi3_test.c
@@ -0,0 +1,58 @@
+//===-- addvdi3_test.c - Test __addvdi3 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+
+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/runtime/test/Unit/addvsi3_test.c b/runtime/test/Unit/addvsi3_test.c
new file mode 100644
index 0000000..f6acde1
--- /dev/null
+++ b/runtime/test/Unit/addvsi3_test.c
@@ -0,0 +1,58 @@
+//===-- addvsi3_test.c - Test __addvsi3 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+
+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/runtime/test/Unit/addvti3_test.c b/runtime/test/Unit/addvti3_test.c
new file mode 100644
index 0000000..17a8864
--- /dev/null
+++ b/runtime/test/Unit/addvti3_test.c
@@ -0,0 +1,92 @@
+//===-- addvti3_test.c - Test __addvti3 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __addvti3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#if __x86_64
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns: a + b
+
+// Effects: aborts if a + b overflows
+
+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()
+{
+#if __x86_64
+// 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;
+
+#endif
+    return 0;
+}
diff --git a/runtime/test/Unit/ashldi3_test.c b/runtime/test/Unit/ashldi3_test.c
new file mode 100644
index 0000000..8afe3d7
--- /dev/null
+++ b/runtime/test/Unit/ashldi3_test.c
@@ -0,0 +1,77 @@
+//===-- ashldi3_test.c - Test __ashldi3 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+
+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/runtime/test/Unit/ashlti3_test.c b/runtime/test/Unit/ashlti3_test.c
new file mode 100644
index 0000000..2921a6a
--- /dev/null
+++ b/runtime/test/Unit/ashlti3_test.c
@@ -0,0 +1,173 @@
+//===-- ashlti3_test.c - Test __ashlti3 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __ashlti3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#if __x86_64
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns: a << b
+
+// Precondition:  0 <= b < bits_in_tword
+
+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()
+{
+#if __x86_64
+    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;
+#endif
+    return 0;
+}
diff --git a/runtime/test/Unit/ashrdi3_test.c b/runtime/test/Unit/ashrdi3_test.c
new file mode 100644
index 0000000..487fa25
--- /dev/null
+++ b/runtime/test/Unit/ashrdi3_test.c
@@ -0,0 +1,118 @@
+//===-- ashrdi3_test.c - Test __ashrdi3 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+
+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/runtime/test/Unit/ashrti3_test.c b/runtime/test/Unit/ashrti3_test.c
new file mode 100644
index 0000000..aaef120
--- /dev/null
+++ b/runtime/test/Unit/ashrti3_test.c
@@ -0,0 +1,171 @@
+//===-- ashrti3_test.c - Test __ashrti3 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __ashrti3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#if __x86_64
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns: arithmetic a >> b
+
+// Precondition:  0 <= b < bits_in_tword
+
+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()
+{
+#if __x86_64
+    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;
+#endif
+    return 0;
+}
diff --git a/runtime/test/Unit/bswapdi2_test.c b/runtime/test/Unit/bswapdi2_test.c
new file mode 100644
index 0000000..177032d
--- /dev/null
+++ b/runtime/test/Unit/bswapdi2_test.c
@@ -0,0 +1,42 @@
+//===-- bswapdi2_test.c - Test __bswapdi2 ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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;
+#endif
+    return 0;
+}
diff --git a/runtime/test/Unit/bswapsi2_test.c b/runtime/test/Unit/bswapsi2_test.c
new file mode 100644
index 0000000..8ca4874
--- /dev/null
+++ b/runtime/test/Unit/bswapsi2_test.c
@@ -0,0 +1,42 @@
+//===-- bswapsi2_test.c - Test __bswapsi2 ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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;
+#endif
+    return 0;
+}
diff --git a/runtime/test/Unit/clear_cache_test.c b/runtime/test/Unit/clear_cache_test.c
new file mode 100644
index 0000000..63ca66e
--- /dev/null
+++ b/runtime/test/Unit/clear_cache_test.c
@@ -0,0 +1,59 @@
+//===-- clear_cache_test.c - Test clear_cache -----------------------------===//
+//
+//                     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 <string.h>
+#include <stdint.h>
+#include <sys/mman.h>
+
+
+
+extern void __clear_cache(void* start, void* end);
+
+typedef int (*pfunc)(void);
+
+int func1() 
+{
+    return 1;
+}
+
+int func2() 
+{
+    return 2;
+}
+
+
+
+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 ( mprotect(start, end-start, PROT_READ|PROT_WRITE|PROT_EXEC) != 0 )
+        return 1;
+
+    // verify you can copy and execute a function
+    memcpy(execution_buffer, (void *)(uintptr_t)&func1, 128);
+    __clear_cache(execution_buffer, &execution_buffer[128]);
+    pfunc f1 = (pfunc)(uintptr_t)execution_buffer;
+    if ( (*f1)() != 1 )
+        return 1;
+
+    // verify you can overwrite a function with another
+    memcpy(execution_buffer, (void *)(uintptr_t)&func2, 128);
+    __clear_cache(execution_buffer, &execution_buffer[128]);
+    pfunc f2 = (pfunc)(uintptr_t)execution_buffer;
+    if ( (*f2)() != 2 )
+        return 1;
+
+    return 0;
+}
diff --git a/runtime/test/Unit/clzdi2_test.c b/runtime/test/Unit/clzdi2_test.c
new file mode 100644
index 0000000..24b85d8
--- /dev/null
+++ b/runtime/test/Unit/clzdi2_test.c
@@ -0,0 +1,68 @@
+//===-- clzdi2_test.c - Test __clzdi2 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+
+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/runtime/test/Unit/clzsi2_test.c b/runtime/test/Unit/clzsi2_test.c
new file mode 100644
index 0000000..c4555d7
--- /dev/null
+++ b/runtime/test/Unit/clzsi2_test.c
@@ -0,0 +1,599 @@
+//===-- clzsi2_test.c - Test __clzsi2 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+
+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/runtime/test/Unit/clzti2_test.c b/runtime/test/Unit/clzti2_test.c
new file mode 100644
index 0000000..e1229f1
--- /dev/null
+++ b/runtime/test/Unit/clzti2_test.c
@@ -0,0 +1,88 @@
+//===-- clzti2_test.c - Test __clzti2 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __clzti2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#if __x86_64
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns: the number of leading 0-bits
+
+// Precondition: a != 0
+
+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()
+{
+#if __x86_64
+    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;
+#endif
+   return 0;
+}
diff --git a/runtime/test/Unit/cmpdi2_test.c b/runtime/test/Unit/cmpdi2_test.c
new file mode 100644
index 0000000..459a5d5
--- /dev/null
+++ b/runtime/test/Unit/cmpdi2_test.c
@@ -0,0 +1,77 @@
+//===-- cmpdi2_test.c - Test __cmpdi2 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+
+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/runtime/test/Unit/cmpti2_test.c b/runtime/test/Unit/cmpti2_test.c
new file mode 100644
index 0000000..f590ddf
--- /dev/null
+++ b/runtime/test/Unit/cmpti2_test.c
@@ -0,0 +1,110 @@
+//===-- cmpti2_test.c - Test __cmpti2 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __cmpti2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#if __x86_64
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns:  if (a <  b) returns 0
+//           if (a == b) returns 1
+//           if (a >  b) returns 2
+
+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()
+{
+#if __x86_64
+    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;
+
+#endif
+   return 0;
+}
diff --git a/runtime/test/Unit/ctzdi2_test.c b/runtime/test/Unit/ctzdi2_test.c
new file mode 100644
index 0000000..b72fdb3
--- /dev/null
+++ b/runtime/test/Unit/ctzdi2_test.c
@@ -0,0 +1,67 @@
+//===-- ctzdi2_test.c - Test __ctzdi2 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+
+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/runtime/test/Unit/ctzsi2_test.c b/runtime/test/Unit/ctzsi2_test.c
new file mode 100644
index 0000000..2c6fd0e
--- /dev/null
+++ b/runtime/test/Unit/ctzsi2_test.c
@@ -0,0 +1,569 @@
+//===-- ctzsi2_test.c - Test __ctzsi2 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+
+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/runtime/test/Unit/ctzti2_test.c b/runtime/test/Unit/ctzti2_test.c
new file mode 100644
index 0000000..ad18b44
--- /dev/null
+++ b/runtime/test/Unit/ctzti2_test.c
@@ -0,0 +1,82 @@
+//===-- ctzti2_test.c - Test __ctzti2 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __ctzti2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#if __x86_64
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns: the number of trailing 0-bits
+
+// Precondition: a != 0
+
+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()
+{
+#if __x86_64
+    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;
+#endif
+
+   return 0;
+}
diff --git a/runtime/test/Unit/divdc3_test.c b/runtime/test/Unit/divdc3_test.c
new file mode 100644
index 0000000..c44eb5c
--- /dev/null
+++ b/runtime/test/Unit/divdc3_test.c
@@ -0,0 +1,370 @@
+//===-- divdc3_test.c - Test __divdc3 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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)
+
+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/runtime/test/Unit/divdf3vfp_test.c b/runtime/test/Unit/divdf3vfp_test.c
new file mode 100644
index 0000000..2ca382a
--- /dev/null
+++ b/runtime/test/Unit/divdf3vfp_test.c
@@ -0,0 +1,46 @@
+//===-- divdf3vfp_test.c - Test __divdf3vfp -------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __divdf3vfp for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+
+#if __arm__
+extern 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;
+#endif
+    return 0;
+}
diff --git a/runtime/test/Unit/divdi3_test.c b/runtime/test/Unit/divdi3_test.c
new file mode 100644
index 0000000..0566a78
--- /dev/null
+++ b/runtime/test/Unit/divdi3_test.c
@@ -0,0 +1,58 @@
+//===-- divdi3_test.c - Test __divdi3 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __divdi3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns: a / b
+
+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/runtime/test/Unit/divsc3_test.c b/runtime/test/Unit/divsc3_test.c
new file mode 100644
index 0000000..50979ab
--- /dev/null
+++ b/runtime/test/Unit/divsc3_test.c
@@ -0,0 +1,370 @@
+//===-- divsc3_test.c - Test __divsc3 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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)
+
+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/runtime/test/Unit/divsf3vfp_test.c b/runtime/test/Unit/divsf3vfp_test.c
new file mode 100644
index 0000000..0dbae2f
--- /dev/null
+++ b/runtime/test/Unit/divsf3vfp_test.c
@@ -0,0 +1,46 @@
+//===-- divsf3vfp_test.c - Test __divsf3vfp -------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __divsf3vfp for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+
+extern 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;
+#endif
+    return 0;
+}
diff --git a/runtime/test/Unit/divsi3_test.c b/runtime/test/Unit/divsi3_test.c
new file mode 100644
index 0000000..425c579
--- /dev/null
+++ b/runtime/test/Unit/divsi3_test.c
@@ -0,0 +1,56 @@
+//===-- divsi3_test.c - Test __divsi3 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __divsi3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns: a / b
+
+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/runtime/test/Unit/divtc3_test.c b/runtime/test/Unit/divtc3_test.c
new file mode 100644
index 0000000..3fa6085
--- /dev/null
+++ b/runtime/test/Unit/divtc3_test.c
@@ -0,0 +1,380 @@
+//===-- divtc3_test.c - Test __divtc3 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __divtc3 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)
+
+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 (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__divtc3(x[i][0], x[i][1], x[j][0], x[j][1]))
+                return 1;
+        }
+    }
+	
+//	printf("No errors found.\n");
+
+#endif
+    return 0;
+}
diff --git a/runtime/test/Unit/divti3_test.c b/runtime/test/Unit/divti3_test.c
new file mode 100644
index 0000000..b5546ca
--- /dev/null
+++ b/runtime/test/Unit/divti3_test.c
@@ -0,0 +1,76 @@
+//===-- divti3_test.c - Test __divti3 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __divti3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#if __x86_64
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns: a / b
+
+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()
+{
+#if __x86_64
+    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;
+
+#endif
+    return 0;
+}
diff --git a/runtime/test/Unit/divxc3_test.c b/runtime/test/Unit/divxc3_test.c
new file mode 100644
index 0000000..6c64d34
--- /dev/null
+++ b/runtime/test/Unit/divxc3_test.c
@@ -0,0 +1,377 @@
+//===-- divxc3_test.c - Test __divxc3 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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)
+
+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;
+        }
+    }
+
+#endif
+    return 0;
+}
diff --git a/runtime/test/Unit/enable_execute_stack_test.c b/runtime/test/Unit/enable_execute_stack_test.c
new file mode 100644
index 0000000..a0e97bb
--- /dev/null
+++ b/runtime/test/Unit/enable_execute_stack_test.c
@@ -0,0 +1,57 @@
+//===-- enable_execute_stack_test.c - Test __enable_execute_stack ----------===//
+//
+//                     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 <string.h>
+#include <stdint.h>
+#include <sys/mman.h>
+
+
+
+extern void __clear_cache(void* start, void* end);
+extern void __enable_execute_stack(void* addr);
+
+typedef int (*pfunc)(void);
+
+int func1() 
+{
+    return 1;
+}
+
+int func2() 
+{
+    return 2;
+}
+
+
+
+
+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
+    memcpy(execution_buffer, (void *)(uintptr_t)&func1, 128);
+    __clear_cache(execution_buffer, &execution_buffer[128]);
+    pfunc f1 = (pfunc)(uintptr_t)execution_buffer;
+    if ( (*f1)() != 1 )
+        return 1;
+
+    // verify you can overwrite a function with another
+    memcpy(execution_buffer, (void *)(uintptr_t)&func2, 128);
+    __clear_cache(execution_buffer, &execution_buffer[128]);
+    pfunc f2 = (pfunc)(uintptr_t)execution_buffer;
+    if ( (*f2)() != 2 )
+        return 1;
+
+    return 0;
+}
diff --git a/runtime/test/Unit/endianness.h b/runtime/test/Unit/endianness.h
new file mode 100644
index 0000000..28b0ace
--- /dev/null
+++ b/runtime/test/Unit/endianness.h
@@ -0,0 +1,94 @@
+/* ===-- endianness.h - configuration header for libgcc replacement --------===
+ *
+ *		       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 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__)
+#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 */
+
+/* .. */
+
+/* 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/runtime/test/Unit/eqdf2vfp_test.c b/runtime/test/Unit/eqdf2vfp_test.c
new file mode 100644
index 0000000..36b77ad
--- /dev/null
+++ b/runtime/test/Unit/eqdf2vfp_test.c
@@ -0,0 +1,53 @@
+//===-- eqdf2vfp_test.c - Test __eqdf2vfp ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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;
+#endif
+    return 0;
+}
diff --git a/runtime/test/Unit/eqsf2vfp_test.c b/runtime/test/Unit/eqsf2vfp_test.c
new file mode 100644
index 0000000..ebcdbc4
--- /dev/null
+++ b/runtime/test/Unit/eqsf2vfp_test.c
@@ -0,0 +1,49 @@
+//===-- eqsf2vfp_test.c - Test __eqsf2vfp ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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;
+#endif
+    return 0;
+}
diff --git a/runtime/test/Unit/extebdsfdf2vfp_test.c b/runtime/test/Unit/extebdsfdf2vfp_test.c
new file mode 100644
index 0000000..f2cf682
--- /dev/null
+++ b/runtime/test/Unit/extebdsfdf2vfp_test.c
@@ -0,0 +1,46 @@
+//===-- extendsfdf2vfp_test.c - Test __extendsfdf2vfp ---------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __extendsfdf2vfp for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+
+extern 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;
+#endif
+    return 0;
+}
diff --git a/runtime/test/Unit/ffsdi2_test.c b/runtime/test/Unit/ffsdi2_test.c
new file mode 100644
index 0000000..8713c4f
--- /dev/null
+++ b/runtime/test/Unit/ffsdi2_test.c
@@ -0,0 +1,66 @@
+//===-- ffsdi2_test.c - Test __ffsdi2 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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.
+
+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/runtime/test/Unit/ffsti2_test.c b/runtime/test/Unit/ffsti2_test.c
new file mode 100644
index 0000000..19da16a
--- /dev/null
+++ b/runtime/test/Unit/ffsti2_test.c
@@ -0,0 +1,81 @@
+//===-- ffsti2_test.c - Test __ffsti2 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __ffsti2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#if __x86_64
+
+#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.
+
+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()
+{
+#if __x86_64
+    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;
+
+#endif
+   return 0;
+}
diff --git a/runtime/test/Unit/fixdfdi_test.c b/runtime/test/Unit/fixdfdi_test.c
new file mode 100644
index 0000000..d84d26d
--- /dev/null
+++ b/runtime/test/Unit/fixdfdi_test.c
@@ -0,0 +1,94 @@
+//===-- fixdfdi_test.c - Test __fixdfdi -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+
+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/runtime/test/Unit/fixdfsivfp_test.c b/runtime/test/Unit/fixdfsivfp_test.c
new file mode 100644
index 0000000..00d24fb
--- /dev/null
+++ b/runtime/test/Unit/fixdfsivfp_test.c
@@ -0,0 +1,48 @@
+//===-- fixdfsivfp_test.c - Test __fixdfsivfp -----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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;
+#endif
+    return 0;
+}
diff --git a/runtime/test/Unit/fixdfti_test.c b/runtime/test/Unit/fixdfti_test.c
new file mode 100644
index 0000000..9761963
--- /dev/null
+++ b/runtime/test/Unit/fixdfti_test.c
@@ -0,0 +1,121 @@
+//===-- fixdfti_test.c - Test __fixdfti -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __fixdfti for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#if __x86_64
+
+#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 ti_int (no range checking performed)
+
+// seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
+
+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()
+{
+#if __x86_64
+    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;
+
+#endif
+   return 0;
+}
diff --git a/runtime/test/Unit/fixsfdi_test.c b/runtime/test/Unit/fixsfdi_test.c
new file mode 100644
index 0000000..434e1a9
--- /dev/null
+++ b/runtime/test/Unit/fixsfdi_test.c
@@ -0,0 +1,84 @@
+//===-- fixsfdi_test.c - Test __fixsfdi -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+
+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/runtime/test/Unit/fixsfsivfp_test.c b/runtime/test/Unit/fixsfsivfp_test.c
new file mode 100644
index 0000000..19d70b1
--- /dev/null
+++ b/runtime/test/Unit/fixsfsivfp_test.c
@@ -0,0 +1,50 @@
+//===-- fixsfsivfp_test.c - Test __fixsfsivfp -----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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;
+#endif
+    return 0;
+}
diff --git a/runtime/test/Unit/fixsfti_test.c b/runtime/test/Unit/fixsfti_test.c
new file mode 100644
index 0000000..0685307
--- /dev/null
+++ b/runtime/test/Unit/fixsfti_test.c
@@ -0,0 +1,109 @@
+//===-- fixsfti_test.c - Test __fixsfti -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __fixsfti for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#if __x86_64
+
+#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 ti_int (no range checking performed)
+
+// seee eeee emmm mmmm mmmm mmmm mmmm mmmm
+
+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()
+{
+#if __x86_64
+    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;
+
+#endif
+   return 0;
+}
diff --git a/runtime/test/Unit/fixunsdfdi_test.c b/runtime/test/Unit/fixunsdfdi_test.c
new file mode 100644
index 0000000..fbdf368
--- /dev/null
+++ b/runtime/test/Unit/fixunsdfdi_test.c
@@ -0,0 +1,106 @@
+//===-- fixunsdfdi_test.c - Test __fixunsdfdi -----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+
+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 !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/runtime/test/Unit/fixunsdfsi_test.c b/runtime/test/Unit/fixunsdfsi_test.c
new file mode 100644
index 0000000..9e6b95d
--- /dev/null
+++ b/runtime/test/Unit/fixunsdfsi_test.c
@@ -0,0 +1,100 @@
+//===-- fixunsdfsi_test.c - Test __fixunsdfsi -----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+
+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.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/runtime/test/Unit/fixunsdfsivfp_test.c b/runtime/test/Unit/fixunsdfsivfp_test.c
new file mode 100644
index 0000000..7c968f2
--- /dev/null
+++ b/runtime/test/Unit/fixunsdfsivfp_test.c
@@ -0,0 +1,48 @@
+//===-- fixunsdfsivfp_test.c - Test __fixunsdfsivfp -----------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __fixunsdfsivfp for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+
+extern 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;
+#endif
+    return 0;
+}
diff --git a/runtime/test/Unit/fixunsdfti_test.c b/runtime/test/Unit/fixunsdfti_test.c
new file mode 100644
index 0000000..5b52466
--- /dev/null
+++ b/runtime/test/Unit/fixunsdfti_test.c
@@ -0,0 +1,128 @@
+//===-- fixunsdfti_test.c - Test __fixunsdfti -----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+
+#if __x86_64
+
+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()
+{
+#if __x86_64
+    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 !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/runtime/test/Unit/fixunssfdi_test.c b/runtime/test/Unit/fixunssfdi_test.c
new file mode 100644
index 0000000..cde3c22
--- /dev/null
+++ b/runtime/test/Unit/fixunssfdi_test.c
@@ -0,0 +1,95 @@
+//===-- fixunssfdi_test.c - Test __fixunssfdi -----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+
+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.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/runtime/test/Unit/fixunssfsi_test.c b/runtime/test/Unit/fixunssfsi_test.c
new file mode 100644
index 0000000..c8995b0
--- /dev/null
+++ b/runtime/test/Unit/fixunssfsi_test.c
@@ -0,0 +1,93 @@
+//===-- fixunssfsi_test.c - Test __fixunssfsi -----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+
+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.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/runtime/test/Unit/fixunssfsivfp_test.c b/runtime/test/Unit/fixunssfsivfp_test.c
new file mode 100644
index 0000000..9653175
--- /dev/null
+++ b/runtime/test/Unit/fixunssfsivfp_test.c
@@ -0,0 +1,48 @@
+//===-- fixunssfsivfp_test.c - Test __fixunssfsivfp -----------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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;
+#endif
+    return 0;
+}
diff --git a/runtime/test/Unit/fixunssfti_test.c b/runtime/test/Unit/fixunssfti_test.c
new file mode 100644
index 0000000..33f0596
--- /dev/null
+++ b/runtime/test/Unit/fixunssfti_test.c
@@ -0,0 +1,120 @@
+//===-- fixunssfti_test.c - Test __fixunssfti -----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __fixunssfti for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#if __x86_64
+
+#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 
+//             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
+
+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()
+{
+#if __x86_64
+    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/runtime/test/Unit/fixunstfdi_test.c b/runtime/test/Unit/fixunstfdi_test.c
new file mode 100644
index 0000000..d96b0ea
--- /dev/null
+++ b/runtime/test/Unit/fixunstfdi_test.c
@@ -0,0 +1,119 @@
+//===-- fixunstfdi_test.c - Test __fixunstfdi -----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __fixunstfdi for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#if _ARCH_PPC
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns: convert a to a unsigned long long, rounding toward zero.
+//          Negative values all become zero.
+
+// Assumption: long double is a ppc 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)
+
+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
+    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.0000000000000000p+63L, 0))
+        return 1;
+    if (test__fixunstfdi(-0x1.FFFFFFFFFFFFFFFCp+62L, 0))
+        return 1;
+    if (test__fixunstfdi(-0x1.FFFFFFFFFFFFFFF8p+62L, 0))
+        return 1;
+
+#endif
+   return 0;
+}
diff --git a/runtime/test/Unit/fixunsxfdi_test.c b/runtime/test/Unit/fixunsxfdi_test.c
new file mode 100644
index 0000000..f8c8945
--- /dev/null
+++ b/runtime/test/Unit/fixunsxfdi_test.c
@@ -0,0 +1,122 @@
+//===-- fixunsxfdi_test.c - Test __fixunsxfdi -----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+
+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;
+
+#endif
+   return 0;
+}
diff --git a/runtime/test/Unit/fixunsxfsi_test.c b/runtime/test/Unit/fixunsxfsi_test.c
new file mode 100644
index 0000000..0353b6b
--- /dev/null
+++ b/runtime/test/Unit/fixunsxfsi_test.c
@@ -0,0 +1,105 @@
+//===-- fixunsxfsi_test.c - Test __fixunsxfsi -----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+
+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/runtime/test/Unit/fixunsxfti_test.c b/runtime/test/Unit/fixunsxfti_test.c
new file mode 100644
index 0000000..ae5ba08
--- /dev/null
+++ b/runtime/test/Unit/fixunsxfti_test.c
@@ -0,0 +1,139 @@
+//===-- fixunsxfti_test.c - Test __fixunsxfti -----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __fixunsxfti for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#if __x86_64
+
+#include "int_lib.h"
+#include <stdio.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
+//             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
+
+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()
+{
+#if __x86_64
+    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;
+
+#endif
+   return 0;
+}
diff --git a/runtime/test/Unit/fixxfdi_test.c b/runtime/test/Unit/fixxfdi_test.c
new file mode 100644
index 0000000..47820c3
--- /dev/null
+++ b/runtime/test/Unit/fixxfdi_test.c
@@ -0,0 +1,113 @@
+//===-- fixxfdi_test.c - Test __fixxfdi -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+
+di_int __fixxfdi(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;
+
+#endif
+   return 0;
+}
diff --git a/runtime/test/Unit/fixxfti_test.c b/runtime/test/Unit/fixxfti_test.c
new file mode 100644
index 0000000..0d3d182
--- /dev/null
+++ b/runtime/test/Unit/fixxfti_test.c
@@ -0,0 +1,144 @@
+//===-- fixxfti_test.c - Test __fixxfti -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __fixxfti for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#if __x86_64
+
+#include "int_lib.h"
+#include <stdio.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
+//             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
+
+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()
+{
+#if __x86_64
+    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;
+#endif
+   return 0;
+}
diff --git a/runtime/test/Unit/floatdidf_test.c b/runtime/test/Unit/floatdidf_test.c
new file mode 100644
index 0000000..d207f55
--- /dev/null
+++ b/runtime/test/Unit/floatdidf_test.c
@@ -0,0 +1,137 @@
+//===-- floatdidf.c - Test __floatdidf ------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+
+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/runtime/test/Unit/floatdisf_test.c b/runtime/test/Unit/floatdisf_test.c
new file mode 100644
index 0000000..91e098d
--- /dev/null
+++ b/runtime/test/Unit/floatdisf_test.c
@@ -0,0 +1,95 @@
+//===-- floatdisf_test.c - Test __floatdisf -------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+
+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/runtime/test/Unit/floatdixf_test.c b/runtime/test/Unit/floatdixf_test.c
new file mode 100644
index 0000000..d96c7e8
--- /dev/null
+++ b/runtime/test/Unit/floatdixf_test.c
@@ -0,0 +1,142 @@
+//===-- floatdixf_test.c - Test __floatdixf -------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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 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;
+
+#endif
+   return 0;
+}
diff --git a/runtime/test/Unit/floatsidfvfp_test.c b/runtime/test/Unit/floatsidfvfp_test.c
new file mode 100644
index 0000000..956fe86
--- /dev/null
+++ b/runtime/test/Unit/floatsidfvfp_test.c
@@ -0,0 +1,48 @@
+//===-- floatsidfvfp_test.c - Test __floatsidfvfp -------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __floatsidfvfp for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+
+extern 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;
+#endif
+    return 0;
+}
diff --git a/runtime/test/Unit/floatsisfvfp_test.c b/runtime/test/Unit/floatsisfvfp_test.c
new file mode 100644
index 0000000..5642e9b
--- /dev/null
+++ b/runtime/test/Unit/floatsisfvfp_test.c
@@ -0,0 +1,48 @@
+//===-- floatsisfvfp_test.c - Test __floatsisfvfp -------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __floatsisfvfp for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+
+extern 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;
+#endif
+    return 0;
+}
diff --git a/runtime/test/Unit/floattidf_test.c b/runtime/test/Unit/floattidf_test.c
new file mode 100644
index 0000000..fff51ae
--- /dev/null
+++ b/runtime/test/Unit/floattidf_test.c
@@ -0,0 +1,178 @@
+//===-- floattidf.c - Test __floattidf ------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __floattidf for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#if __x86_64
+
+#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 
+//             ti_int is a 64 bit integral type
+
+// seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
+
+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()
+{
+#if __x86_64
+    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;
+#endif
+   return 0;
+}
diff --git a/runtime/test/Unit/floattisf_test.c b/runtime/test/Unit/floattisf_test.c
new file mode 100644
index 0000000..e4c9980
--- /dev/null
+++ b/runtime/test/Unit/floattisf_test.c
@@ -0,0 +1,134 @@
+//===-- floattisf_test.c - Test __floattisf -------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __floattisf for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#if __x86_64
+
+#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 
+//             ti_int is a 64 bit integral type
+
+// seee eeee emmm mmmm mmmm mmmm mmmm mmmm
+
+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()
+{
+#if __x86_64
+    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;
+
+#endif
+   return 0;
+}
diff --git a/runtime/test/Unit/floattixf_test.c b/runtime/test/Unit/floattixf_test.c
new file mode 100644
index 0000000..ada9594
--- /dev/null
+++ b/runtime/test/Unit/floattixf_test.c
@@ -0,0 +1,210 @@
+//===-- floattixf.c - Test __floattixf ------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __floattixf for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#if __x86_64
+
+#include "int_lib.h"
+#include <float.h>
+#include <stdio.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
+//             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
+
+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()
+{
+#if __x86_64
+    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;
+#endif
+   return 0;
+}
diff --git a/runtime/test/Unit/floatundidf_test.c b/runtime/test/Unit/floatundidf_test.c
new file mode 100644
index 0000000..5a8dcbf
--- /dev/null
+++ b/runtime/test/Unit/floatundidf_test.c
@@ -0,0 +1,132 @@
+//===-- floatundidf_test.c - Test __floatundidf ---------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+
+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/runtime/test/Unit/floatundisf_test.c b/runtime/test/Unit/floatundisf_test.c
new file mode 100644
index 0000000..782db6d
--- /dev/null
+++ b/runtime/test/Unit/floatundisf_test.c
@@ -0,0 +1,96 @@
+//===-- floatundisf_test.c - Test __floatundisf ---------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+
+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/runtime/test/Unit/floatundixf_test.c b/runtime/test/Unit/floatundixf_test.c
new file mode 100644
index 0000000..40e1d72
--- /dev/null
+++ b/runtime/test/Unit/floatundixf_test.c
@@ -0,0 +1,143 @@
+//===-- floatundixf_test.c - Test __floatundixf ---------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+
+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;
+
+#endif
+   return 0;
+}
diff --git a/runtime/test/Unit/floatunssidfvfp_test.c b/runtime/test/Unit/floatunssidfvfp_test.c
new file mode 100644
index 0000000..be0bd07
--- /dev/null
+++ b/runtime/test/Unit/floatunssidfvfp_test.c
@@ -0,0 +1,48 @@
+//===-- floatunssidfvfp_test.c - Test __floatunssidfvfp -------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __floatunssidfvfp for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+
+extern 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;
+#endif
+    return 0;
+}
diff --git a/runtime/test/Unit/floatunssisfvfp_test.c b/runtime/test/Unit/floatunssisfvfp_test.c
new file mode 100644
index 0000000..13cee2f
--- /dev/null
+++ b/runtime/test/Unit/floatunssisfvfp_test.c
@@ -0,0 +1,48 @@
+//===-- floatunssisfvfp_test.c - Test __floatunssisfvfp -------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __floatunssisfvfp for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+
+extern 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;
+#endif
+    return 0;
+}
diff --git a/runtime/test/Unit/floatuntidf_test.c b/runtime/test/Unit/floatuntidf_test.c
new file mode 100644
index 0000000..dff3ca6
--- /dev/null
+++ b/runtime/test/Unit/floatuntidf_test.c
@@ -0,0 +1,172 @@
+//===-- floatuntidf.c - Test __floatuntidf --------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __floatuntidf for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#if __x86_64
+
+#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 
+//             tu_int is a 64 bit integral type
+
+// seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
+
+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()
+{
+#if __x86_64
+    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;
+#endif
+   return 0;
+}
diff --git a/runtime/test/Unit/floatuntisf_test.c b/runtime/test/Unit/floatuntisf_test.c
new file mode 100644
index 0000000..668e727
--- /dev/null
+++ b/runtime/test/Unit/floatuntisf_test.c
@@ -0,0 +1,163 @@
+//===-- floatuntisf.c - Test __floatuntisf --------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __floatuntisf for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#if __x86_64
+
+#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 
+//             tu_int is a 128 bit integral type
+
+// seee eeee emmm mmmm mmmm mmmm mmmm mmmm
+
+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()
+{
+#if __x86_64
+    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;
+
+#endif
+   return 0;
+}
diff --git a/runtime/test/Unit/floatuntixf_test.c b/runtime/test/Unit/floatuntixf_test.c
new file mode 100644
index 0000000..ec4c3ea
--- /dev/null
+++ b/runtime/test/Unit/floatuntixf_test.c
@@ -0,0 +1,217 @@
+//===-- floatuntixf.c - Test __floatuntixf --------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __floatuntixf for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#if __x86_64
+
+#include "int_lib.h"
+#include <float.h>
+#include <stdio.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
+//             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
+
+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()
+{
+#if __x86_64
+    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;
+#endif
+   return 0;
+}
diff --git a/runtime/test/Unit/gcc_personality_test.c b/runtime/test/Unit/gcc_personality_test.c
new file mode 100644
index 0000000..7fe661b
--- /dev/null
+++ b/runtime/test/Unit/gcc_personality_test.c
@@ -0,0 +1,42 @@
+/* ===-- gcc_personality_test.c - Tests __gcc_personality_v0 -------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. 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/runtime/test/Unit/gcc_personality_test_helper.cxx b/runtime/test/Unit/gcc_personality_test_helper.cxx
new file mode 100644
index 0000000..eb64d82
--- /dev/null
+++ b/runtime/test/Unit/gcc_personality_test_helper.cxx
@@ -0,0 +1,85 @@
+//===-- gcc_personality_test_helper.cxx -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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/runtime/test/Unit/gedf2vfp_test.c b/runtime/test/Unit/gedf2vfp_test.c
new file mode 100644
index 0000000..93df4c7
--- /dev/null
+++ b/runtime/test/Unit/gedf2vfp_test.c
@@ -0,0 +1,51 @@
+//===-- gedf2vfp_test.c - Test __gedf2vfp ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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;
+#endif
+    return 0;
+}
diff --git a/runtime/test/Unit/gesf2vfp_test.c b/runtime/test/Unit/gesf2vfp_test.c
new file mode 100644
index 0000000..af67c70
--- /dev/null
+++ b/runtime/test/Unit/gesf2vfp_test.c
@@ -0,0 +1,51 @@
+//===-- gesf2vfp_test.c - Test __gesf2vfp ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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;
+#endif
+    return 0;
+}
diff --git a/runtime/test/Unit/gtdf2vfp_test.c b/runtime/test/Unit/gtdf2vfp_test.c
new file mode 100644
index 0000000..d39ad82
--- /dev/null
+++ b/runtime/test/Unit/gtdf2vfp_test.c
@@ -0,0 +1,51 @@
+//===-- gtdf2vfp_test.c - Test __gtdf2vfp ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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;
+#endif
+    return 0;
+}
diff --git a/runtime/test/Unit/gtsf2vfp_test.c b/runtime/test/Unit/gtsf2vfp_test.c
new file mode 100644
index 0000000..40c37f2
--- /dev/null
+++ b/runtime/test/Unit/gtsf2vfp_test.c
@@ -0,0 +1,51 @@
+//===-- gtsf2vfp_test.c - Test __gtsf2vfp ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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;
+#endif
+    return 0;
+}
diff --git a/runtime/test/Unit/ledf2vfp_test.c b/runtime/test/Unit/ledf2vfp_test.c
new file mode 100644
index 0000000..87455c3
--- /dev/null
+++ b/runtime/test/Unit/ledf2vfp_test.c
@@ -0,0 +1,51 @@
+//===-- ledf2vfp_test.c - Test __ledf2vfp ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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;
+#endif
+    return 0;
+}
diff --git a/runtime/test/Unit/lesf2vfp_test.c b/runtime/test/Unit/lesf2vfp_test.c
new file mode 100644
index 0000000..03cb02a
--- /dev/null
+++ b/runtime/test/Unit/lesf2vfp_test.c
@@ -0,0 +1,51 @@
+//===-- lesf2vfp_test.c - Test __lesf2vfp ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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;
+#endif
+    return 0;
+}
diff --git a/runtime/test/Unit/lshrdi3_test.c b/runtime/test/Unit/lshrdi3_test.c
new file mode 100644
index 0000000..90ad06b
--- /dev/null
+++ b/runtime/test/Unit/lshrdi3_test.c
@@ -0,0 +1,118 @@
+//===-- lshrdi3_test.c - Test __lshrdi3 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+
+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/runtime/test/Unit/lshrti3_test.c b/runtime/test/Unit/lshrti3_test.c
new file mode 100644
index 0000000..5d68c52
--- /dev/null
+++ b/runtime/test/Unit/lshrti3_test.c
@@ -0,0 +1,171 @@
+//===-- lshrti3_test.c - Test __lshrti3 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __lshrti3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#if __x86_64
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns: logical a >> b
+
+// Precondition:  0 <= b < bits_in_dword
+
+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()
+{
+#if __x86_64
+    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;
+#endif
+    return 0;
+}
diff --git a/runtime/test/Unit/ltdf2vfp_test.c b/runtime/test/Unit/ltdf2vfp_test.c
new file mode 100644
index 0000000..615785e
--- /dev/null
+++ b/runtime/test/Unit/ltdf2vfp_test.c
@@ -0,0 +1,49 @@
+//===-- ltdf2vfp_test.c - Test __ltdf2vfp ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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;
+#endif
+    return 0;
+}
diff --git a/runtime/test/Unit/ltsf2vfp_test.c b/runtime/test/Unit/ltsf2vfp_test.c
new file mode 100644
index 0000000..73df39f
--- /dev/null
+++ b/runtime/test/Unit/ltsf2vfp_test.c
@@ -0,0 +1,51 @@
+//===-- ltsf2vfp_test.c - Test __ltsf2vfp ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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;
+#endif
+    return 0;
+}
diff --git a/runtime/test/Unit/moddi3_test.c b/runtime/test/Unit/moddi3_test.c
new file mode 100644
index 0000000..ab84c49
--- /dev/null
+++ b/runtime/test/Unit/moddi3_test.c
@@ -0,0 +1,62 @@
+//===-- moddi3_test.c - Test __moddi3 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __moddi3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns: a % b
+
+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/runtime/test/Unit/modsi3_test.c b/runtime/test/Unit/modsi3_test.c
new file mode 100644
index 0000000..82a0fab
--- /dev/null
+++ b/runtime/test/Unit/modsi3_test.c
@@ -0,0 +1,57 @@
+/* ===-- modsi3_test.c - Test __modsi3 -------------------------------------===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file tests __modsi3 for the compiler_rt library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+#include <stdio.h>
+
+/* Returns: a % b */
+
+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/runtime/test/Unit/modti3_test.c b/runtime/test/Unit/modti3_test.c
new file mode 100644
index 0000000..3cbccbe
--- /dev/null
+++ b/runtime/test/Unit/modti3_test.c
@@ -0,0 +1,93 @@
+//===-- modti3_test.c - Test __modti3 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __modti3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#if __x86_64
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns: a % b
+
+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()
+{
+#if __x86_64
+    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;
+
+#endif
+    return 0;
+}
diff --git a/runtime/test/Unit/muldc3_test.c b/runtime/test/Unit/muldc3_test.c
new file mode 100644
index 0000000..1d7fe42
--- /dev/null
+++ b/runtime/test/Unit/muldc3_test.c
@@ -0,0 +1,366 @@
+//===-- muldc3_test.c - Test __muldc3 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+
+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/runtime/test/Unit/muldf3vfp_test.c b/runtime/test/Unit/muldf3vfp_test.c
new file mode 100644
index 0000000..a99d8e9
--- /dev/null
+++ b/runtime/test/Unit/muldf3vfp_test.c
@@ -0,0 +1,48 @@
+//===-- muldf3vfp_test.c - Test __muldf3vfp -------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __muldf3vfp for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+
+#if __arm__
+extern 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;
+#endif
+    return 0;
+}
diff --git a/runtime/test/Unit/muldi3_test.c b/runtime/test/Unit/muldi3_test.c
new file mode 100644
index 0000000..915befa
--- /dev/null
+++ b/runtime/test/Unit/muldi3_test.c
@@ -0,0 +1,110 @@
+//===-- muldi3_test.c - Test __muldi3 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __muldi3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+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/runtime/test/Unit/mulsc3_test.c b/runtime/test/Unit/mulsc3_test.c
new file mode 100644
index 0000000..fa817a6
--- /dev/null
+++ b/runtime/test/Unit/mulsc3_test.c
@@ -0,0 +1,370 @@
+//===-- mulsc3_test.c - Test __mulsc3 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+
+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/runtime/test/Unit/mulsf3vfp_test.c b/runtime/test/Unit/mulsf3vfp_test.c
new file mode 100644
index 0000000..f706c47
--- /dev/null
+++ b/runtime/test/Unit/mulsf3vfp_test.c
@@ -0,0 +1,48 @@
+//===-- mulsf3vfp_test.c - Test __mulsf3vfp -------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __mulsf3vfp for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+
+extern 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;
+#endif
+    return 0;
+}
diff --git a/runtime/test/Unit/multc3_test.c b/runtime/test/Unit/multc3_test.c
new file mode 100644
index 0000000..72adb93
--- /dev/null
+++ b/runtime/test/Unit/multc3_test.c
@@ -0,0 +1,373 @@
+//===-- multc3_test.c - Test __multc3 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __multc3 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
+
+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
+    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;
+        }
+    }
+
+#endif
+    return 0;
+}
diff --git a/runtime/test/Unit/multi3_test.c b/runtime/test/Unit/multi3_test.c
new file mode 100644
index 0000000..4fa2796
--- /dev/null
+++ b/runtime/test/Unit/multi3_test.c
@@ -0,0 +1,132 @@
+//===-- multi3_test.c - Test __multi3 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __multi3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#if __x86_64
+
+#include "int_lib.h"
+#include <stdio.h>
+
+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()
+{
+#if __x86_64
+    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;
+#endif
+    return 0;
+}
diff --git a/runtime/test/Unit/mulvdi3_test.c b/runtime/test/Unit/mulvdi3_test.c
new file mode 100644
index 0000000..1c73e64
--- /dev/null
+++ b/runtime/test/Unit/mulvdi3_test.c
@@ -0,0 +1,175 @@
+//===-- mulvdi3_test.c - Test __mulvdi3 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+
+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/runtime/test/Unit/mulvsi3_test.c b/runtime/test/Unit/mulvsi3_test.c
new file mode 100644
index 0000000..c9e239a
--- /dev/null
+++ b/runtime/test/Unit/mulvsi3_test.c
@@ -0,0 +1,148 @@
+//===-- mulvsi3_test.c - Test __mulvsi3 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+
+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/runtime/test/Unit/mulvti3_test.c b/runtime/test/Unit/mulvti3_test.c
new file mode 100644
index 0000000..509b267
--- /dev/null
+++ b/runtime/test/Unit/mulvti3_test.c
@@ -0,0 +1,258 @@
+//===-- mulvti3_test.c - Test __mulvti3 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __mulvti3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#if __x86_64
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns: a * b
+
+// Effects: aborts if a * b overflows
+
+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()
+{
+#if __x86_64
+    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;
+
+#endif
+    return 0;
+}
diff --git a/runtime/test/Unit/mulxc3_test.c b/runtime/test/Unit/mulxc3_test.c
new file mode 100644
index 0000000..0390d34
--- /dev/null
+++ b/runtime/test/Unit/mulxc3_test.c
@@ -0,0 +1,373 @@
+//===-- mulxc3_test.c - Test __mulxc3 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+
+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;
+        }
+    }
+
+#endif
+    return 0;
+}
diff --git a/runtime/test/Unit/nedf2vfp_test.c b/runtime/test/Unit/nedf2vfp_test.c
new file mode 100644
index 0000000..f2983fc
--- /dev/null
+++ b/runtime/test/Unit/nedf2vfp_test.c
@@ -0,0 +1,49 @@
+//===-- nedf2vfp_test.c - Test __nedf2vfp ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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;
+#endif
+    return 0;
+}
diff --git a/runtime/test/Unit/negdf2vfp_test.c b/runtime/test/Unit/negdf2vfp_test.c
new file mode 100644
index 0000000..d019bd3
--- /dev/null
+++ b/runtime/test/Unit/negdf2vfp_test.c
@@ -0,0 +1,46 @@
+//===-- negdf2vfp_test.c - Test __negdf2vfp -------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __negdf2vfp for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+
+extern 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;
+#endif
+    return 0;
+}
diff --git a/runtime/test/Unit/negdi2_test.c b/runtime/test/Unit/negdi2_test.c
new file mode 100644
index 0000000..4de9ab6
--- /dev/null
+++ b/runtime/test/Unit/negdi2_test.c
@@ -0,0 +1,84 @@
+//===-- negdi2_test.c - Test __negdi2 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __negdi2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns: -a
+
+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/runtime/test/Unit/negsf2vfp_test.c b/runtime/test/Unit/negsf2vfp_test.c
new file mode 100644
index 0000000..0c75fdf
--- /dev/null
+++ b/runtime/test/Unit/negsf2vfp_test.c
@@ -0,0 +1,46 @@
+//===-- negsf2vfp_test.c - Test __negsf2vfp -------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __negsf2vfp for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+
+extern 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;
+#endif
+    return 0;
+}
diff --git a/runtime/test/Unit/negti2_test.c b/runtime/test/Unit/negti2_test.c
new file mode 100644
index 0000000..13c28e6
--- /dev/null
+++ b/runtime/test/Unit/negti2_test.c
@@ -0,0 +1,125 @@
+//===-- negti2_test.c - Test __negti2 -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __negti2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#if __x86_64
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns: -a
+
+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()
+{
+#if __x86_64
+    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;
+
+#endif
+   return 0;
+}
diff --git a/runtime/test/Unit/negvdi2_test.c b/runtime/test/Unit/negvdi2_test.c
new file mode 100644
index 0000000..7fef4d9
--- /dev/null
+++ b/runtime/test/Unit/negvdi2_test.c
@@ -0,0 +1,57 @@
+//===-- negvdi2_test.c - Test __negvdi2 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+
+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/runtime/test/Unit/negvsi2_test.c b/runtime/test/Unit/negvsi2_test.c
new file mode 100644
index 0000000..0480528
--- /dev/null
+++ b/runtime/test/Unit/negvsi2_test.c
@@ -0,0 +1,56 @@
+//===-- negvsi2_test.c - Test __negvsi2 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+
+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/runtime/test/Unit/negvti2_test.c b/runtime/test/Unit/negvti2_test.c
new file mode 100644
index 0000000..7772c08
--- /dev/null
+++ b/runtime/test/Unit/negvti2_test.c
@@ -0,0 +1,107 @@
+//===-- negvti2_test.c - Test __negvti2 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __negvti2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#if __x86_64
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns: -a
+
+// Effects: aborts if -a overflows
+
+ti_int __negvti2(ti_int a);
+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()
+{
+#if __x86_64
+    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;
+
+#endif
+   return 0;
+}
diff --git a/runtime/test/Unit/nesf2vfp_test.c b/runtime/test/Unit/nesf2vfp_test.c
new file mode 100644
index 0000000..dcbc483
--- /dev/null
+++ b/runtime/test/Unit/nesf2vfp_test.c
@@ -0,0 +1,49 @@
+//===-- nesf2vfp_test.c - Test __nesf2vfp ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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;
+#endif
+    return 0;
+}
diff --git a/runtime/test/Unit/paritydi2_test.c b/runtime/test/Unit/paritydi2_test.c
new file mode 100644
index 0000000..297de8f
--- /dev/null
+++ b/runtime/test/Unit/paritydi2_test.c
@@ -0,0 +1,51 @@
+//===-- paritydi2_test.c - Test __paritydi2 -------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+
+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/runtime/test/Unit/paritysi2_test.c b/runtime/test/Unit/paritysi2_test.c
new file mode 100644
index 0000000..f15f90e
--- /dev/null
+++ b/runtime/test/Unit/paritysi2_test.c
@@ -0,0 +1,50 @@
+//===-- paritysi2_test.c - Test __paritysi2 -------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+
+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/runtime/test/Unit/parityti2_test.c b/runtime/test/Unit/parityti2_test.c
new file mode 100644
index 0000000..6fe1cf6
--- /dev/null
+++ b/runtime/test/Unit/parityti2_test.c
@@ -0,0 +1,62 @@
+//===-- parityti2_test.c - Test __parityti2 -------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __parityti2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#if __x86_64
+
+#include "int_lib.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+// Returns: 1 if number of bits is odd else returns 0
+
+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()
+{
+#if __x86_64
+    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;
+
+#endif
+   return 0;
+}
diff --git a/runtime/test/Unit/popcountdi2_test.c b/runtime/test/Unit/popcountdi2_test.c
new file mode 100644
index 0000000..6d555ce
--- /dev/null
+++ b/runtime/test/Unit/popcountdi2_test.c
@@ -0,0 +1,63 @@
+//===-- popcountdi2_test.c - Test __popcountdi2 ----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+
+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/runtime/test/Unit/popcountsi2_test.c b/runtime/test/Unit/popcountsi2_test.c
new file mode 100644
index 0000000..3d91cde
--- /dev/null
+++ b/runtime/test/Unit/popcountsi2_test.c
@@ -0,0 +1,62 @@
+//===-- popcountsi2_test.c - Test __popcountsi2 ---------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+
+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/runtime/test/Unit/popcountti2_test.c b/runtime/test/Unit/popcountti2_test.c
new file mode 100644
index 0000000..917b5cb
--- /dev/null
+++ b/runtime/test/Unit/popcountti2_test.c
@@ -0,0 +1,80 @@
+//===-- popcountti2_test.c - Test __popcountti2 ----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __popcountti2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#if __x86_64
+
+#include "int_lib.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+// Returns: count of 1 bits
+
+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()
+{
+#if __x86_64
+    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;
+
+#endif
+   return 0;
+}
diff --git a/runtime/test/Unit/powidf2_test.c b/runtime/test/Unit/powidf2_test.c
new file mode 100644
index 0000000..48cb4bb
--- /dev/null
+++ b/runtime/test/Unit/powidf2_test.c
@@ -0,0 +1,224 @@
+//===-- powidf2_test.cpp - Test __powidf2 ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+
+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/runtime/test/Unit/powisf2_test.c b/runtime/test/Unit/powisf2_test.c
new file mode 100644
index 0000000..789bb37
--- /dev/null
+++ b/runtime/test/Unit/powisf2_test.c
@@ -0,0 +1,224 @@
+//===-- powisf2_test.cpp - Test __powisf2 ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+
+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/runtime/test/Unit/powitf2_test.c b/runtime/test/Unit/powitf2_test.c
new file mode 100644
index 0000000..4258ce2
--- /dev/null
+++ b/runtime/test/Unit/powitf2_test.c
@@ -0,0 +1,230 @@
+//===-- powitf2_test.cpp - Test __powitf2 ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __powitf2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#if _ARCH_PPC
+
+#include "int_lib.h"
+#include <stdio.h>
+#include <math.h>
+
+// Returns: a ^ b
+
+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;
+
+#endif
+    return 0;
+}
diff --git a/runtime/test/Unit/powixf2_test.c b/runtime/test/Unit/powixf2_test.c
new file mode 100644
index 0000000..74403aa
--- /dev/null
+++ b/runtime/test/Unit/powixf2_test.c
@@ -0,0 +1,230 @@
+//===-- powixf2_test.cpp - Test __powixf2 ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+
+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;
+
+#endif
+    return 0;
+}
diff --git a/runtime/test/Unit/ppc/CMakeLists.txt b/runtime/test/Unit/ppc/CMakeLists.txt
new file mode 100644
index 0000000..45f1a26
--- /dev/null
+++ b/runtime/test/Unit/ppc/CMakeLists.txt
@@ -0,0 +1,9 @@
+SET( SRCS
+ floatditf_test.c
+ fixtfdi_test.c
+ qsub_test.c
+ qadd_test.c
+ qmul_test.c
+ qdiv_test.c
+ floatunditf_test.c
+ )
diff --git a/runtime/test/Unit/ppc/DD.h b/runtime/test/Unit/ppc/DD.h
new file mode 100644
index 0000000..fd62dae
--- /dev/null
+++ b/runtime/test/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/runtime/test/Unit/ppc/fixtfdi_test.c b/runtime/test/Unit/ppc/fixtfdi_test.c
new file mode 100644
index 0000000..b4865fb
--- /dev/null
+++ b/runtime/test/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/runtime/test/Unit/ppc/floatditf_test.c b/runtime/test/Unit/ppc/floatditf_test.c
new file mode 100644
index 0000000..578260a
--- /dev/null
+++ b/runtime/test/Unit/ppc/floatditf_test.c
@@ -0,0 +1,30 @@
+#include <stdint.h>
+#include <stdio.h>
+
+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/runtime/test/Unit/ppc/floatditf_test.h b/runtime/test/Unit/ppc/floatditf_test.h
new file mode 100644
index 0000000..8b47e17
--- /dev/null
+++ b/runtime/test/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/runtime/test/Unit/ppc/floatunditf_test.c b/runtime/test/Unit/ppc/floatunditf_test.c
new file mode 100644
index 0000000..68390d1
--- /dev/null
+++ b/runtime/test/Unit/ppc/floatunditf_test.c
@@ -0,0 +1,30 @@
+#include <stdint.h>
+#include <stdio.h>
+
+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/runtime/test/Unit/ppc/floatunditf_test.h b/runtime/test/Unit/ppc/floatunditf_test.h
new file mode 100644
index 0000000..4a42e97
--- /dev/null
+++ b/runtime/test/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/runtime/test/Unit/ppc/qadd_test.c b/runtime/test/Unit/ppc/qadd_test.c
new file mode 100644
index 0000000..6d4ca93
--- /dev/null
+++ b/runtime/test/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/runtime/test/Unit/ppc/qdiv_test.c b/runtime/test/Unit/ppc/qdiv_test.c
new file mode 100644
index 0000000..8e4e75a
--- /dev/null
+++ b/runtime/test/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/runtime/test/Unit/ppc/qmul_test.c b/runtime/test/Unit/ppc/qmul_test.c
new file mode 100644
index 0000000..fc5b46d
--- /dev/null
+++ b/runtime/test/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/runtime/test/Unit/ppc/qsub_test.c b/runtime/test/Unit/ppc/qsub_test.c
new file mode 100644
index 0000000..43bc7f4
--- /dev/null
+++ b/runtime/test/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/runtime/test/Unit/ppc/test b/runtime/test/Unit/ppc/test
new file mode 100755
index 0000000..96e0632
--- /dev/null
+++ b/runtime/test/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/runtime/test/Unit/subdf3vfp_test.c b/runtime/test/Unit/subdf3vfp_test.c
new file mode 100644
index 0000000..ee5a492
--- /dev/null
+++ b/runtime/test/Unit/subdf3vfp_test.c
@@ -0,0 +1,46 @@
+//===-- subdf3vfp_test.c - Test __subdf3vfp -------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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 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;
+#endif
+    return 0;
+}
diff --git a/runtime/test/Unit/subsf3vfp_test.c b/runtime/test/Unit/subsf3vfp_test.c
new file mode 100644
index 0000000..f6853e3
--- /dev/null
+++ b/runtime/test/Unit/subsf3vfp_test.c
@@ -0,0 +1,46 @@
+//===-- subsf3vfp_test.c - Test __subsf3vfp -------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __subsf3vfp for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+
+extern 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;
+#endif
+    return 0;
+}
diff --git a/runtime/test/Unit/subvdi3_test.c b/runtime/test/Unit/subvdi3_test.c
new file mode 100644
index 0000000..8af7928
--- /dev/null
+++ b/runtime/test/Unit/subvdi3_test.c
@@ -0,0 +1,60 @@
+//===-- subvdi3_test.c - Test __subvdi3 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+
+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/runtime/test/Unit/subvsi3_test.c b/runtime/test/Unit/subvsi3_test.c
new file mode 100644
index 0000000..c37b4b2
--- /dev/null
+++ b/runtime/test/Unit/subvsi3_test.c
@@ -0,0 +1,60 @@
+//===-- subvsi3_test.c - Test __subvsi3 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+
+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/runtime/test/Unit/subvti3_test.c b/runtime/test/Unit/subvti3_test.c
new file mode 100644
index 0000000..11d8175
--- /dev/null
+++ b/runtime/test/Unit/subvti3_test.c
@@ -0,0 +1,78 @@
+//===-- subvti3_test.c - Test __subvti3 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __subvti3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#if __x86_64
+
+#include "int_lib.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+// Returns: a - b
+
+// Effects: aborts if a - b overflows
+
+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()
+{
+#if __x86_64
+//     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;
+
+#endif
+    return 0;
+}
diff --git a/runtime/test/Unit/test b/runtime/test/Unit/test
new file mode 100755
index 0000000..e2a39a9
--- /dev/null
+++ b/runtime/test/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/runtime/test/Unit/trampoline_setup_test.c b/runtime/test/Unit/trampoline_setup_test.c
new file mode 100644
index 0000000..8d1c968
--- /dev/null
+++ b/runtime/test/Unit/trampoline_setup_test.c
@@ -0,0 +1,63 @@
+/* ===-- trampoline_setup_test.c - Test __trampoline_setup -----------------===
+ *
+ *                     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 <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() {
+  return 0;
+}
+
+#endif
diff --git a/runtime/test/Unit/truncdfsf2vfp_test.c b/runtime/test/Unit/truncdfsf2vfp_test.c
new file mode 100644
index 0000000..f02b836
--- /dev/null
+++ b/runtime/test/Unit/truncdfsf2vfp_test.c
@@ -0,0 +1,48 @@
+//===-- truncdfsf2vfp_test.c - Test __truncdfsf2vfp -----------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __truncdfsf2vfp for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+
+extern 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;
+#endif
+    return 0;
+}
diff --git a/runtime/test/Unit/ucmpdi2_test.c b/runtime/test/Unit/ucmpdi2_test.c
new file mode 100644
index 0000000..eab9589
--- /dev/null
+++ b/runtime/test/Unit/ucmpdi2_test.c
@@ -0,0 +1,75 @@
+//===-- ucmpdi2_test.c - Test __ucmpdi2 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+
+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/runtime/test/Unit/ucmpti2_test.c b/runtime/test/Unit/ucmpti2_test.c
new file mode 100644
index 0000000..cb6b4b7
--- /dev/null
+++ b/runtime/test/Unit/ucmpti2_test.c
@@ -0,0 +1,114 @@
+//===-- ucmpti2_test.c - Test __ucmpti2 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __ucmpti2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#if __x86_64
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns:  if (a <  b) returns 0
+//           if (a == b) returns 1
+//           if (a >  b) returns 2
+
+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()
+{
+#if __x86_64
+    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;
+#endif
+   return 0;
+}
diff --git a/runtime/test/Unit/udivdi3_test.c b/runtime/test/Unit/udivdi3_test.c
new file mode 100644
index 0000000..115453b
--- /dev/null
+++ b/runtime/test/Unit/udivdi3_test.c
@@ -0,0 +1,44 @@
+//===-- udivdi3_test.c - Test __udivdi3 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __udivdi3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns: a / b
+
+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/runtime/test/Unit/udivmoddi4_test.c b/runtime/test/Unit/udivmoddi4_test.c
new file mode 100644
index 0000000..3ac4809
--- /dev/null
+++ b/runtime/test/Unit/udivmoddi4_test.c
@@ -0,0 +1,20639 @@
+//===-- udivmoddi4_test.c - Test __udivmoddi4 -----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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
+
+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/runtime/test/Unit/udivmodti4_test.c b/runtime/test/Unit/udivmodti4_test.c
new file mode 100644
index 0000000..d16002c
--- /dev/null
+++ b/runtime/test/Unit/udivmodti4_test.c
@@ -0,0 +1,65351 @@
+//===-- udivmodti4_test.c - Test __udivmodti4 -----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __udivmodti4 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#if __x86_64
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Effects: if rem != 0, *rem = a % b
+// Returns: a / b
+
+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()
+{
+#if __x86_64
+    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;
+
+#endif
+    return 0;
+}
diff --git a/runtime/test/Unit/udivsi3_test.c b/runtime/test/Unit/udivsi3_test.c
new file mode 100644
index 0000000..0fdf714
--- /dev/null
+++ b/runtime/test/Unit/udivsi3_test.c
@@ -0,0 +1,175 @@
+//===-- udivsi3_test.c - Test __udivsi3 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __udivsi3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns: a / b
+
+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/runtime/test/Unit/udivti3_test.c b/runtime/test/Unit/udivti3_test.c
new file mode 100644
index 0000000..3b7846e
--- /dev/null
+++ b/runtime/test/Unit/udivti3_test.c
@@ -0,0 +1,65 @@
+//===-- udivti3_test.c - Test __udivti3 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __udivti3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#if __x86_64
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns: a / b
+
+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()
+{
+#if __x86_64
+    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;
+
+#endif
+    return 0;
+}
diff --git a/runtime/test/Unit/umoddi3_test.c b/runtime/test/Unit/umoddi3_test.c
new file mode 100644
index 0000000..3ffa0be
--- /dev/null
+++ b/runtime/test/Unit/umoddi3_test.c
@@ -0,0 +1,44 @@
+//===-- umoddi3_test.c - Test __umoddi3 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __umoddi3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns: a % b
+
+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/runtime/test/Unit/umodsi3_test.c b/runtime/test/Unit/umodsi3_test.c
new file mode 100644
index 0000000..89c7c23
--- /dev/null
+++ b/runtime/test/Unit/umodsi3_test.c
@@ -0,0 +1,175 @@
+//===-- umodsi3_test.c - Test __umodsi3 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __umodsi3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns: a % b
+
+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/runtime/test/Unit/umodti3_test.c b/runtime/test/Unit/umodti3_test.c
new file mode 100644
index 0000000..3f6696a
--- /dev/null
+++ b/runtime/test/Unit/umodti3_test.c
@@ -0,0 +1,63 @@
+//===-- umodti3_test.c - Test __umodti3 -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __umodti3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#if __x86_64
+
+#include "int_lib.h"
+#include <stdio.h>
+
+// Returns: a % b
+
+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()
+{
+#if __x86_64
+    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;
+
+#endif
+    return 0;
+}
diff --git a/runtime/test/Unit/unorddf2vfp_test.c b/runtime/test/Unit/unorddf2vfp_test.c
new file mode 100644
index 0000000..a08c06c
--- /dev/null
+++ b/runtime/test/Unit/unorddf2vfp_test.c
@@ -0,0 +1,47 @@
+//===-- unorddf2vfp_test.c - Test __unorddf2vfp ---------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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;
+#endif
+    return 0;
+}
diff --git a/runtime/test/Unit/unordsf2vfp_test.c b/runtime/test/Unit/unordsf2vfp_test.c
new file mode 100644
index 0000000..cf51396
--- /dev/null
+++ b/runtime/test/Unit/unordsf2vfp_test.c
@@ -0,0 +1,47 @@
+//===-- unordsf2vfp_test.c - Test __unordsf2vfp ---------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. 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;
+#endif
+    return 0;
+}
diff --git a/runtime/test/timing/CMakeLists.txt b/runtime/test/timing/CMakeLists.txt
new file mode 100644
index 0000000..abc7d8f
--- /dev/null
+++ b/runtime/test/timing/CMakeLists.txt
@@ -0,0 +1,17 @@
+
+# create tests
+MACRO_ADD_CHECK_TEST( lshrdi3 lshrdi3.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( floatundixf floatundixf.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( floatdixf floatdixf.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( umoddi3 umoddi3.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( udivdi3 udivdi3.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( negdi2 negdi2.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( ashrdi3 ashrdi3.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( muldi3 muldi3.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( ashldi3 ashldi3.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( divdi3 divdi3.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( floatundisf floatundisf.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( floatdidf floatdidf.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( floatdisf floatdisf.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( moddi3 moddi3.c ${TEST_TARGET_LIBRARIES} )
+MACRO_ADD_CHECK_TEST( floatundidf floatundidf.c ${TEST_TARGET_LIBRARIES} )
diff --git a/runtime/test/timing/ashldi3.c b/runtime/test/timing/ashldi3.c
new file mode 100644
index 0000000..0d7378d
--- /dev/null
+++ b/runtime/test/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/runtime/test/timing/ashrdi3.c b/runtime/test/timing/ashrdi3.c
new file mode 100644
index 0000000..84e11f7
--- /dev/null
+++ b/runtime/test/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/runtime/test/timing/divdi3.c b/runtime/test/timing/divdi3.c
new file mode 100644
index 0000000..37937aa
--- /dev/null
+++ b/runtime/test/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/runtime/test/timing/floatdidf.c b/runtime/test/timing/floatdidf.c
new file mode 100644
index 0000000..2c970d4
--- /dev/null
+++ b/runtime/test/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/runtime/test/timing/floatdisf.c b/runtime/test/timing/floatdisf.c
new file mode 100644
index 0000000..801ab0a
--- /dev/null
+++ b/runtime/test/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/runtime/test/timing/floatdixf.c b/runtime/test/timing/floatdixf.c
new file mode 100644
index 0000000..b646e3c
--- /dev/null
+++ b/runtime/test/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/runtime/test/timing/floatundidf.c b/runtime/test/timing/floatundidf.c
new file mode 100644
index 0000000..25c02bd
--- /dev/null
+++ b/runtime/test/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/runtime/test/timing/floatundisf.c b/runtime/test/timing/floatundisf.c
new file mode 100644
index 0000000..ec8f3be
--- /dev/null
+++ b/runtime/test/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/runtime/test/timing/floatundixf.c b/runtime/test/timing/floatundixf.c
new file mode 100644
index 0000000..46733eb
--- /dev/null
+++ b/runtime/test/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/runtime/test/timing/lshrdi3.c b/runtime/test/timing/lshrdi3.c
new file mode 100644
index 0000000..b474cf3
--- /dev/null
+++ b/runtime/test/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/runtime/test/timing/moddi3.c b/runtime/test/timing/moddi3.c
new file mode 100644
index 0000000..83e2441
--- /dev/null
+++ b/runtime/test/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/runtime/test/timing/muldi3.c b/runtime/test/timing/muldi3.c
new file mode 100644
index 0000000..3ba3af2
--- /dev/null
+++ b/runtime/test/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/runtime/test/timing/negdi2.c b/runtime/test/timing/negdi2.c
new file mode 100644
index 0000000..2668eb1
--- /dev/null
+++ b/runtime/test/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/runtime/test/timing/time b/runtime/test/timing/time
new file mode 100755
index 0000000..35da97d
--- /dev/null
+++ b/runtime/test/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/runtime/test/timing/timing.h b/runtime/test/timing/timing.h
new file mode 100644
index 0000000..bb6c41e
--- /dev/null
+++ b/runtime/test/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/runtime/test/timing/udivdi3.c b/runtime/test/timing/udivdi3.c
new file mode 100644
index 0000000..9c6a7e8
--- /dev/null
+++ b/runtime/test/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/runtime/test/timing/umoddi3.c b/runtime/test/timing/umoddi3.c
new file mode 100644
index 0000000..a81c46e
--- /dev/null
+++ b/runtime/test/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/runtime/www/content.css b/runtime/www/content.css
new file mode 100644
index 0000000..ab6983b
--- /dev/null
+++ b/runtime/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/runtime/www/index.html b/runtime/www/index.html
new file mode 100644
index 0000000..ec62b6d
--- /dev/null
+++ b/runtime/www/index.html
@@ -0,0 +1,148 @@
+<!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 Library</h1>
+  <!--*********************************************************************-->
+  
+  <p>The compiler-rt project is 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 compiler-rt library provides
+    optimized implementations of this and other low-level routines.</p>
+
+  <p>All of the code in the compiler-rt project is available under the standard
+     <a href="http://llvm.org/docs/DeveloperPolicy.html#license">LLVM
+     License</a>, a "BSD-style" license.</p>
+  
+  <!--=====================================================================-->
+  <h2 id="goals">Goals</h2>
+  <!--=====================================================================-->
+  
+  <p>Different targets require different routines.  The compiler-rt project aims
+     to implement these routines in both target-independent C form as well as
+     providing heavily optimized assembly versions of the routines in some
+     cases.  It should be very easy to bring compiler-rt to support a new
+     target by adding the new routines needed by that target.</p>
+     
+  <p>Where it make sense, the compiler-rt project aims to implement interfaces
+     that are drop-in compatible with the libgcc interfaces.</p>
+
+  <!--=====================================================================-->
+  <h2 id="features">Features</h2>
+  <!--=====================================================================-->
+
+   <p>The current feature set of compiler-rt is:</p>
+
+   <ul>
+    <li>Full support for the libgcc interfaces on supported targets.</li>
+    <li>High performance hand tuned implementations of commonly used functions
+        like __floatundidf in assembly that are dramatically faster than the
+        libgcc implementations.</li>
+    <li>A target-independent implementation of the Apple "Blocks" runtime
+        interfaces.</li>
+   </ul>
+
+  <!--=====================================================================-->
+  <h2 id="requirements">Platform Support</h2>
+  <!--=====================================================================-->
+
+   <p>Compiler-RT is known to work on the following platforms:</p>
+
+   <li>Machine Architectures:
+    <ul>
+     <li>i386</li>
+     <li>X86-64</li>
+     <li>SPARC64</li>
+     <li>ARM</li>
+     <li>PowerPC</li>
+     <li>PowerPC 64</li>
+    </ul></li>
+
+   <table cellpadding="3" summary="Known Compiler-RT platforms">
+   <tr>
+     <th>OS</th>
+     <th>Arch</th>
+   </tr>
+   <tr>
+     <td>AuroraUX</td>
+     <td>All<sup>
+   </tr>
+   <tr>
+     <td>DragonFlyBSD</td>
+     <td>All<sup>
+   </tr>
+   <tr>
+     <td>FreeBSD</td>
+     <td>All<sup>
+   </tr>
+   <tr>
+     <td>NetBSD</td>
+     <td>All<sup>
+   </tr>
+   <tr>
+     <td>Linux</td>
+     <td>All<sup>
+   </tr>
+   <tr>
+     <td>Darwin</td>
+     <td>All<sup>
+   </tr>
+   </table>
+
+  <!--=====================================================================-->
+  <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> lib/ Is a generic portable implementations.</li>
+    <li> lib/(arch) has optimized version for the supported architectures.</li>
+   </ul>
+    
+  <!--=====================================================================-->
+  <h2>Get it and get involved!</h2>
+  <!--=====================================================================-->
+  
+  <p>To check out the code, use:</p>
+  
+  <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</li>
+  <li>make</li>
+  <li>To run the Compiler-RT Test Suit (recommended):</li>
+  <li>ctest</li>
+  <li>To Install:</li>
+  <li>make install</li>
+  </ul>
+  
+  <p>compiler-rt doesn't have its own mailing list, if you have questions please
+     email the <a
+    href="http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev">llvmdev</a> mailing
+    list.  Commits to the compiler-rt SVN module are automatically sent to the
+    <a 
+  href="http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits">llvm-commits</a>
+    mailing list.</p>
+</div>
+</body>
+</html>
diff --git a/runtime/www/menu.css b/runtime/www/menu.css
new file mode 100644
index 0000000..6e96a45
--- /dev/null
+++ b/runtime/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/runtime/www/menu.html.incl b/runtime/www/menu.html.incl
new file mode 100644
index 0000000..cc0af56
--- /dev/null
+++ b/runtime/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.cs.uiuc.edu/mailman/listinfo/llvmdev">llvmdev</a>
+    <a href="http://lists.cs.uiuc.edu/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>
diff --git a/tests/Android.mk b/tests/Android.mk
new file mode 100644
index 0000000..5463979
--- /dev/null
+++ b/tests/Android.mk
@@ -0,0 +1,40 @@
+LOCAL_PATH := $(call my-dir)
+
+# Executable for host
+# ========================================================
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := bcc
+
+LOCAL_SRC_FILES:= \
+	main.cpp
+
+LOCAL_SHARED_LIBRARIES := \
+    libbcc
+
+LOCAL_C_INCLUDES :=	\
+	$(LOCAL_PATH)/../include
+
+LOCAL_MODULE_TAGS := tests
+
+include $(BUILD_HOST_EXECUTABLE)
+
+# Executable for target
+# ========================================================
+include $(CLEAR_VARS)
+
+LOCAL_MODULE:= bcc
+
+LOCAL_SRC_FILES:= \
+	main.cpp \
+    disassem.cpp
+
+LOCAL_SHARED_LIBRARIES := \
+    libbcc
+
+LOCAL_C_INCLUDES :=	\
+	$(LOCAL_PATH)/../include
+
+LOCAL_MODULE_TAGS := tests
+
+include $(BUILD_EXECUTABLE)
diff --git a/tests/armreg.h b/tests/armreg.h
new file mode 100644
index 0000000..fde81ba
--- /dev/null
+++ b/tests/armreg.h
@@ -0,0 +1,300 @@
+/*	$NetBSD: armreg.h,v 1.28 2003/10/31 16:30:15 scw Exp $	*/
+
+/*-
+ * Copyright (c) 1998, 2001 Ben Harris
+ * Copyright (c) 1994-1996 Mark Brinicombe.
+ * Copyright (c) 1994 Brini.
+ * All rights reserved.
+ *
+ * This code is derived from software written for Brini by Mark Brinicombe
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. 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.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by Brini.
+ * 4. The name of the company nor the name of the author may be used to
+ *    endorse or promote products derived from this software without specific
+ *    prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY BRINI ``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 BRINI 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.
+ *
+ * $FreeBSD: /repoman/r/ncvs/src/sys/arm/include/armreg.h,v 1.3 2005/11/21 19:06:25 cognet Exp $
+ */
+
+#ifndef MACHINE_ARMREG_H
+#define MACHINE_ARMREG_H
+#define INSN_SIZE	4
+#define INSN_COND_MASK	0xf0000000	/* Condition mask */
+#define PSR_MODE        0x0000001f      /* mode mask */
+#define PSR_USR26_MODE  0x00000000
+#define PSR_FIQ26_MODE  0x00000001
+#define PSR_IRQ26_MODE  0x00000002
+#define PSR_SVC26_MODE  0x00000003
+#define PSR_USR32_MODE  0x00000010
+#define PSR_FIQ32_MODE  0x00000011
+#define PSR_IRQ32_MODE  0x00000012
+#define PSR_SVC32_MODE  0x00000013
+#define PSR_ABT32_MODE  0x00000017
+#define PSR_UND32_MODE  0x0000001b
+#define PSR_SYS32_MODE  0x0000001f
+#define PSR_32_MODE     0x00000010
+#define PSR_FLAGS	0xf0000000    /* flags */
+
+#define PSR_C_bit (1 << 29)       /* carry */
+
+/* The high-order byte is always the implementor */
+#define CPU_ID_IMPLEMENTOR_MASK	0xff000000
+#define CPU_ID_ARM_LTD		0x41000000 /* 'A' */
+#define CPU_ID_DEC		0x44000000 /* 'D' */
+#define CPU_ID_INTEL		0x69000000 /* 'i' */
+#define	CPU_ID_TI		0x54000000 /* 'T' */
+
+/* How to decide what format the CPUID is in. */
+#define CPU_ID_ISOLD(x)		(((x) & 0x0000f000) == 0x00000000)
+#define CPU_ID_IS7(x)		(((x) & 0x0000f000) == 0x00007000)
+#define CPU_ID_ISNEW(x)		(!CPU_ID_ISOLD(x) && !CPU_ID_IS7(x))
+
+/* On ARM3 and ARM6, this byte holds the foundry ID. */
+#define CPU_ID_FOUNDRY_MASK	0x00ff0000
+#define CPU_ID_FOUNDRY_VLSI	0x00560000
+
+/* On ARM7 it holds the architecture and variant (sub-model) */
+#define CPU_ID_7ARCH_MASK	0x00800000
+#define CPU_ID_7ARCH_V3		0x00000000
+#define CPU_ID_7ARCH_V4T	0x00800000
+#define CPU_ID_7VARIANT_MASK	0x007f0000
+
+/* On more recent ARMs, it does the same, but in a different format */
+#define CPU_ID_ARCH_MASK	0x000f0000
+#define CPU_ID_ARCH_V3		0x00000000
+#define CPU_ID_ARCH_V4		0x00010000
+#define CPU_ID_ARCH_V4T		0x00020000
+#define CPU_ID_ARCH_V5		0x00030000
+#define CPU_ID_ARCH_V5T		0x00040000
+#define CPU_ID_ARCH_V5TE	0x00050000
+#define CPU_ID_VARIANT_MASK	0x00f00000
+
+/* Next three nybbles are part number */
+#define CPU_ID_PARTNO_MASK	0x0000fff0
+
+/* Intel XScale has sub fields in part number */
+#define CPU_ID_XSCALE_COREGEN_MASK	0x0000e000 /* core generation */
+#define CPU_ID_XSCALE_COREREV_MASK	0x00001c00 /* core revision */
+#define CPU_ID_XSCALE_PRODUCT_MASK	0x000003f0 /* product number */
+
+/* And finally, the revision number. */
+#define CPU_ID_REVISION_MASK	0x0000000f
+
+/* Individual CPUs are probably best IDed by everything but the revision. */
+#define CPU_ID_CPU_MASK		0xfffffff0
+
+/* Fake CPU IDs for ARMs without CP15 */
+#define CPU_ID_ARM2		0x41560200
+#define CPU_ID_ARM250		0x41560250
+
+/* Pre-ARM7 CPUs -- [15:12] == 0 */
+#define CPU_ID_ARM3		0x41560300
+#define CPU_ID_ARM600		0x41560600
+#define CPU_ID_ARM610		0x41560610
+#define CPU_ID_ARM620		0x41560620
+
+/* ARM7 CPUs -- [15:12] == 7 */
+#define CPU_ID_ARM700		0x41007000 /* XXX This is a guess. */
+#define CPU_ID_ARM710		0x41007100
+#define CPU_ID_ARM7500		0x41027100 /* XXX This is a guess. */
+#define CPU_ID_ARM710A		0x41047100 /* inc ARM7100 */
+#define CPU_ID_ARM7500FE	0x41077100
+#define CPU_ID_ARM710T		0x41807100
+#define CPU_ID_ARM720T		0x41807200
+#define CPU_ID_ARM740T8K	0x41807400 /* XXX no MMU, 8KB cache */
+#define CPU_ID_ARM740T4K	0x41817400 /* XXX no MMU, 4KB cache */
+
+/* Post-ARM7 CPUs */
+#define CPU_ID_ARM810		0x41018100
+#define CPU_ID_ARM920T		0x41129200
+#define CPU_ID_ARM920T_ALT	0x41009200
+#define CPU_ID_ARM922T		0x41029220
+#define CPU_ID_ARM940T		0x41029400 /* XXX no MMU */
+#define CPU_ID_ARM946ES		0x41049460 /* XXX no MMU */
+#define	CPU_ID_ARM966ES		0x41049660 /* XXX no MMU */
+#define	CPU_ID_ARM966ESR1	0x41059660 /* XXX no MMU */
+#define CPU_ID_ARM1020E		0x4115a200 /* (AKA arm10 rev 1) */
+#define CPU_ID_ARM1022ES	0x4105a220
+#define CPU_ID_SA110		0x4401a100
+#define CPU_ID_SA1100		0x4401a110
+#define	CPU_ID_TI925T		0x54029250
+#define CPU_ID_SA1110		0x6901b110
+#define CPU_ID_IXP1200		0x6901c120
+#define CPU_ID_80200		0x69052000
+#define CPU_ID_PXA250    	0x69052100 /* sans core revision */
+#define CPU_ID_PXA210    	0x69052120
+#define CPU_ID_PXA250A		0x69052100 /* 1st version Core */
+#define CPU_ID_PXA210A		0x69052120 /* 1st version Core */
+#define CPU_ID_PXA250B		0x69052900 /* 3rd version Core */
+#define CPU_ID_PXA210B		0x69052920 /* 3rd version Core */
+#define CPU_ID_PXA250C		0x69052d00 /* 4th version Core */
+#define CPU_ID_PXA210C		0x69052d20 /* 4th version Core */
+#define	CPU_ID_80321_400	0x69052420
+#define	CPU_ID_80321_600	0x69052430
+#define	CPU_ID_80321_400_B0	0x69052c20
+#define	CPU_ID_80321_600_B0	0x69052c30
+#define	CPU_ID_IXP425_533	0x690541c0
+#define	CPU_ID_IXP425_400	0x690541d0
+#define	CPU_ID_IXP425_266	0x690541f0
+
+/* ARM3-specific coprocessor 15 registers */
+#define ARM3_CP15_FLUSH		1
+#define ARM3_CP15_CONTROL	2
+#define ARM3_CP15_CACHEABLE	3
+#define ARM3_CP15_UPDATEABLE	4
+#define ARM3_CP15_DISRUPTIVE	5	
+
+/* ARM3 Control register bits */
+#define ARM3_CTL_CACHE_ON	0x00000001
+#define ARM3_CTL_SHARED		0x00000002
+#define ARM3_CTL_MONITOR	0x00000004
+
+/*
+ * Post-ARM3 CP15 registers:
+ *
+ *	1	Control register
+ *
+ *	2	Translation Table Base
+ *
+ *	3	Domain Access Control
+ *
+ *	4	Reserved
+ *
+ *	5	Fault Status
+ *
+ *	6	Fault Address
+ *
+ *	7	Cache/write-buffer Control
+ *
+ *	8	TLB Control
+ *
+ *	9	Cache Lockdown
+ *
+ *	10	TLB Lockdown
+ *
+ *	11	Reserved
+ *
+ *	12	Reserved
+ *
+ *	13	Process ID (for FCSE)
+ *
+ *	14	Reserved
+ *
+ *	15	Implementation Dependent
+ */
+
+/* Some of the definitions below need cleaning up for V3/V4 architectures */
+
+/* CPU control register (CP15 register 1) */
+#define CPU_CONTROL_MMU_ENABLE	0x00000001 /* M: MMU/Protection unit enable */
+#define CPU_CONTROL_AFLT_ENABLE	0x00000002 /* A: Alignment fault enable */
+#define CPU_CONTROL_DC_ENABLE	0x00000004 /* C: IDC/DC enable */
+#define CPU_CONTROL_WBUF_ENABLE 0x00000008 /* W: Write buffer enable */
+#define CPU_CONTROL_32BP_ENABLE 0x00000010 /* P: 32-bit exception handlers */
+#define CPU_CONTROL_32BD_ENABLE 0x00000020 /* D: 32-bit addressing */
+#define CPU_CONTROL_LABT_ENABLE 0x00000040 /* L: Late abort enable */
+#define CPU_CONTROL_BEND_ENABLE 0x00000080 /* B: Big-endian mode */
+#define CPU_CONTROL_SYST_ENABLE 0x00000100 /* S: System protection bit */
+#define CPU_CONTROL_ROM_ENABLE	0x00000200 /* R: ROM protection bit */
+#define CPU_CONTROL_CPCLK	0x00000400 /* F: Implementation defined */
+#define CPU_CONTROL_BPRD_ENABLE 0x00000800 /* Z: Branch prediction enable */
+#define CPU_CONTROL_IC_ENABLE   0x00001000 /* I: IC enable */
+#define CPU_CONTROL_VECRELOC	0x00002000 /* V: Vector relocation */
+#define CPU_CONTROL_ROUNDROBIN	0x00004000 /* RR: Predictable replacement */
+#define CPU_CONTROL_V4COMPAT	0x00008000 /* L4: ARMv4 compat LDR R15 etc */
+
+#define CPU_CONTROL_IDC_ENABLE	CPU_CONTROL_DC_ENABLE
+
+/* XScale Auxillary Control Register (CP15 register 1, opcode2 1) */
+#define	XSCALE_AUXCTL_K		0x00000001 /* dis. write buffer coalescing */
+#define	XSCALE_AUXCTL_P		0x00000002 /* ECC protect page table access */
+#define	XSCALE_AUXCTL_MD_WB_RA	0x00000000 /* mini-D$ wb, read-allocate */
+#define	XSCALE_AUXCTL_MD_WB_RWA	0x00000010 /* mini-D$ wb, read/write-allocate */
+#define	XSCALE_AUXCTL_MD_WT	0x00000020 /* mini-D$ wt, read-allocate */
+#define	XSCALE_AUXCTL_MD_MASK	0x00000030
+
+/* Cache type register definitions */
+#define	CPU_CT_ISIZE(x)		((x) & 0xfff)		/* I$ info */
+#define	CPU_CT_DSIZE(x)		(((x) >> 12) & 0xfff)	/* D$ info */
+#define	CPU_CT_S		(1U << 24)		/* split cache */
+#define	CPU_CT_CTYPE(x)		(((x) >> 25) & 0xf)	/* cache type */
+
+#define	CPU_CT_CTYPE_WT		0	/* write-through */
+#define	CPU_CT_CTYPE_WB1	1	/* write-back, clean w/ read */
+#define	CPU_CT_CTYPE_WB2	2	/* w/b, clean w/ cp15,7 */
+#define	CPU_CT_CTYPE_WB6	6	/* w/b, cp15,7, lockdown fmt A */
+#define	CPU_CT_CTYPE_WB7	7	/* w/b, cp15,7, lockdown fmt B */
+
+#define	CPU_CT_xSIZE_LEN(x)	((x) & 0x3)		/* line size */
+#define	CPU_CT_xSIZE_M		(1U << 2)		/* multiplier */
+#define	CPU_CT_xSIZE_ASSOC(x)	(((x) >> 3) & 0x7)	/* associativity */
+#define	CPU_CT_xSIZE_SIZE(x)	(((x) >> 6) & 0x7)	/* size */
+
+/* Fault status register definitions */
+
+#define FAULT_TYPE_MASK 0x0f
+#define FAULT_USER      0x10
+
+#define FAULT_WRTBUF_0  0x00 /* Vector Exception */
+#define FAULT_WRTBUF_1  0x02 /* Terminal Exception */
+#define FAULT_BUSERR_0  0x04 /* External Abort on Linefetch -- Section */
+#define FAULT_BUSERR_1  0x06 /* External Abort on Linefetch -- Page */
+#define FAULT_BUSERR_2  0x08 /* External Abort on Non-linefetch -- Section */
+#define FAULT_BUSERR_3  0x0a /* External Abort on Non-linefetch -- Page */
+#define FAULT_BUSTRNL1  0x0c /* External abort on Translation -- Level 1 */
+#define FAULT_BUSTRNL2  0x0e /* External abort on Translation -- Level 2 */
+#define FAULT_ALIGN_0   0x01 /* Alignment */
+#define FAULT_ALIGN_1   0x03 /* Alignment */
+#define FAULT_TRANS_S   0x05 /* Translation -- Section */
+#define FAULT_TRANS_P   0x07 /* Translation -- Page */
+#define FAULT_DOMAIN_S  0x09 /* Domain -- Section */
+#define FAULT_DOMAIN_P  0x0b /* Domain -- Page */
+#define FAULT_PERM_S    0x0d /* Permission -- Section */
+#define FAULT_PERM_P    0x0f /* Permission -- Page */
+
+#define	FAULT_IMPRECISE	0x400	/* Imprecise exception (XSCALE) */
+
+/*
+ * Address of the vector page, low and high versions.
+ */
+#define	ARM_VECTORS_LOW		0x00000000U
+#define	ARM_VECTORS_HIGH	0xffff0000U
+
+/*
+ * ARM Instructions
+ *
+ *       3 3 2 2 2                              
+ *       1 0 9 8 7                                                     0
+ *      +-------+-------------------------------------------------------+
+ *      | cond  |              instruction dependant                    |
+ *      |c c c c|                                                       |
+ *      +-------+-------------------------------------------------------+
+ */
+
+#define INSN_SIZE		4		/* Always 4 bytes */
+#define INSN_COND_MASK		0xf0000000	/* Condition mask */
+#define INSN_COND_AL		0xe0000000	/* Always condition */
+
+#endif /* !MACHINE_ARMREG_H */
diff --git a/tests/bccarm b/tests/bccarm
new file mode 100755
index 0000000..0914e10
--- /dev/null
+++ b/tests/bccarm
@@ -0,0 +1,69 @@
+#!/usr/bin/python
+#
+# Run a test on the ARM version of bcc.
+
+import unittest
+import subprocess
+import os
+import sys
+
+def compile(args):
+    proc = subprocess.Popen(["bcc"] + args, stderr=subprocess.PIPE, stdout=subprocess.PIPE)
+    result = proc.communicate()
+    return result
+
+def runCmd(args):
+    proc = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    result = proc.communicate()
+    return result[0].strip()
+
+def uname():
+    return runCmd(["uname"])
+
+def unameM():
+    return runCmd(["uname", "-m"])
+
+def which(item):
+    return runCmd(["which", item])
+
+def adb(args):
+    return runCmd(["adb"] + args)
+
+def setupArm(file):
+    print "Setting up arm"
+    adb(["remount"])
+    adb(["shell", "rm", "/system/bin/bcc"])
+    adb(["shell", "mkdir", "/system/bin/bccdata"])
+    adb(["shell", "mkdir", "/system/bin/bccdata/data"])
+
+    remoteFileName = os.path.join("/system/bin/bccdata", file)
+    adb(["push", file, remoteFileName])
+
+    # Copy over compiler
+    adb(["sync"])
+    return remoteFileName
+
+def compileArm(args):
+    remoteArgs = []
+    fileName = ""
+    for arg in sys.argv[1:]:
+        if arg.startswith('-'):
+            remoteArgs.append(arg)
+        else:
+            fileName = arg
+
+    remoteFileName = setupArm(fileName)
+    remoteArgs.append(remoteFileName)
+    remoteCmdLine = ["adb", "shell", "/system/bin/bcc"] + remoteArgs
+    proc = subprocess.Popen(remoteCmdLine, stdout=subprocess.PIPE)
+    result = proc.communicate()
+    return result[0].replace("\r","")
+
+
+def main():
+    print compileArm(sys.argv[1:])
+
+if __name__ == '__main__':
+    main()
+
+
diff --git a/tests/data/addressOf.bc b/tests/data/addressOf.bc
new file mode 100644
index 0000000..8b54383
--- /dev/null
+++ b/tests/data/addressOf.bc
Binary files differ
diff --git a/tests/data/array.bc b/tests/data/array.bc
new file mode 100644
index 0000000..0d389fc
--- /dev/null
+++ b/tests/data/array.bc
Binary files differ
diff --git a/tests/data/assignment.bc b/tests/data/assignment.bc
new file mode 100644
index 0000000..6cb36ea
--- /dev/null
+++ b/tests/data/assignment.bc
Binary files differ
diff --git a/tests/data/assignmentop.bc b/tests/data/assignmentop.bc
new file mode 100644
index 0000000..f4131f8
--- /dev/null
+++ b/tests/data/assignmentop.bc
Binary files differ
diff --git a/tests/data/b2071670.bc b/tests/data/b2071670.bc
new file mode 100644
index 0000000..e9b495e
--- /dev/null
+++ b/tests/data/b2071670.bc
Binary files differ
diff --git a/tests/data/brackets.bc b/tests/data/brackets.bc
new file mode 100644
index 0000000..da5fc92
--- /dev/null
+++ b/tests/data/brackets.bc
Binary files differ
diff --git a/tests/data/casts.bc b/tests/data/casts.bc
new file mode 100644
index 0000000..d21e54a
--- /dev/null
+++ b/tests/data/casts.bc
Binary files differ
diff --git a/tests/data/char.bc b/tests/data/char.bc
new file mode 100644
index 0000000..8ba6f9d
--- /dev/null
+++ b/tests/data/char.bc
Binary files differ
diff --git a/tests/data/comma.bc b/tests/data/comma.bc
new file mode 100644
index 0000000..0e159c1
--- /dev/null
+++ b/tests/data/comma.bc
Binary files differ
diff --git a/tests/data/constants.bc b/tests/data/constants.bc
new file mode 100644
index 0000000..c0699e1
--- /dev/null
+++ b/tests/data/constants.bc
Binary files differ
diff --git a/tests/data/defines.bc b/tests/data/defines.bc
new file mode 100644
index 0000000..4457f46
--- /dev/null
+++ b/tests/data/defines.bc
Binary files differ
diff --git a/tests/data/double.bc b/tests/data/double.bc
new file mode 100644
index 0000000..3dc204e
--- /dev/null
+++ b/tests/data/double.bc
Binary files differ
diff --git a/tests/data/expr-ansi.bc b/tests/data/expr-ansi.bc
new file mode 100644
index 0000000..9b1ddc9
--- /dev/null
+++ b/tests/data/expr-ansi.bc
Binary files differ
diff --git a/tests/data/expr2.bc b/tests/data/expr2.bc
new file mode 100644
index 0000000..4b6ce5f
--- /dev/null
+++ b/tests/data/expr2.bc
Binary files differ
diff --git a/tests/data/film.bc b/tests/data/film.bc
new file mode 100644
index 0000000..5be0267
--- /dev/null
+++ b/tests/data/film.bc
Binary files differ
diff --git a/tests/data/float.bc b/tests/data/float.bc
new file mode 100644
index 0000000..8ec27f3
--- /dev/null
+++ b/tests/data/float.bc
Binary files differ
diff --git a/tests/data/floatdouble.bc b/tests/data/floatdouble.bc
new file mode 100644
index 0000000..8d30e62
--- /dev/null
+++ b/tests/data/floatdouble.bc
Binary files differ
diff --git a/tests/data/flops.bc b/tests/data/flops.bc
new file mode 100644
index 0000000..856b222
--- /dev/null
+++ b/tests/data/flops.bc
Binary files differ
diff --git a/tests/data/hello.bc b/tests/data/hello.bc
new file mode 100644
index 0000000..74c75e7
--- /dev/null
+++ b/tests/data/hello.bc
Binary files differ
diff --git a/tests/data/inc.bc b/tests/data/inc.bc
new file mode 100644
index 0000000..6763032
--- /dev/null
+++ b/tests/data/inc.bc
Binary files differ
diff --git a/tests/data/iops.bc b/tests/data/iops.bc
new file mode 100644
index 0000000..7edaca6
--- /dev/null
+++ b/tests/data/iops.bc
Binary files differ
diff --git a/tests/data/missing-main.bc b/tests/data/missing-main.bc
new file mode 100644
index 0000000..6eacb7f
--- /dev/null
+++ b/tests/data/missing-main.bc
Binary files differ
diff --git a/tests/data/otcc-ansi.bc b/tests/data/otcc-ansi.bc
new file mode 100644
index 0000000..377fb47
--- /dev/null
+++ b/tests/data/otcc-ansi.bc
Binary files differ
diff --git a/tests/data/otcc.c b/tests/data/otcc.c
new file mode 100644
index 0000000..433ae2e
--- /dev/null
+++ b/tests/data/otcc.c
@@ -0,0 +1,448 @@
+#include <stdio.h>
+#define k *(int*)
+#define a if(
+#define c ad()
+#define i else
+#define p while(
+#define x *(char*)
+#define b ==
+#define V =calloc(1,99999)
+#define f ()
+#define J return
+#define l ae(
+#define n e)
+#define u d!=
+#define F int 
+#define y (j)
+#define r m=
+#define t +4
+F d,z,C,h,P,K,ac,q,G,v,Q,R,D,L,W,M;
+E(n{
+x D++=e;
+}
+o f{
+a L){
+h=x L++;
+a h b 2){
+L=0;
+h=W;
+}
+}
+i h=fgetc(Q);
+}
+X f{
+J isalnum(h)|h b 95;
+}
+Y f{
+a h b 92){
+o f;
+a h b 110)h=10;
+}
+}
+c{
+F e,j,m;
+p isspace(h)|h b 35){
+a h b 35){
+o f;
+c;
+a d b 536){
+c;
+E(32);
+k d=1;
+k(d t)=D;
+}
+p h!=10){
+E(h);
+o f;
+}
+E(h);
+E(2);
+}
+o f;
+}
+C=0;
+d=h;
+a X f){
+E(32);
+M=D;
+p X f){
+E(h);
+o f;
+}
+a isdigit(d)){
+z=strtol(M,0,0);
+d=2;
+}
+i{
+x D=32;
+d=strstr(R,M-1)-R;
+x D=0;
+d=d*8+256;
+a d>536){
+d=P+d;
+a k d b 1){
+L=k(d t);
+W=h;
+o f;
+c;
+}
+}
+}
+}
+i{
+o f;
+a d b 39){
+d=2;
+Y f;
+z=h;
+o f;
+o f;
+}
+i a d b 47&h b 42){
+o f;
+p h){
+p h!=42)o f;
+o f;
+a h b 47)h=0;
+}
+o f;
+c;
+}
+i{
+e="++#m--%am*@R<^1c/@%[_[H3c%@%[_[H3c+@.B#d-@%:_^BKd<<Z/03e>>`/03e<=0f>=/f<@.f>@1f==&g!='g&&k||#l&@.BCh^@.BSi|@.B+j~@/%Yd!@&d*@b";
+p j=x e++){
+r x e++;
+z=0;
+p(C=x e++-98)<0)z=z*64+C+64;
+a j b d&(m b h|m b 64)){
+a m b h){
+o f;
+d=1;
+}
+break;
+}
+}
+}
+}
+}
+l g){
+p g&&g!=-1){
+x q++=g;
+g=g>>8;
+}
+}
+A(n{
+F g;
+p n{
+g=k e;
+k e=q-e-4;
+e=g;
+}
+}
+s(g,n{
+l g);
+k q=e;
+e=q;
+q=q t;
+J e;
+}
+H(n{
+s(184,n;
+}
+B(n{
+J s(233,n;
+}
+S(j,n{
+l 1032325);
+J s(132+j,n;
+}
+Z(n{
+l 49465);
+H(0);
+l 15);
+l e+144);
+l 192);
+}
+N(j,n{
+l j+131);
+s((e<512)<<7|5,n;
+}
+T y{
+F g,e,m,aa;
+g=1;
+a d b 34){
+H(v);
+p h!=34){
+Y f;
+x v++=h;
+o f;
+}
+x v=0;
+v=v t&-4;
+o f;
+c;
+}
+i{
+aa=C;
+r z;
+e=d;
+c;
+a e b 2){
+H(m);
+}
+i a aa b 2){
+T(0);
+s(185,0);
+a e b 33)Z(m);
+i l m);
+}
+i a e b 40){
+w f;
+c;
+}
+i a e b 42){
+c;
+e=d;
+c;
+c;
+a d b 42){
+c;
+c;
+c;
+c;
+e=0;
+}
+c;
+T(0);
+a d b 61){
+c;
+l 80);
+w f;
+l 89);
+l 392+(e b 256));
+}
+i a n{
+a e b 256)l 139);
+i l 48655);
+q++;
+}
+}
+i a e b 38){
+N(10,k d);
+c;
+}
+i{
+g=k e;
+a!g)g=dlsym(0,M);
+a d b 61&j){
+c;
+w f;
+N(6,g);
+}
+i a u 40){
+N(8,g);
+a C b 11){
+N(0,g);
+l z);
+c;
+}
+}
+}
+}
+a d b 40){
+a g b 1)l 80);
+r s(60545,0);
+c;
+j=0;
+p u 41){
+w f;
+s(2393225,j);
+a d b 44)c;
+j=j t;
+}
+k r j;
+c;
+a!g){
+e=e t;
+k e=s(232,k n;
+}
+i a g b 1){
+s(2397439,j);
+j=j t;
+}
+i{
+s(232,g-q-5);
+}
+a j)s(50305,j);
+}
+}
+O y{
+F e,g,m;
+a j--b 1)T(1);
+i{
+O y;
+r 0;
+p j b C){
+g=d;
+e=z;
+c;
+a j>8){
+r S(e,m);
+O y;
+}
+i{
+l 80);
+O y;
+l 89);
+a j b 4|j b 5){
+Z(n;
+}
+i{
+l n;
+a g b 37)l 146);
+}
+}
+}
+a m&&j>8){
+r S(e,m);
+H(e^1);
+B(5);
+A(m);
+H(n;
+}
+}
+}
+w f{
+O(11);
+}
+U f{
+w f;
+J S(0,0);
+}
+I y{
+F m,g,e;
+a d b 288){
+c;
+c;
+r U f;
+c;
+I y;
+a d b 312){
+c;
+g=B(0);
+A(m);
+I y;
+A(g);
+}
+i{
+A(m);
+}
+}
+i a d b 352|d b 504){
+e=d;
+c;
+c;
+a e b 352){
+g=q;
+r U f;
+}
+i{
+a u 59)w f;
+c;
+g=q;
+r 0;
+a u 59)r U f;
+c;
+a u 41){
+e=B(0);
+w f;
+B(g-q-5);
+A(n;
+g=e t;
+}
+}
+c;
+I(&m);
+B(g-q-5);
+A(m);
+}
+i a d b 123){
+c;
+ab(1);
+p u 125)I y;
+c;
+}
+i{
+a d b 448){
+c;
+a u 59)w f;
+K=B(K);
+}
+i a d b 400){
+c;
+k j=B(k j);
+}
+i a u 59)w f;
+c;
+}
+}
+ab y{
+F m;
+p d b 256|u-1&!j){
+a d b 256){
+c;
+p u 59){
+a j){
+G=G t;
+k d=-G;
+}
+i{
+k d=v;
+v=v t;
+}
+c;
+a d b 44)c;
+}
+c;
+}
+i{
+A(k(d t));
+k d=q;
+c;
+c;
+r 8;
+p u 41){
+k d=m;
+r m t;
+c;
+a d b 44)c;
+}
+c;
+K=G=0;
+l 15042901);
+r s(60545,0);
+I(0);
+A(K);
+l 50121);
+k r G;
+}
+}
+}
+main(g,n{
+Q=stdin;
+a g-->1){
+e=e t;
+Q=fopen(k e,"r");
+}
+D=strcpy(R V," int if else while break return for define main ")+48;
+v V;
+q=ac V;
+P V;
+o f;
+c;
+ab(0);
+mprotect(ac & (~ 4095), (99999 + 4095) & (~ 4095), 7);
+fprintf(stderr, "otcc.c: about to execute compiled code.\n");
+J(*(int(*)f)k(P+592))(g,n;
+}
+
diff --git a/tests/data/pointers.bc b/tests/data/pointers.bc
new file mode 100644
index 0000000..d4e88e4
--- /dev/null
+++ b/tests/data/pointers.bc
Binary files differ
diff --git a/tests/data/pointers2.bc b/tests/data/pointers2.bc
new file mode 100644
index 0000000..b6d1f91
--- /dev/null
+++ b/tests/data/pointers2.bc
Binary files differ
diff --git a/tests/data/returnval-ansi.bc b/tests/data/returnval-ansi.bc
new file mode 100644
index 0000000..ac14ab1
--- /dev/null
+++ b/tests/data/returnval-ansi.bc
Binary files differ
diff --git a/tests/data/returnval.c b/tests/data/returnval.c
new file mode 100644
index 0000000..1cf5bae
--- /dev/null
+++ b/tests/data/returnval.c
@@ -0,0 +1,4 @@
+main() {
+  return 42;
+}
+
diff --git a/tests/data/short.bc b/tests/data/short.bc
new file mode 100644
index 0000000..eae1d26
--- /dev/null
+++ b/tests/data/short.bc
Binary files differ
diff --git a/tests/data/simplest.bc b/tests/data/simplest.bc
new file mode 100644
index 0000000..4b6ce5f
--- /dev/null
+++ b/tests/data/simplest.bc
Binary files differ
diff --git a/tests/data/src/addressOf.c b/tests/data/src/addressOf.c
new file mode 100644
index 0000000..e7acde5
--- /dev/null
+++ b/tests/data/src/addressOf.c
@@ -0,0 +1,31 @@
+void testStruct() {
+    struct str {
+        float x;
+        float y;
+    };
+
+    struct str base;
+    int index = 0;
+
+    base.x = 10.0;
+    struct str *s = &base;
+
+    float *v = &(*s).x;
+    float *v2 = &s[index].x;
+    printf("testStruct: %g %g %g\n",base.x, *v, *v2);
+}
+
+void testArray() {
+    int a[2];
+    a[0] = 1;
+    a[1] = 2;
+    int* p = &a[0];
+    int* p2 = a;
+    printf("testArray: %d %d %d\n", a[0], *p, *p2);
+}
+
+int main() {
+    testStruct();
+    testArray();
+    return 0;
+}
diff --git a/tests/data/src/array.c b/tests/data/src/array.c
new file mode 100644
index 0000000..ca4a728
--- /dev/null
+++ b/tests/data/src/array.c
@@ -0,0 +1,107 @@
+// Array allocation tests
+
+void testLocalInt()
+{
+    int a[3];
+    a[0] = 1;
+    a[1] = 2;
+    a[2] = a[0] + a[1];
+    printf("localInt: %d\n", a[2]);
+}
+
+char a[3];
+double d[3];
+
+void testGlobalChar()
+{
+    a[0] = 1;
+    a[1] = 2;
+    a[2] = a[0] + a[1];
+    printf("globalChar: %d\n", a[2]);
+}
+
+void testGlobalDouble()
+{
+    d[0] = 1;
+    d[1] = 2;
+    d[2] = d[0] + d[1];
+    printf("globalDouble: %g\n", d[2]);
+}
+
+void testLocalDouble()
+{
+    double d[3];
+    float  m[12];
+    m[0] = 1.0f;
+    m[1] = 2.0f;
+    d[0] = 1.0;
+    d[1] = 2.0;
+    d[2] = d[0] + d[1];
+    m[2] = m[0] + m[1];
+    printf("localDouble: %g %g\n", d[2], m[2]);
+}
+
+void vectorAdd(int* a, int* b, float* c, int len) {
+    int i;
+    for(i = 0; i < len; i++) {
+        c[i] = a[i] + b[i];
+    }
+}
+
+void testArgs() {
+    int a[3], b[3];
+    float c[3];
+    int i;
+    int len = 3;
+    for(i = 0; i < len; i++) {
+        a[i] = i;
+        b[i] = i;
+        c[i] = 0;
+    }
+    vectorAdd(a,b,c, len);
+    printf("testArgs:");
+    for(i = 0; i < len; i++) {
+        printf(" %g", c[i]);
+    }
+    printf("\n");
+}
+
+void testDecay() {
+    char c[4];
+    c[0] = 'H';
+    c[1] = 'i';
+    c[2] = '!';
+    c[3] = 0;
+    printf("testDecay: %s\n", c);
+}
+
+void test2D() {
+    char c[10][20];
+    int x;
+    int y;
+    printf("test2D:\n");
+    for(y = 0; y < 10; y++) {
+        for(x = 0; x < 20; x++) {
+            c[y][x] = 'a' + (15 & (y * 19 + x));
+        }
+    }
+    for(y = 0; y < 10; y++) {
+        for(x = 0; x < 20; x++) {
+            printf("%c", c[y][x]);
+        }
+        printf("\n");
+    }
+
+}
+
+int main()
+{
+    testLocalInt();
+    testLocalDouble();
+    testGlobalChar();
+    testGlobalDouble();
+    testArgs();
+    testDecay();
+    test2D();
+    return 0;
+}
diff --git a/tests/data/src/assignment.c b/tests/data/src/assignment.c
new file mode 100644
index 0000000..4fc7801
--- /dev/null
+++ b/tests/data/src/assignment.c
@@ -0,0 +1,9 @@
+int main() {
+    int a = 0;
+    int b = 1;
+    a = b = 2; // Test that "b = 2" generates an rvalue.
+    if (a = 7) { // Test that a = 7 generates an rvalue.
+        b = 3;
+    }
+    return a;
+}
diff --git a/tests/data/src/assignmentop.c b/tests/data/src/assignmentop.c
new file mode 100644
index 0000000..649edf9
--- /dev/null
+++ b/tests/data/src/assignmentop.c
@@ -0,0 +1,62 @@
+// Test assignment operations
+
+void testAssignment() {
+    int a = 2;
+    a *= 5;
+    printf("2 *= 5  %d\n", a);
+    a = 20;
+    a /= 5;
+    printf("20 /= 5  %d\n", a);
+    a = 17;
+    a %= 5;
+    printf("17 %%= 5  %d\n", a);
+    a = 17;
+    a += 5;
+    printf("17 += 5  %d\n", a);
+    a = 17;
+    a-=5;
+    printf("17 -= 5  %d\n", a);
+    a = 17;
+    a<<=1;
+    printf("17<<= 1  %d\n", a);
+    a = 17;
+    a>>=1;
+    printf("17>>= 1  %d\n", a);
+    a = 17;
+    a&=1;
+    printf("17&= 1  %d\n", a);
+    a = 17;
+    a^=1;
+    printf("17^= 1  %d\n", a);
+    a = 16;
+    a^=1;
+    printf("16|= 1  %d\n", a);
+}
+
+int a;
+
+int* f() {
+    printf("f()\n");
+    return &a;
+}
+
+void testEval() {
+    a = 0;
+    printf("*f() = *f() + 10;\n");
+    *f() = *f() + 10;
+    printf("a = %d\n", a);
+}
+
+void testOpEval() {
+    a = 0;
+    printf("*f() += 10;\n");
+    *f() += 10;
+    printf("a = %d\n", a);
+}
+
+int main() {
+    testAssignment();
+    testEval();
+    testOpEval();
+    return 0;
+}
diff --git a/tests/data/src/b2071670.c b/tests/data/src/b2071670.c
new file mode 100644
index 0000000..311bc4f
--- /dev/null
+++ b/tests/data/src/b2071670.c
@@ -0,0 +1,9 @@
+// See http://b/2071670
+
+int main() {
+    float f = 10.0f;
+    float* floatPointer = &f;
+    // The following line used to incorrectly error: "Incompatible pointer or array types"
+    int* buffer = (int*) floatPointer;
+    return *buffer;
+}
diff --git a/tests/data/src/bellard.otccex.c b/tests/data/src/bellard.otccex.c
new file mode 100644
index 0000000..e8f0989
--- /dev/null
+++ b/tests/data/src/bellard.otccex.c
@@ -0,0 +1,126 @@
+/* #!/usr/local/bin/otcc */
+/*
+ * Sample OTCC C example. You can uncomment the first line and install
+ * otcc in /usr/local/bin to make otcc scripts !  
+ */
+
+/* Any preprocessor directive except #define are ignored. We put this
+   include so that a standard C compiler can compile this code too. */
+#include <stdio.h>
+
+/* defines are handled, but macro arguments cannot be given. No
+   recursive defines are tolerated */
+#define DEFAULT_BASE 10
+
+/*
+ * Only old style K&R prototypes are parsed. Only int arguments are
+ * allowed (implicit types).
+ * 
+ * By benchmarking the execution time of this function (for example
+ * for fib(35)), you'll notice that OTCC is quite fast because it
+ * generates native i386 machine code.  
+ */
+fib(n)
+{
+    if (n <= 2)
+        return 1;
+    else
+        return fib(n-1) + fib(n-2);
+}
+
+/* Identifiers are parsed the same way as C: begins with letter or
+   '_', and then letters, '_' or digits */
+fact(n)
+{
+    /* local variables can be declared. Only 'int' type is supported */
+    int i, r;
+    r = 1;
+    /* 'while' and 'for' loops are supported */
+    for(i=2;i<=n;i++)
+        r = r * i;
+    return r;
+}
+
+/* Well, we could use printf, but it would be too easy */
+print_num(n, b)
+{
+    int tab, p, c;
+    /* Numbers can be entered in decimal, hexadecimal ('0x' prefix) and
+       octal ('0' prefix) */
+    /* more complex programs use malloc */
+    tab = malloc(0x100); 
+    p = tab;
+    while (1) {
+        c = n % b;
+        /* Character constants can be used */
+        if (c >= 10)
+            c = c + 'a' - 10;
+        else
+            c = c + '0';
+        *(char *)p = c;
+        p++;
+        n = n / b;
+        /* 'break' is supported */
+        if (n == 0)
+            break;
+    }
+    while (p != tab) {
+        p--;
+        printf("%c", *(char *)p);
+    }
+    free(tab);
+}
+
+/* 'main' takes standard 'argc' and 'argv' parameters */
+main(argc, argv)
+{
+    /* no local name space is supported, but local variables ARE
+       supported. As long as you do not use a globally defined
+       variable name as local variable (which is a bad habbit), you
+       won't have any problem */
+    int s, n, f, base;
+    
+    /* && and || operator have the same semantics as C (left to right
+       evaluation and early exit) */
+    if (argc != 2 && argc != 3) {
+        /* '*' operator is supported with explicit casting to 'int *',
+           'char *' or 'int (*)()' (function pointer). Of course, 'int'
+           are supposed to be used as pointers too. */
+        s = *(int *)argv;
+        help(s);
+        return 1;
+    }
+    /* Any libc function can be used because OTCC uses dynamic linking */
+    n = atoi(*(int *)(argv + 4));
+    base = DEFAULT_BASE;
+    if (argc >= 3) {
+        base = atoi(*(int *)(argv + 8));
+        if (base < 2 || base > 36) {
+            /* external variables can be used too (here: 'stderr') */
+            fprintf(stderr, "Invalid base\n");
+            return 1;
+        }
+    }
+    printf("fib(%d) = ", n);
+    print_num(fib(n), base);
+    printf("\n");
+
+    printf("fact(%d) = ", n);
+    if (n > 12) {
+        printf("Overflow");
+    } else {
+        /* why not using a function pointer ? */
+        f = &fact;
+        print_num((*(int (*)())f)(n), base);
+    }
+    printf("\n");
+    return 0;
+}
+
+/* functions can be used before being defined */
+help(name)
+{
+    printf("usage: %s n [base]\n", name);
+    printf("Compute fib(n) and fact(n) and output the result in base 'base'\n");
+}
+
diff --git a/tests/data/src/brackets.c b/tests/data/src/brackets.c
new file mode 100644
index 0000000..bab88a2
--- /dev/null
+++ b/tests/data/src/brackets.c
@@ -0,0 +1,61 @@
+void testBrackets(int* ar, int len) {
+    int i;
+    int errors = 0;
+    for (i = 0; i < len; i++) {
+        ar[i] = i;
+    }
+    for (i = 0; i < len; i++) {
+        if (ar[i] != i) {
+            printf("error: [%d] %d != %d\n", i, ar[i], i);
+            errors++;
+        }
+    }
+    printf("Errors: %d\n", errors);
+}
+
+void testBrackets2D(int** ar2D, int lenX, int lenY) {
+    int x, y;
+    int errors = 0;
+    for (x = 0; x < lenX; x++) {
+        for (y = 0; y < lenY; y++) {
+            ar2D[x][y] = x * lenY + y;
+        }
+    }
+    for (x = 0; x < lenX; x++) {
+        for (y = 0; y < lenY; y++) {
+            int expected = x * lenY + y;
+            int val = ar2D[x][y];
+            if (val != expected) {
+                printf("error: [%d][%d] %d != %d\n", x, y, val, expected);
+                errors++;
+            }
+        }
+    }
+    printf("2D Errors: %d\n", errors);
+}
+
+void testHeap() {
+    int* ar = (int*) malloc(100);
+    testBrackets(ar, 25);
+    free(ar);
+}
+
+void testHeap2D() {
+    int lenX = 10;
+    int lenY = 5;
+    int* ar = (int*) malloc(lenX * lenY * 4);
+    int** ar2D = (int**) malloc(lenX * 4);
+    int i;
+    for(i = 0; i < lenX; i++) {
+        ar2D[i] = ar + lenY * i;
+    }
+    testBrackets2D(ar2D, lenX, lenY);
+    free(ar);
+    free(ar2D);
+}
+
+int main() {
+    testHeap();
+    testHeap2D();
+    return 0;
+}
diff --git a/tests/data/src/casts.c b/tests/data/src/casts.c
new file mode 100644
index 0000000..d3a49b4
--- /dev/null
+++ b/tests/data/src/casts.c
@@ -0,0 +1,85 @@
+void test1() {
+    int a = 3;
+    int* pb = &a;
+    int c = *pb;
+    printf("Reading from a pointer: %d %d\n", a, c);
+    *pb = 4;
+    printf("Writing to a pointer: %d\n", a);
+    printf("Testing casts: %d %g %g %d\n", 3, (float) 3, 4.5, (int) 4.5);
+}
+
+void test2() {
+    int x = 4;
+    int px = &x;
+    // int z = * px; // An error, expected a pointer type
+    int y = * (int*) px;
+    printf("Testing reading (int*): %d\n", y);
+}
+
+void test3() {
+    int px = (int) malloc(120);
+    * (int*) px = 8;
+    * (int*) (px + 4) = 9;
+    printf("Testing writing (int*): %d %d\n", * (int*) px, * (int*) (px + 4));
+    free((void*) px);
+}
+
+void test4() {
+    int x = 0x12345678;
+    int px = &x;
+    int a = * (char*) px;
+    int b = * (char*) (px + 1);
+    int c = * (char*) (px + 2);
+    int d = * (char*) (px + 3);
+    printf("Testing reading (char*): 0x%02x 0x%02x 0x%02x 0x%02x\n", a, b, c, d);
+}
+
+void test5() {
+    int x = 0xFFFFFFFF;
+    int px = &x;
+    * (char*) px = 0x21;
+    * (char*) (px + 1) = 0x43;
+    * (char*) (px + 2) = 0x65;
+    * (char*) (px + 3) = 0x87;
+    printf("Testing writing (char*): 0x%08x\n", x);
+}
+
+int f(int b) {
+    printf("f(%d)\n", b);
+    return 7 * b;
+}
+
+void test6() {
+    int fp = &f;
+    int x = (*(int(*)()) fp)(10);
+    printf("Function pointer result: %d\n", x);
+}
+
+void test7() {
+    int px = (int) malloc(120);
+    * (float*) px = 8.8f;
+    * (float*) (px + 4) = 9.9f;
+    printf("Testing read/write (float*): %g %g\n", * (float*) px, * (float*) (px + 4));
+    free((void*) px);
+}
+
+void test8() {
+    int px = (int) malloc(120);
+    * (double*) px = 8.8;
+    * (double*) (px + 8) = 9.9;
+    printf("Testing read/write (double*): %g %g\n", * (double*) px, * (double*) (px + 8));
+    free((void*) px);
+}
+
+
+int main() {
+    test1();
+    test2();
+    test3();
+    test4();
+    test5();
+    test6();
+    test7();
+    test8();
+    return 0;
+}
diff --git a/tests/data/src/char.c b/tests/data/src/char.c
new file mode 100644
index 0000000..8c63ba2
--- /dev/null
+++ b/tests/data/src/char.c
@@ -0,0 +1,13 @@
+char ga;
+char gb;
+
+int main() {
+    char a = 'c';
+    char b = a * 3;
+    printf("a = %d, b = %d\n", a, b);
+    ga = 'd';
+    gb = ga * 3;
+    printf("ga = %d, gb = %d\n", ga, gb);
+    return 0;
+}
+
diff --git a/tests/data/src/comma.c b/tests/data/src/comma.c
new file mode 100644
index 0000000..496944c
--- /dev/null
+++ b/tests/data/src/comma.c
@@ -0,0 +1,35 @@
+int testReturn() {
+    return 10, 20, 30;
+}
+
+int testArg(int a) {
+    return a;
+}
+
+void testComma() {
+    int a;
+    0, a = 10,20;
+    printf("statement: %d\n", a);
+    a = 1;
+    if (a = 0, 1) {
+        printf("if: a = %d\n", a);
+    }
+    int b = 0;
+    a = 10;
+    while(b++,a--) {}
+    printf("while: b = %d\n", b);
+    b = 0;
+    for(b++,a = 0;b++, a < 10; b++, a++) {}
+    printf("for: b = %d\n", b);
+    b = testReturn();
+    printf("return: %d\n", b);
+    b = testArg((a,12));
+    printf("arg: %d\n", b);
+}
+
+
+
+int main() {
+    testComma();
+    return 0;
+}
diff --git a/tests/data/src/constants.c b/tests/data/src/constants.c
new file mode 100644
index 0000000..230109a
--- /dev/null
+++ b/tests/data/src/constants.c
@@ -0,0 +1,30 @@
+#define FOO 0x10
+
+int main() {
+    printf("0 = %d\n", 0);
+    printf("010 = %d\n", 010);
+    printf("0x10 = %d\n", FOO);
+    printf("'\\a' = %d\n", '\a');
+    printf("'\\b' = %d\n", '\b');
+    printf("'\\f' = %d\n", '\f');
+    printf("'\\n' = %d\n", '\n');
+    printf("'\\r' = %d\n", '\r');
+    printf("'\\t' = %d\n", '\t');
+    printf("'\\v' = %d\n", '\v');
+    // Undefined
+    // printf("'\\z' = %d\n", '\z');
+    printf("'\\\\' = %d\n", '\\');
+    printf("'\\'' = %d\n", '\'');
+    printf("'\\\"' = %d\n", '\"');
+    printf("'\\?' = %d\n", '\?');
+    printf("'\\0' = %d\n", '\0');
+    printf("'\\1' = %d\n", '\1');
+    printf("'\\12' = %d\n", '\12');
+    printf("'\\123' = %d\n", '\123');
+    printf("'\\x0' = %d\n", '\x0');
+    printf("'\\x1' = %d\n", '\x1');
+    printf("'\\x12' = %d\n", '\x12');
+    printf("'\\x123' = %d\n", '\x123');
+    printf("'\\x1f' = %d\n", '\x1f');
+    printf("'\\x1F' = %d\n", '\x1F');
+}
diff --git a/tests/data/src/defines.c b/tests/data/src/defines.c
new file mode 100644
index 0000000..6cb6f7e
--- /dev/null
+++ b/tests/data/src/defines.c
@@ -0,0 +1,9 @@
+// Simple tests of the C preprocessor
+
+#define A 1
+#define A (4 / 2)
+#define B 1 // This is a comment. With a / in it.
+
+int main() {
+    return A + B;
+}
diff --git a/tests/data/src/double.c b/tests/data/src/double.c
new file mode 100644
index 0000000..5bc20a3
--- /dev/null
+++ b/tests/data/src/double.c
@@ -0,0 +1,7 @@
+double atof(char *nptr);
+
+int main() {
+    printf("Value = %g\n", atof("10.42"));
+    return 0;
+}
+
diff --git a/tests/data/src/error.c b/tests/data/src/error.c
new file mode 100644
index 0000000..2e08dcc
--- /dev/null
+++ b/tests/data/src/error.c
@@ -0,0 +1,2 @@
+void foo;
+
diff --git a/tests/data/src/expr-ansi.c b/tests/data/src/expr-ansi.c
new file mode 100644
index 0000000..d463659
--- /dev/null
+++ b/tests/data/src/expr-ansi.c
@@ -0,0 +1,60 @@
+/* Test operators */
+
+void testInc() { int a, b; a = 3; b = a++; printf("3++ = %d %d\n", b, a); }
+void testDec() { int a, b; a = 3; b = a--; printf("3-- = %d %d\n", b, a); }
+void testTimes(){ printf("%d * %d = %d\n", 10, 4, 10 * 4); }
+void testDiv(){ printf("%d / %d = %d\n", 11, 4, 11 / 4); }
+void testMod(){ printf("%d %% %d = %d\n", 11, 4, 11 % 4); }
+void testPlus(){ printf("%d + %d = %d\n", 10, 4, 10 + 4); }
+void testMinus(){ printf("%d - %d = %d\n", 10, 4, 10 - 4); }
+void testShiftLeft(){ printf("%d << %d = %d\n", 10, 4, 10 << 4); }
+void testShiftRight(){ printf("%d >> %d = %d\n", 100, 4, 100 >> 4); }
+void testLess(){ printf("%d < %d = %d\n", 10, 4, 10 < 4); }
+void testLesEqual(){ printf("%d <= %d = %d\n", 10, 4, 10 <= 4); }
+void testGreater(){ printf("%d > %d = %d\n", 10, 4, 10 > 4); }
+void testGreaterEqual(){ printf("%d >= %d = %d\n", 10, 4, 10 >= 4); }
+void testEqualTo(){ printf("%d == %d = %d\n", 10, 4, 10 == 4); }
+void testNotEqualTo(){ printf("%d != %d = %d\n", 10, 4, 10 != 4); }
+void testBitAnd(){ printf("%d & %d = %d\n", 10, 7, 10 & 7); }
+void testBitXor(){ printf("%d ^ %d = %d\n", 10, 7, 10 ^ 7); }
+void testBitOr(){ printf("%d | %d = %d\n", 10, 4, 10 | 4); }
+void testAssignment(){ int a, b; a = 3; b = a; printf("b == %d\n", b); }
+void testLogicalAnd(){ printf("%d && %d = %d\n", 10, 4, 10 && 4); }
+void testLogicalOr(){ printf("%d || %d = %d\n", 10, 4, 10 || 4); }
+void testAddressOf(){ int a; printf("&a is %d\n", &a); }
+void testPointerIndirection(){ int a, b; a = &b; b = 17; printf("*%d  = %d =?= %d\n", a, * (int*) a, b); }
+void testNegation(){ printf("-%d = %d\n", 10, -10); }
+void testUnaryPlus(){ printf("+%d = %d\n", 10, +10); }
+void testUnaryNot(){ printf("!%d = %d\n", 10, !10); }
+void testBitNot(){ printf("~%d = %d\n", 10, ~10); }
+
+int main(int a, char** b) {
+    testInc();
+    testDec();
+    testTimes();
+    testDiv();
+    testMod();
+    testPlus();
+    testMinus();
+    testShiftLeft();
+    testShiftRight();
+    testLess();
+    testLesEqual();
+    testGreater();
+    testGreaterEqual();
+    testEqualTo();
+    testNotEqualTo();
+    testBitAnd();
+    testBinXor();
+    testBitOr();
+    testAssignment();
+    testLogicalAnd();
+    testLogicalOr();
+    testAddressOf();
+    testPointerIndirection();
+    testNegation();
+    testUnaryPlus();
+    testUnaryNot();
+    testBitNot();
+    return 0;
+}
diff --git a/tests/data/src/expr.c b/tests/data/src/expr.c
new file mode 100644
index 0000000..4f2d2e7
--- /dev/null
+++ b/tests/data/src/expr.c
@@ -0,0 +1,60 @@
+/* Test operators */
+
+testInc() { int a, b; a = 3; b = a++; printf("3++ = %d %d\n", b, a); }
+testDec() { int a, b; a = 3; b = a--; printf("3-- = %d %d\n", b, a); }
+testTimes(){ printf("%d * %d = %d\n", 10, 4, 10 * 4); }
+testDiv(){ printf("%d / %d = %d\n", 11, 4, 11 / 4); }
+testMod(){ printf("%d %% %d = %d\n", 11, 4, 11 % 4); }
+testPlus(){ printf("%d + %d = %d\n", 10, 4, 10 + 4); }
+testMinus(){ printf("%d - %d = %d\n", 10, 4, 10 - 4); }
+testShiftLeft(){ printf("%d << %d = %d\n", 10, 4, 10 << 4); }
+testShiftRight(){ printf("%d >> %d = %d\n", 100, 4, 100 >> 4); }
+testLess(){ printf("%d < %d = %d\n", 10, 4, 10 < 4); }
+testLesEqual(){ printf("%d <= %d = %d\n", 10, 4, 10 <= 4); }
+testGreater(){ printf("%d > %d = %d\n", 10, 4, 10 > 4); }
+testGreaterEqual(){ printf("%d >= %d = %d\n", 10, 4, 10 >= 4); }
+testEqualTo(){ printf("%d == %d = %d\n", 10, 4, 10 == 4); }
+testNotEqualTo(){ printf("%d != %d = %d\n", 10, 4, 10 != 4); }
+testBitAnd(){ printf("%d & %d = %d\n", 10, 7, 10 & 7); }
+testBitXor(){ printf("%d ^ %d = %d\n", 10, 7, 10 ^ 7); }
+testBitOr(){ printf("%d | %d = %d\n", 10, 4, 10 | 4); }
+testAssignment(){ int a, b; a = 3; b = a; printf("b == %d\n", b); }
+testLogicalAnd(){ printf("%d && %d = %d\n", 10, 4, 10 && 4); }
+testLogicalOr(){ printf("%d || %d = %d\n", 10, 4, 10 || 4); }
+testAddressOf(){ int a; printf("&a is %d\n", &a); }
+testPointerIndirection(){ int a, b; a = &b; b = 17; printf("*%d  = %d =?= %d\n", a, * (int*) a, b); }
+testNegation(){ printf("-%d = %d\n", 10, -10); }
+testUnaryPlus(){ printf("+%d = %d\n", 10, +10); }
+testUnaryNot(){ printf("!%d = %d\n", 10, !10); }
+testBitNot(){ printf("~%d = %d\n", 10, ~10); }
+
+main(a,b) {
+    testInc();
+    testDec();
+    testTimes();
+    testDiv();
+    testMod();
+    testPlus();
+    testMinus();
+    testShiftLeft();
+    testShiftRight();
+    testLess();
+    testLesEqual();
+    testGreater();
+    testGreaterEqual();
+    testEqualTo();
+    testNotEqualTo();
+    testBitAnd();
+    testBinXor();
+    testBitOr();
+    testAssignment();
+    testLogicalAnd();
+    testLogicalOr();
+    testAddressOf();
+    testPointerIndirection();
+    testNegation();
+    testUnaryPlus();
+    testUnaryNot();
+    testBitNot();
+    return 0;
+}
\ No newline at end of file
diff --git a/tests/data/src/expr2.c b/tests/data/src/expr2.c
new file mode 100644
index 0000000..04b6a38
--- /dev/null
+++ b/tests/data/src/expr2.c
@@ -0,0 +1,6 @@
+/* Test operators */
+
+main() {
+    int a;
+    a = a++;
+}
diff --git a/tests/data/src/film.c b/tests/data/src/film.c
new file mode 100644
index 0000000..00c2d36
--- /dev/null
+++ b/tests/data/src/film.c
@@ -0,0 +1,53 @@
+// Test logical and bitwise AND and OR
+
+int test(int x, int y) {
+    int v = x || y;
+    return v;
+}
+
+int test2(int x, int y) {
+    if(x | y) {
+        return 1;
+    } else {
+        return 0;
+    }
+}
+
+int test3(int x, int y) {
+    int v = x && y;
+    return v;
+}
+
+int test4(int x, int y) {
+    if(x & y) {
+        return 1;
+    } else {
+        return 0;
+    }
+}
+
+int main(int index)
+{
+    int x,y;
+    printf("testing...\n");
+    int totalBad = 0;
+    for(y = 0; y < 2; y++) {
+        for(x = 0; x < 2; x++) {
+            int a = test(x,y);
+            int b = test2(x,y);
+            if (a != b) {
+                printf("Results differ: OR x=%d y=%d a=%d b=%d\n", x, y, a, b);
+                totalBad++;
+            }
+            a = test3(x,y);
+            b = test4(x,y);
+            if (a != b) {
+                printf("Results differ: AND x=%d y=%d a=%d b=%d\n", x, y, a, b);
+                totalBad++;
+            }
+        }
+    }
+    printf("Total bad: %d\n", totalBad);
+    return 0;
+}
+
diff --git a/tests/data/src/float.c b/tests/data/src/float.c
new file mode 100644
index 0000000..f48b3d1
--- /dev/null
+++ b/tests/data/src/float.c
@@ -0,0 +1,57 @@
+int ftoi(float f) {
+    return f;
+}
+
+int dtoi(double d) {
+    return d;
+}
+
+float itof(int i) {
+    return i;
+}
+
+double itod(int i) {
+    return i;
+}
+
+float f0, f1;
+double d0, d1;
+
+void testParseConsts() {
+    printf("Constants: %g %g %g %g %g %g %g %g %g\n", 0e1, 0E1, 0.f, .01f,
+          .01e0f, 1.0e-1, 1.0e1, 1.0e+1,
+          .1f);
+}
+void testVars(float arg0, float arg1, double arg2, double arg3) {
+    float local0, local1;
+    double local2, local3;
+    f0 = arg0;
+    f1 = arg1;
+    d0 = arg2;
+    d1 = arg3;
+    local0 = arg0;
+    local1 = arg1;
+    local2 = arg2;
+    local3 = arg3;
+    printf("globals: %g %g %g %g\n", f0, f1, d0, d1);
+    printf("args: %g %g %g %g\n", arg0, arg1, arg2, arg3);
+    printf("locals: %g %g %g %g\n", local0, local1, local2, local3);
+
+
+    printf("cast rval: %g %g\n", * (float*) & f1, * (double*) & d1);
+
+    * (float*) & f0 = 1.1f;
+    * (double*) & d0 = 3.3;
+    printf("cast lval: %g %g %g %g\n", f0, f1, d0, d1);
+}
+
+int main() {
+    testParseConsts();
+    printf("int: %d float: %g double: %g\n", 1, 2.2f, 3.3);
+    printf(" ftoi(1.4f)=%d\n", ftoi(1.4f));
+    printf(" dtoi(2.4)=%d\n", dtoi(2.4));
+    printf(" itof(3)=%g\n", itof(3));
+    printf(" itod(4)=%g\n", itod(4));
+    testVars(1.0f, 2.0f, 3.0, 4.0);
+    return 0;
+}
diff --git a/tests/data/src/floatdouble.c b/tests/data/src/floatdouble.c
new file mode 100644
index 0000000..264c641
--- /dev/null
+++ b/tests/data/src/floatdouble.c
@@ -0,0 +1,9 @@
+int main()
+{
+    // Test coercing values when storing.
+    float a = 0.002;
+    double b = 0.1f;
+    int c = 10.002;
+    printf("%g %g %d\n", a, b, c);
+    return 0;
+}
diff --git a/tests/data/src/flops.c b/tests/data/src/flops.c
new file mode 100644
index 0000000..40b1b28
--- /dev/null
+++ b/tests/data/src/flops.c
@@ -0,0 +1,158 @@
+// Test floating point operations.
+
+void unaryOps() {
+    // Unary ops
+    printf("-%g = %g\n", 1.1, -1.1);
+    printf("!%g = %d\n", 1.2, !1.2);
+    printf("!%g = %d\n", 0.0, !0.0);
+}
+
+void binaryOps() {
+    printf("double op double:\n");
+    printf("%g + %g = %g\n", 1.0, 2.0, 1.0 + 2.0);
+    printf("%g - %g = %g\n", 1.0, 2.0, 1.0 - 2.0);
+    printf("%g * %g = %g\n", 1.0, 2.0, 1.0 * 2.0);
+    printf("%g / %g = %g\n", 1.0, 2.0, 1.0 / 2.0);
+
+    printf("float op float:\n");
+    printf("%g + %g = %g\n", 1.0f, 2.0f, 1.0f + 2.0f);
+    printf("%g - %g = %g\n", 1.0f, 2.0f, 1.0f - 2.0f);
+    printf("%g * %g = %g\n", 1.0f, 2.0f, 1.0f * 2.0f);
+    printf("%g / %g = %g\n", 1.0f, 2.0f, 1.0f / 2.0f);
+
+    printf("double op float:\n");
+    printf("%g + %g = %g\n", 1.0, 2.0f, 1.0 + 2.0f);
+    printf("%g - %g = %g\n", 1.0, 2.0f, 1.0 - 2.0f);
+    printf("%g * %g = %g\n", 1.0, 2.0f, 1.0 * 2.0f);
+    printf("%g / %g = %g\n", 1.0, 2.0f, 1.0 / 2.0f);
+
+    printf("double op int:\n");
+    printf("%g + %d = %g\n", 1.0, 2, 1.0 + 2);
+    printf("%g - %d = %g\n", 1.0, 2, 1.0 - 2);
+    printf("%g * %d = %g\n", 1.0, 2, 1.0 * 2);
+    printf("%g / %d = %g\n", 1.0, 2, 1.0 / 2);
+
+    printf("int op double:\n");
+    printf("%d + %g = %g\n", 1, 2.0, 1 + 2.0);
+    printf("%d - %g = %g\n", 1, 2.0, 1 - 2.0);
+    printf("%d * %g = %g\n", 1, 2.0, 1 * 2.0);
+    printf("%d / %g = %g\n", 1, 2.0, 1 / 2.0);
+}
+
+void comparisonTestdd(double a, double b) {
+    printf("%g op %g: < %d   <= %d   == %d   >= %d   > %d   != %d\n",
+           a, b, a < b, a <= b, a == b, a >= b, a > b, a != b);
+}
+
+void comparisonOpsdd() {
+    printf("double op double:\n");
+    comparisonTestdd(1.0, 2.0);
+    comparisonTestdd(1.0, 1.0);
+    comparisonTestdd(2.0, 1.0);
+}
+
+
+void comparisonTestdf(double a, float b) {
+    printf("%g op %g: < %d   <= %d   == %d   >= %d   > %d   != %d\n",
+           a, b, a < b, a <= b, a == b, a >= b, a > b, a != b);
+}
+
+void comparisonOpsdf() {
+    printf("double op float:\n");
+    comparisonTestdf(1.0, 2.0f);
+    comparisonTestdf(1.0, 1.0f);
+    comparisonTestdf(2.0, 1.0f);
+}
+
+void comparisonTestff(float a, float b) {
+    printf("%g op %g: < %d   <= %d   == %d   >= %d   > %d   != %d\n",
+           a, b, a < b, a <= b, a == b, a >= b, a > b, a != b);
+}
+
+void comparisonOpsff() {
+    printf("float op float:\n");
+    comparisonTestff(1.0f, 2.0f);
+    comparisonTestff(1.0f, 1.0f);
+    comparisonTestff(2.0f, 1.0f);
+}
+
+void comparisonTestid(int a, double b) {
+    printf("%d op %g: < %d   <= %d   == %d   >= %d   > %d   != %d\n",
+           a, b, a < b, a <= b, a == b, a >= b, a > b, a != b);
+}
+
+void comparisonOpsid() {
+    printf("int op double:\n");
+    comparisonTestid(1, 2.0);
+    comparisonTestid(1, 1.0);
+    comparisonTestid(2, 1.0);
+}
+void comparisonTestdi(double a, int b) {
+    printf("%g op %d: < %d   <= %d   == %d   >= %d   > %d   != %d\n",
+           a, b, a < b, a <= b, a == b, a >= b, a > b, a != b);
+}
+
+void comparisonOpsdi() {
+    printf("double op int:\n");
+    comparisonTestdi(1.0f, 2);
+    comparisonTestdi(1.0f, 1);
+    comparisonTestdi(2.0f, 1);
+}
+
+void comparisonOps() {
+    comparisonOpsdd();
+    comparisonOpsdf();
+    comparisonOpsff();
+    comparisonOpsid();
+    comparisonOpsdi();
+}
+
+int branch(double d) {
+    if (d) {
+        return 1;
+    }
+    return 0;
+}
+
+void testBranching() {
+    printf("branching: %d %d %d\n", branch(-1.0), branch(0.0), branch(1.0));
+}
+
+void testpassi(int a, int b, int c, int d, int e, int f, int g, int h, int i, int j, int k, int l) {
+    printf("testpassi: %d %d %d %d %d %d %d %d %d %d %d %d\n", a, b, c, d, e, f, g, h, i, j, k, l);
+}
+
+void testpassf(float a, float b, float c, float d, float e, float f, float g, float h, float i, float j, float k, float l) {
+    printf("testpassf: %g %g %g %g %g %g %g %g %g %g %g %g\n", a, b, c, d, e, f, g, h, i, j, k, l);
+}
+
+void testpassd(double a, double b, double c, double d, double e, double f, double g, double h, double i, double j, double k, double l) {
+    printf("testpassd: %g %g %g %g %g %g %g %g %g %g %g %g\n", a, b, c, d, e, f, g, h, i, j, k, l);
+}
+
+void testpassidf(int i, double d, float f) {
+    printf("testpassidf: %d %g %g\n", i, d, f);
+}
+
+void testParameterPassing() {
+    float x;
+    testpassi(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
+    testpassf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
+    testpassd(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
+    testpassi(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f);
+    testpassf(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f);
+    testpassd(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f);
+    testpassi(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0);
+    testpassf(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0);
+    testpassd(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0);
+    testpassidf(1, 2.0, 3.0f);
+}
+
+int main() {
+    unaryOps();
+    binaryOps();
+    comparisonOps();
+    testBranching();
+    testParameterPassing();
+    return 0;
+}
diff --git a/tests/data/src/funcargs.c b/tests/data/src/funcargs.c
new file mode 100644
index 0000000..1dce226
--- /dev/null
+++ b/tests/data/src/funcargs.c
@@ -0,0 +1,8 @@
+int f(int a,int, int c) {
+    return a + c;
+}
+
+int main() {
+    return f(1,2,3);
+}
+
diff --git a/tests/data/src/hello.c b/tests/data/src/hello.c
new file mode 100644
index 0000000..06c9d03
--- /dev/null
+++ b/tests/data/src/hello.c
@@ -0,0 +1,4 @@
+int main() {
+    printf("Hello, world\n");
+    return 0;
+}
diff --git a/tests/data/src/inc.c b/tests/data/src/inc.c
new file mode 100644
index 0000000..14c09d1
--- /dev/null
+++ b/tests/data/src/inc.c
@@ -0,0 +1,14 @@
+// Check integer operations
+
+int main() {
+    int a = 0;
+    printf("%d\n", a++);
+    printf("%d\n", a++);
+    printf("%d\n", a--);
+    printf("%d\n", a--);
+    printf("%d\n", ++a);
+    printf("%d\n", ++a);
+    printf("%d\n", --a);
+    printf("%d\n", --a);
+    return a;
+}
diff --git a/tests/data/src/iops.c b/tests/data/src/iops.c
new file mode 100644
index 0000000..780e95d
--- /dev/null
+++ b/tests/data/src/iops.c
@@ -0,0 +1,23 @@
+// Check integer operations
+
+void loops() {
+    int y;
+    printf("++\n");
+    for(y = 0; y < 10; y++) {
+        printf("%d\n", y);
+    }
+    printf("--\n");
+    for(y = 10; y >= 0; y--) {
+        printf("%d\n", y);
+    }
+}
+
+void checkLiterals() {
+    printf("Literals: %d %d\n", 1, -1);
+}
+
+int main() {
+    checkLiterals();
+    loops();
+    return 0;
+}
diff --git a/tests/data/src/locals.c b/tests/data/src/locals.c
new file mode 100644
index 0000000..f1ef363
--- /dev/null
+++ b/tests/data/src/locals.c
@@ -0,0 +1,71 @@
+int a;
+
+int f() {
+    int a;
+    // Undefined variable b
+    // printf("f 0: a = %d b = %d\n", a, b);
+    printf("f 0: a = %d\n", a);
+    a = 2;
+    printf("f 1: a = %d\n", a);
+}
+
+int g(int a) {
+    printf("g 0: a = %d\n", a);
+    a = 3;
+    printf("g 1: a = %d\n", a);
+}
+
+int h(int a) {
+    // int a; // gcc 4.3 says error: 'a' redeclared as different kind of symbol
+
+    printf("h 0: a = %d\n", a);
+    a = 4;
+    printf("h 1: a = %d\n", a);
+}
+
+// Already defined global 
+// int h() {}
+int globCheck() {
+    fprintf(stdout, "globCheck()\n");
+}
+
+int fwdCheck() {
+    b();
+    // Undefined forward reference
+    // c();
+}
+
+int b() {
+    printf("b()\n");
+}
+
+int nested() {
+    int a;
+    printf("nested 0: a = %d\n", a);
+    a = 50;
+    printf("nested 1: a = %d\n", a);
+    {
+        int a;
+        printf("nested 2: a = %d\n", a);
+        a = 51;
+        printf("nested 3: a = %d\n", a);
+    }
+    printf("nested 4: a = %d\n", a);
+}
+
+int main() {
+    globCheck();
+    fwdCheck();
+    printf("main 0: a = %d\n", a);
+    a = 5;
+    printf("main 1: a = %d\n", a);
+    f();
+    printf("main 2: a = %d\n", a);
+    g(77);
+    printf("main 3: a = %d\n", a);
+    h(30);
+    printf("main 4: a = %d\n", a);
+    nested();
+    printf("main 5: a = %d\n", a);
+    return 0;
+}
diff --git a/tests/data/src/missing-main.c b/tests/data/src/missing-main.c
new file mode 100644
index 0000000..e73eec4
--- /dev/null
+++ b/tests/data/src/missing-main.c
@@ -0,0 +1,4 @@
+/* No main. */
+
+a() {
+}
\ No newline at end of file
diff --git a/tests/data/src/otcc-ansi.c b/tests/data/src/otcc-ansi.c
new file mode 100644
index 0000000..e1534bd
--- /dev/null
+++ b/tests/data/src/otcc-ansi.c
@@ -0,0 +1,469 @@
+// #include <stdio.h>
+extern int stdin, stderr, errno;
+int d, z, C, h, P, K, ac, q, G, v, Q, R, D, L, W, M;
+
+void w();
+void ab(int);
+
+void E(int e) {
+    *(char*) D++ = e;
+}
+
+void o() {
+    if (L) {
+        h = *(char*) L++;
+        if (h == 2) {
+            L = 0;
+            h = W;
+        }
+    } else
+        h = fgetc(Q);
+}
+
+int X() {
+    return isalnum(h) | h == 95;
+}
+
+void Y() {
+    if (h == 92) {
+        o();
+        if (h == 110)
+            h = 10;
+    }
+}
+
+void ad() {
+    int e, j, m;
+    while (isspace(h) | h == 35) {
+        if (h == 35) {
+            o();
+            ad();
+            if (d == 536) {
+                ad();
+                E(32);
+                *(int*) d = 1;
+                *(int*) (d + 4) = D;
+            }
+            while (h != 10) {
+                E(h);
+                o();
+            }
+            E(h);
+            E(2);
+        }
+        o();
+    }
+    C = 0;
+    d = h;	
+    if (X()) {
+        E(32);
+        M = D;
+        while (X()) {
+            E(h);
+            o();
+        }
+        if (isdigit(d)) {
+            z = strtol(M, 0, 0);
+            d = 2;
+        } else {
+            *(char*) D = 32;
+            d = strstr(R, M - 1) - R;
+            *(char*) D = 0;
+            d = d * 8 + 256;
+            if (d > 536) {
+                d = P + d;
+                if (*(int*) d == 1) {
+                    L = *(int*) (d + 4);
+                    W = h;
+                    o();
+                    ad();
+                }
+            }
+        }
+    } else {
+        o();
+        if (d == 39) {
+            d = 2;
+            Y();
+            z = h;
+            o();
+            o();
+        } else if (d == 47 & h == 42) {
+            o();
+            while (h) {
+                while (h != 42)
+                    o();
+                o();
+                if (h == 47)
+                    h = 0;
+            }
+            o();
+            ad();
+        } else {
+            e
+                    = "++#m--%am*@R<^1c/@%[_[H3c%@%[_[H3c+@.B#d-@%:_^BKd<<Z/03e>>`/03e<=0f>=/f<@.f>@1f==&g!='g&&k||#l&@.BCh^@.BSi|@.B+j~@/%Yd!@&d*@b";
+            while (j = *(char*) e++) {
+                m = *(char*) e++;
+                z = 0;
+                while ((C = *(char*) e++ - 98) < 0)
+                    z = z * 64 + C + 64;
+                if (j == d & (m == h | m == 64)) {
+                    if (m == h) {
+                        o();
+                        d = 1;
+                    }
+                    break;
+                }
+            }
+        }
+    }
+}
+
+void ae(int g) {
+    while( g&&g!=-1) {
+        *(char*) q++=g;
+        g=g>>8;
+    }
+}
+
+void A(int e) {
+    int g;
+    while( e) {
+        g=*(int*) e;
+        *(int*) e=q-e-4;
+        e=g;
+    }
+}
+
+int s(int g, int e) {
+    ae(g);
+    *(int*) q = e;
+    e = q;
+    q = q + 4;
+    return e;
+}
+
+void H(int e) {
+    s(184,e);
+}
+
+int B(int e) {
+    return s(233,e);
+}
+
+int S(int j, int e) {
+    ae(1032325);
+    return s(132 + j, e);
+}
+
+void Z(int e) {
+    ae( 49465);
+    H(0);
+    ae( 15);
+    ae( e+144);
+    ae( 192);
+}
+
+void N(int j, int e) {
+    ae(j + 131);
+    s((e > -512 && e < 512) << 7 | 5, e);
+}
+
+void T (int j) {
+    int g,e,m,aa;
+    g=1;
+    if( d == 34) {
+        H(v);
+        while( h!=34) {
+            Y ();
+            *(char*) v++=h;
+            o ();
+        }
+        *(char*) v=0;
+        v=v +4&-4;
+        o ();
+        ad();
+    }
+    else {
+        aa=C;
+        m= z;
+        e=d;
+        ad();
+        if( e == 2) {
+            H(m);
+        }
+        else if( aa == 2) {
+            T(0);
+            s(185,0);
+            if( e == 33)Z(m);
+            else ae( m);
+        }
+        else if( e == 40) {
+            w ();
+            ad();
+        }
+        else if( e == 42) {
+            ad();
+            e=d;
+            ad();
+            ad();
+            if( d == 42) {
+                ad();
+                ad();
+                ad();
+                ad();
+                e=0;
+            }
+            ad();
+            T(0);
+            if( d == 61) {
+                ad();
+                ae( 80);
+                w ();
+                ae( 89);
+                ae( 392+(e == 256));
+            }
+            else if( e) {
+                if( e == 256)ae( 139);
+                else ae( 48655);
+                q++;
+            }
+        }
+        else if( e == 38) {
+            N(10,*(int*) d);
+            ad();
+        }
+        else {
+            g=*(int*) e;
+            if(!g)g=dlsym(0,M);
+            if( d == 61&j) {
+                ad();
+                w ();
+                N(6,g);
+            }
+            else if( d!= 40) {
+                N(8,g);
+                if( C == 11) {
+                    N(0,g);
+                    ae( z);
+                    ad();
+                }
+            }
+        }
+    }
+    if( d == 40) {
+        if( g == 1)ae( 80);
+        m= s(60545,0);
+        ad();
+        j=0;
+        while( d!= 41) {
+            w ();
+            s(2393225,j);
+            if( d == 44)ad();
+            j=j +4;
+        }
+        *(int*) m= j;
+        ad();
+        if(!g) {
+            e=e +4;
+            *(int*) e=s(232,*(int*) e);
+        }
+        else if( g == 1) {
+            s(2397439,j);
+            j=j +4;
+        }
+        else {
+            s(232,g-q-5);
+        }
+        if( j)s(50305,j);
+    }
+}
+
+void O (int j) {
+    int e,g,m;
+    if( j--== 1)T(1);
+    else {
+        O (j);
+        m= 0;
+        while( j == C) {
+            g=d;
+            e=z;
+            ad();
+            if( j>8) {
+                m= S(e,m);
+                O (j);
+            }
+            else {
+                ae( 80);
+                O (j);
+                ae( 89);
+                if( j == 4|j == 5) {
+                    Z(e);
+                }
+                else {
+                    ae( e);
+                    if( g == 37)ae( 146);
+                }
+            }
+        }
+        if( m&&j>8) {
+            m= S(e,m);
+            H(e^1);
+            B(5);
+            A(m);
+            H(e);
+        }
+    }
+}
+
+void w() {
+    O(11);
+}
+
+int U() {
+    w();
+    return S(0, 0);
+}
+
+void I (int j) {
+    int m,g,e;
+    if( d == 288) {
+        ad();
+        ad();
+        m= U ();
+        ad();
+        I (j);
+        if( d == 312) {
+            ad();
+            g=B(0);
+            A(m);
+            I (j);
+            A(g);
+        }
+        else {
+            A(m);
+        }
+    }
+    else if( d == 352|d == 504) {
+        e=d;
+        ad();
+        ad();
+        if( e == 352) {
+            g=q;
+            m= U ();
+        }
+        else {
+            if( d!= 59)w ();
+            ad();
+            g=q;
+            m= 0;
+            if( d!= 59)m= U ();
+            ad();
+            if( d!= 41) {
+                e=B(0);
+                w ();
+                B(g-q-5);
+                A(e);
+                g=e +4;
+            }
+        }
+        ad();
+        I(&m);
+        B(g-q-5);
+        A(m);
+    }
+    else if( d == 123) {
+        ad();
+        ab(1);
+        while( d!= 125)I (j);
+        ad();
+    }
+    else {
+        if( d == 448) {
+            ad();
+            if( d!= 59)w ();
+            K=B(K);
+        }
+        else if( d == 400) {
+            ad();
+            *(int*) j=B(*(int*) j);
+        }
+        else if( d!= 59)w ();
+        ad();
+    }
+}
+
+void ab (int j) {
+    int m;
+    while( d == 256|d!=-1&!j) {
+        if( d == 256) {
+            ad();
+            while( d!= 59) {
+                if( j) {
+                    G=G +4;
+                    *(int*) d=-G;
+                }
+                else {
+                    *(int*) d=v;
+                    v=v +4;
+                }
+                ad();
+                if( d == 44)ad()	;
+            }
+            ad();
+        }
+        else {
+            A(*(int*)(d +4));
+            *(int*) d=q;
+            ad();
+            ad();
+            m= 8;
+            while( d!= 41) {
+                *(int*) d=m;
+                m= m +4;
+                ad();
+                if( d == 44)ad();
+            }
+            ad();
+            K=G=0;
+            ae( 15042901);
+            m= s(60545,0);
+            I(0);
+            A(K);
+            ae( 50121);
+            *(int*) m= G;
+        }
+    }
+}
+
+int run(int g, int e) {
+    return (*(int(*)()) *(int*) (P + 592))(g, e);
+}
+
+int main(int g, char** e) {
+    int result;
+    Q = stdin;
+    if (g-- > 1) {
+        Q = fopen(e[1], "r");
+        if (!Q) {
+            fprintf(stderr, "otcc-ansi.c: could not open file %s\n", *(int*) e);
+            return -2;
+        }
+    }
+    D = strcpy(R = calloc(1, 99999), " int if else while break return for define main ") + 48;
+    v = calloc(1, 99999);
+    q = ac = calloc(1, 99999);
+    P = calloc(1, 99999);
+    o();
+    ad();
+    ab(0);
+    if (mprotect(ac & (~ 4095), (99999 + 4095) & (~ 4095), 7)) {
+        printf("Mprotect failed. %d\n", errno);
+        return -1;
+    }
+    fprintf(stderr, "otcc-ansi.c: About to execute compiled code:\n");
+    result = run(g, e);
+    fprintf(stderr, "atcc-ansi.c: result: %d\n", result);
+    return result;
+}
+
diff --git a/tests/data/src/otcc-noinclude.c b/tests/data/src/otcc-noinclude.c
new file mode 100644
index 0000000..530f9e2
--- /dev/null
+++ b/tests/data/src/otcc-noinclude.c
@@ -0,0 +1,446 @@
+// #include <stdio.h>
+#define k *(int*)
+#define a if(
+#define c ad()
+#define i else
+#define p while(
+#define x *(char*)
+#define b ==
+#define V =calloc(1,99999)
+#define f ()
+#define J return
+#define l ae(
+#define n e)
+#define u d!=
+#define F int 
+#define y (j)
+#define r m=
+#define t +4
+F d,z,C,h,P,K,ac,q,G,v,Q,R,D,L,W,M;
+E(n{
+x D++=e;
+}
+o f{
+a L){
+h=x L++;
+a h b 2){
+L=0;
+h=W;
+}
+}
+i h=fgetc(Q);
+}
+X f{
+J isalnum(h)|h b 95;
+}
+Y f{
+a h b 92){
+o f;
+a h b 110)h=10;
+}
+}
+c{
+F e,j,m;
+p isspace(h)|h b 35){
+a h b 35){
+o f;
+c;
+a d b 536){
+c;
+E(32);
+k d=1;
+k(d t)=D;
+}
+p h!=10){
+E(h);
+o f;
+}
+E(h);
+E(2);
+}
+o f;
+}
+C=0;
+d=h;
+a X f){
+E(32);
+M=D;
+p X f){
+E(h);
+o f;
+}
+a isdigit(d)){
+z=strtol(M,0,0);
+d=2;
+}
+i{
+x D=32;
+d=strstr(R,M-1)-R;
+x D=0;
+d=d*8+256;
+a d>536){
+d=P+d;
+a k d b 1){
+L=k(d t);
+W=h;
+o f;
+c;
+}
+}
+}
+}
+i{
+o f;
+a d b 39){
+d=2;
+Y f;
+z=h;
+o f;
+o f;
+}
+i a d b 47&h b 42){
+o f;
+p h){
+p h!=42)o f;
+o f;
+a h b 47)h=0;
+}
+o f;
+c;
+}
+i{
+e="++#m--%am*@R<^1c/@%[_[H3c%@%[_[H3c+@.B#d-@%:_^BKd<<Z/03e>>`/03e<=0f>=/f<@.f>@1f==&g!='g&&k||#l&@.BCh^@.BSi|@.B+j~@/%Yd!@&d*@b";
+p j=x e++){
+r x e++;
+z=0;
+p(C=x e++-98)<0)z=z*64+C+64;
+a j b d&(m b h|m b 64)){
+a m b h){
+o f;
+d=1;
+}
+break;
+}
+}
+}
+}
+}
+l g){
+p g&&g!=-1){
+x q++=g;
+g=g>>8;
+}
+}
+A(n{
+F g;
+p n{
+g=k e;
+k e=q-e-4;
+e=g;
+}
+}
+s(g,n{
+l g);
+k q=e;
+e=q;
+q=q t;
+J e;
+}
+H(n{
+s(184,n;
+}
+B(n{
+J s(233,n;
+}
+S(j,n{
+l 1032325);
+J s(132+j,n;
+}
+Z(n{
+l 49465);
+H(0);
+l 15);
+l e+144);
+l 192);
+}
+N(j,n{
+l j+131);
+s((e<512)<<7|5,n;
+}
+T y{
+F g,e,m,aa;
+g=1;
+a d b 34){
+H(v);
+p h!=34){
+Y f;
+x v++=h;
+o f;
+}
+x v=0;
+v=v t&-4;
+o f;
+c;
+}
+i{
+aa=C;
+r z;
+e=d;
+c;
+a e b 2){
+H(m);
+}
+i a aa b 2){
+T(0);
+s(185,0);
+a e b 33)Z(m);
+i l m);
+}
+i a e b 40){
+w f;
+c;
+}
+i a e b 42){
+c;
+e=d;
+c;
+c;
+a d b 42){
+c;
+c;
+c;
+c;
+e=0;
+}
+c;
+T(0);
+a d b 61){
+c;
+l 80);
+w f;
+l 89);
+l 392+(e b 256));
+}
+i a n{
+a e b 256)l 139);
+i l 48655);
+q++;
+}
+}
+i a e b 38){
+N(10,k d);
+c;
+}
+i{
+g=k e;
+a!g)g=dlsym(0,M);
+a d b 61&j){
+c;
+w f;
+N(6,g);
+}
+i a u 40){
+N(8,g);
+a C b 11){
+N(0,g);
+l z);
+c;
+}
+}
+}
+}
+a d b 40){
+a g b 1)l 80);
+r s(60545,0);
+c;
+j=0;
+p u 41){
+w f;
+s(2393225,j);
+a d b 44)c;
+j=j t;
+}
+k r j;
+c;
+a!g){
+e=e t;
+k e=s(232,k n;
+}
+i a g b 1){
+s(2397439,j);
+j=j t;
+}
+i{
+s(232,g-q-5);
+}
+a j)s(50305,j);
+}
+}
+O y{
+F e,g,m;
+a j--b 1)T(1);
+i{
+O y;
+r 0;
+p j b C){
+g=d;
+e=z;
+c;
+a j>8){
+r S(e,m);
+O y;
+}
+i{
+l 80);
+O y;
+l 89);
+a j b 4|j b 5){
+Z(n;
+}
+i{
+l n;
+a g b 37)l 146);
+}
+}
+}
+a m&&j>8){
+r S(e,m);
+H(e^1);
+B(5);
+A(m);
+H(n;
+}
+}
+}
+w f{
+O(11);
+}
+U f{
+w f;
+J S(0,0);
+}
+I y{
+F m,g,e;
+a d b 288){
+c;
+c;
+r U f;
+c;
+I y;
+a d b 312){
+c;
+g=B(0);
+A(m);
+I y;
+A(g);
+}
+i{
+A(m);
+}
+}
+i a d b 352|d b 504){
+e=d;
+c;
+c;
+a e b 352){
+g=q;
+r U f;
+}
+i{
+a u 59)w f;
+c;
+g=q;
+r 0;
+a u 59)r U f;
+c;
+a u 41){
+e=B(0);
+w f;
+B(g-q-5);
+A(n;
+g=e t;
+}
+}
+c;
+I(&m);
+B(g-q-5);
+A(m);
+}
+i a d b 123){
+c;
+ab(1);
+p u 125)I y;
+c;
+}
+i{
+a d b 448){
+c;
+a u 59)w f;
+K=B(K);
+}
+i a d b 400){
+c;
+k j=B(k j);
+}
+i a u 59)w f;
+c;
+}
+}
+ab y{
+F m;
+p d b 256|u-1&!j){
+a d b 256){
+c;
+p u 59){
+a j){
+G=G t;
+k d=-G;
+}
+i{
+k d=v;
+v=v t;
+}
+c;
+a d b 44)c;
+}
+c;
+}
+i{
+A(k(d t));
+k d=q;
+c;
+c;
+r 8;
+p u 41){
+k d=m;
+r m t;
+c;
+a d b 44)c;
+}
+c;
+K=G=0;
+l 15042901);
+r s(60545,0);
+I(0);
+A(K);
+l 50121);
+k r G;
+}
+}
+}
+main(g,n{
+Q=stdin;
+a g-->1){
+e=e t;
+Q=fopen(k e,"r");
+}
+D=strcpy(R V," int if else while break return for define main ")+48;
+v V;
+q=ac V;
+P V;
+o f;
+c;
+ab(0);
+J(*(int(*)f)k(P+592))(g,n;
+}
+
diff --git a/tests/data/src/pointers.c b/tests/data/src/pointers.c
new file mode 100644
index 0000000..461ebeb
--- /dev/null
+++ b/tests/data/src/pointers.c
@@ -0,0 +1,15 @@
+int main() {
+    int* pa = (int*) malloc(100);
+    int* pb = pa + 1;
+    int* pc = (int*) 0;
+    *pa = 1;
+    *pb = 2;
+    printf("Pointer difference: %d %d\n", pb - pa, ((int) pb) - ((int) pa));
+    int c = * (pa + 1);
+    printf("Pointer addition: %d\n", c);
+    printf("Pointer comparison to zero: %d %d %d\n", pa == 0, pb == 0, pc == 0);
+    printf("Pointer comparison: %d %d %d %d %d\n", pa < pb, pa == pb, pa > pb, ! pb, ! pc);
+    free(pa);
+    return 0;
+}
+
diff --git a/tests/data/src/pointers2.c b/tests/data/src/pointers2.c
new file mode 100644
index 0000000..69e402f
--- /dev/null
+++ b/tests/data/src/pointers2.c
@@ -0,0 +1,35 @@
+// Test multiple levels of indirection
+
+void testsingle() {
+    int a = 0;
+    int* pa = &a;
+    printf("a = %d, *pa = %d\n", a, *pa);
+    *pa = 2;
+    printf("a = %d, *pa = %d\n", a, *pa);
+}
+
+void testdouble() {
+    int a = 0;
+    int* pa = &a;
+    int** ppa = &pa;
+    printf("a = %d, *pa = %d **ppa = %d\n", a, *pa, **ppa);
+    **ppa = 2;
+    printf("a = %d, *pa = %d **ppa = %d\n", a, *pa, **ppa);
+}
+
+void testtripple() {
+    int a = 0;
+    int* pa = &a;
+    int** ppa = &pa;
+    int*** pppa = &ppa;
+    printf("a = %d, *pa = %d **ppa = %d\n ***pppa = %d", a, *pa, **ppa, ***pppa);
+    ***pppa = 2;
+    printf("a = %d, *pa = %d **ppa = %d\n ***pppa = %d", a, *pa, **ppa, ***pppa);
+}
+
+int main() {
+    testsingle();
+    testdouble();
+    testdouble();
+    return 0;
+}
diff --git a/tests/data/src/returnval-ansi.c b/tests/data/src/returnval-ansi.c
new file mode 100644
index 0000000..6b53fd5
--- /dev/null
+++ b/tests/data/src/returnval-ansi.c
@@ -0,0 +1,8 @@
+
+int main(int argc, char** argv) {
+  return f();
+}
+
+int f() {
+    return 42;
+}
diff --git a/tests/data/src/rollo3.c b/tests/data/src/rollo3.c
new file mode 100644
index 0000000..b21c12f
--- /dev/null
+++ b/tests/data/src/rollo3.c
@@ -0,0 +1,9 @@
+
+float fabsf(float);
+
+int main(void* con, int ft, int launchID)
+{
+   float f =  fabsf(-10.0f);
+   return f;
+}
+
diff --git a/tests/data/src/short.c b/tests/data/src/short.c
new file mode 100644
index 0000000..5e222f3
--- /dev/null
+++ b/tests/data/src/short.c
@@ -0,0 +1,6 @@
+short a = 3;
+int main() {
+    short* b = &a;
+    *b = *b - 5;
+    return a;
+}
diff --git a/tests/data/src/simplest.c b/tests/data/src/simplest.c
new file mode 100644
index 0000000..bae895a
--- /dev/null
+++ b/tests/data/src/simplest.c
@@ -0,0 +1 @@
+main() {}
diff --git a/tests/data/src/structs.c b/tests/data/src/structs.c
new file mode 100644
index 0000000..e824a3e
--- /dev/null
+++ b/tests/data/src/structs.c
@@ -0,0 +1,90 @@
+// struct definition and declaration
+struct a {
+    int a;
+    int b;
+} c;
+
+// Useful anonymous struct declaration
+struct {
+    int y;
+} anon1, anon2;
+
+// forward declarations
+struct a;
+struct b;
+struct c;
+
+struct b {int a; int b; };
+
+// struct c {b g; }; // syntax error.
+
+// struct s {float c,a,b,c;} s; // duplicate struct member
+
+struct c {struct b g; };
+
+// struct a { int w; }; // error
+
+void testCopying() {
+    struct a {int a[10]; char c;} a, b;
+    a.c = 37;
+    b.c = 38;
+    b = a;
+    printf("testCopying: %d == %d\n", a.c, b.c);
+}
+
+void testUnion() {
+    union u;
+    union u {float f;int i;} u;
+    u.f = 1.0f;
+    printf("testUnion: %g == 0x%08x\n", u.f, u.i);
+}
+
+struct v {float x, y, z, w; };
+
+void add(struct v* result, struct v* a, struct v* b) {
+    result->x = a->x + b->x;
+    result->y = a->y + b->y;
+    result->z = a->z + b->z;
+    result->w = a->w + b->w;
+}
+
+void set(struct v* v, float x, float y, float z, float w) {
+    v->x = x;
+    v->y = y;
+    v->z = z;
+    v->w = w;
+}
+
+void print(struct v* v) {
+    printf("(%g, %g, %g, %g)\n", v->x, v->y, v->z, v->w);
+}
+
+void testArgs() {
+    struct v a, b, c;
+    set(&a, 1.0f, 2.0f, 3.0f, 4.0f);
+    set(&b, 5.0f, 6.0f, 7.0f, 8.0f);
+    add(&c, &a, &b);
+    printf("testArgs: ");
+    print(&c);
+}
+
+int main() {
+    anon1.y = 3;
+    anon2.y = anon1.y;
+
+    testCopying();
+    testUnion();
+    testArgs();
+
+    struct c cc;
+    cc.g.a = 3;
+    c.a = 1;
+    c.b = 3;
+    struct a {int x, y; } z;
+    // struct a {int x, y; } z2;
+    z.x = c.a;
+    struct a *pA;
+    pA = &z;
+    pA->x += 5;
+    return pA->x;
+}
diff --git a/tests/data/src/testStringConcat.c b/tests/data/src/testStringConcat.c
new file mode 100644
index 0000000..bf06ae1
--- /dev/null
+++ b/tests/data/src/testStringConcat.c
@@ -0,0 +1,4 @@
+int main() {
+    return printf("Hello" "," " world\n");
+}
+
diff --git a/tests/data/structs.bc b/tests/data/structs.bc
new file mode 100644
index 0000000..1534ee2
--- /dev/null
+++ b/tests/data/structs.bc
Binary files differ
diff --git a/tests/data/testStringConcat.bc b/tests/data/testStringConcat.bc
new file mode 100644
index 0000000..73385b1
--- /dev/null
+++ b/tests/data/testStringConcat.bc
Binary files differ
diff --git a/tests/disassem.cpp b/tests/disassem.cpp
new file mode 100644
index 0000000..ac35342
--- /dev/null
+++ b/tests/disassem.cpp
@@ -0,0 +1,711 @@
+/*	$NetBSD: disassem.c,v 1.14 2003/03/27 16:58:36 mycroft Exp $	*/
+
+/*-
+ * Copyright (c) 1996 Mark Brinicombe.
+ * Copyright (c) 1996 Brini.
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. 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.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by Brini.
+ * 4. The name of the company nor the name of the author may be used to
+ *    endorse or promote products derived from this software without specific
+ *    prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY BRINI ``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 BRINI 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.
+ *
+ * RiscBSD kernel project
+ *
+ * db_disasm.c
+ *
+ * Kernel disassembler
+ *
+ * Created      : 10/02/96
+ *
+ * Structured after the sparc/sparc/db_disasm.c by David S. Miller &
+ * Paul Kranenburg
+ *
+ * This code is not complete. Not all instructions are disassembled.
+ */
+
+#include <sys/cdefs.h>
+//__FBSDID("$FreeBSD: /repoman/r/ncvs/src/sys/arm/arm/disassem.c,v 1.2 2005/01/05 21:58:47 imp Exp $");
+#include <sys/param.h>
+#include <stdio.h>
+#include <stdarg.h>
+
+#include "disassem.h"
+#include "armreg.h"
+//#include <ddb/ddb.h>
+
+/*
+ * General instruction format
+ *
+ *	insn[cc][mod]	[operands]
+ *
+ * Those fields with an uppercase format code indicate that the field
+ * follows directly after the instruction before the separator i.e.
+ * they modify the instruction rather than just being an operand to
+ * the instruction. The only exception is the writeback flag which
+ * follows a operand.
+ *
+ *
+ * 2 - print Operand 2 of a data processing instruction
+ * d - destination register (bits 12-15)
+ * n - n register (bits 16-19)
+ * s - s register (bits 8-11)
+ * o - indirect register rn (bits 16-19) (used by swap)
+ * m - m register (bits 0-3)
+ * a - address operand of ldr/str instruction
+ * e - address operand of ldrh/strh instruction
+ * l - register list for ldm/stm instruction
+ * f - 1st fp operand (register) (bits 12-14)
+ * g - 2nd fp operand (register) (bits 16-18)
+ * h - 3rd fp operand (register/immediate) (bits 0-4)
+ * b - branch address
+ * t - thumb branch address (bits 24, 0-23)
+ * k - breakpoint comment (bits 0-3, 8-19)
+ * X - block transfer type
+ * Y - block transfer type (r13 base)
+ * c - comment field bits(0-23)
+ * p - saved or current status register
+ * F - PSR transfer fields
+ * D - destination-is-r15 (P) flag on TST, TEQ, CMP, CMN
+ * L - co-processor transfer size
+ * S - set status flag
+ * P - fp precision
+ * Q - fp precision (for ldf/stf)
+ * R - fp rounding
+ * v - co-processor data transfer registers + addressing mode
+ * W - writeback flag
+ * x - instruction in hex
+ * # - co-processor number
+ * y - co-processor data processing registers
+ * z - co-processor register transfer registers
+ */
+
+struct arm32_insn {
+	u_int mask;
+	u_int pattern;
+	const char* name;
+	const char* format;
+};
+
+static const struct arm32_insn arm32_i[] = {
+    { 0x0fffffff, 0x0ff00000, "imb",	"c" },		/* Before swi */
+    { 0x0fffffff, 0x0ff00001, "imbrange",	"c" },	/* Before swi */
+    { 0x0f000000, 0x0f000000, "swi",	"c" },
+    { 0xfe000000, 0xfa000000, "blx",	"t" },		/* Before b and bl */
+    { 0x0f000000, 0x0a000000, "b",	"b" },
+    { 0x0f000000, 0x0b000000, "bl",	"b" },
+    { 0x0fe000f0, 0x00000090, "mul",	"Snms" },
+    { 0x0fe000f0, 0x00200090, "mla",	"Snmsd" },
+    { 0x0fe000f0, 0x00800090, "umull",	"Sdnms" },
+    { 0x0fe000f0, 0x00c00090, "smull",	"Sdnms" },
+    { 0x0fe000f0, 0x00a00090, "umlal",	"Sdnms" },
+    { 0x0fe000f0, 0x00e00090, "smlal",	"Sdnms" },
+    { 0x0d700000, 0x04200000, "strt",	"daW" },
+    { 0x0d700000, 0x04300000, "ldrt",	"daW" },
+    { 0x0d700000, 0x04600000, "strbt",	"daW" },
+    { 0x0d700000, 0x04700000, "ldrbt",	"daW" },
+    { 0x0c500000, 0x04000000, "str",	"daW" },
+    { 0x0c500000, 0x04100000, "ldr",	"daW" },
+    { 0x0c500000, 0x04400000, "strb",	"daW" },
+    { 0x0c500000, 0x04500000, "ldrb",	"daW" },
+    { 0x0e1f0000, 0x080d0000, "stm",	"YnWl" },/* separate out r13 base */
+    { 0x0e1f0000, 0x081d0000, "ldm",	"YnWl" },/* separate out r13 base */    
+    { 0x0e100000, 0x08000000, "stm",	"XnWl" },
+    { 0x0e100000, 0x08100000, "ldm",	"XnWl" },    
+    { 0x0e1000f0, 0x00100090, "ldrb",	"deW" },
+    { 0x0e1000f0, 0x00000090, "strb",	"deW" },
+    { 0x0e1000f0, 0x001000d0, "ldrsb",	"deW" },
+    { 0x0e1000f0, 0x001000b0, "ldrh",	"deW" },
+    { 0x0e1000f0, 0x000000b0, "strh",	"deW" },
+    { 0x0e1000f0, 0x001000f0, "ldrsh",	"deW" },
+    { 0x0f200090, 0x00200090, "und",	"x" },	/* Before data processing */
+    { 0x0e1000d0, 0x000000d0, "und",	"x" },	/* Before data processing */
+    { 0x0ff00ff0, 0x01000090, "swp",	"dmo" },
+    { 0x0ff00ff0, 0x01400090, "swpb",	"dmo" },
+    { 0x0fbf0fff, 0x010f0000, "mrs",	"dp" },	/* Before data processing */
+    { 0x0fb0fff0, 0x0120f000, "msr",	"pFm" },/* Before data processing */
+    { 0x0fb0f000, 0x0320f000, "msr",	"pF2" },/* Before data processing */
+    { 0x0ffffff0, 0x012fff10, "bx",     "m" },
+    { 0x0fff0ff0, 0x016f0f10, "clz",	"dm" },
+    { 0x0ffffff0, 0x012fff30, "blx",	"m" },
+    { 0xfff000f0, 0xe1200070, "bkpt",	"k" },
+    { 0x0de00000, 0x00000000, "and",	"Sdn2" },
+    { 0x0de00000, 0x00200000, "eor",	"Sdn2" },
+    { 0x0de00000, 0x00400000, "sub",	"Sdn2" },
+    { 0x0de00000, 0x00600000, "rsb",	"Sdn2" },
+    { 0x0de00000, 0x00800000, "add",	"Sdn2" },
+    { 0x0de00000, 0x00a00000, "adc",	"Sdn2" },
+    { 0x0de00000, 0x00c00000, "sbc",	"Sdn2" },
+    { 0x0de00000, 0x00e00000, "rsc",	"Sdn2" },
+    { 0x0df00000, 0x01100000, "tst",	"Dn2" },
+    { 0x0df00000, 0x01300000, "teq",	"Dn2" },
+    { 0x0df00000, 0x01500000, "cmp",	"Dn2" },
+    { 0x0df00000, 0x01700000, "cmn",	"Dn2" },
+    { 0x0de00000, 0x01800000, "orr",	"Sdn2" },
+    { 0x0de00000, 0x01a00000, "mov",	"Sd2" },
+    { 0x0de00000, 0x01c00000, "bic",	"Sdn2" },
+    { 0x0de00000, 0x01e00000, "mvn",	"Sd2" },
+    { 0x0ff08f10, 0x0e000100, "adf",	"PRfgh" },
+    { 0x0ff08f10, 0x0e100100, "muf",	"PRfgh" },
+    { 0x0ff08f10, 0x0e200100, "suf",	"PRfgh" },
+    { 0x0ff08f10, 0x0e300100, "rsf",	"PRfgh" },
+    { 0x0ff08f10, 0x0e400100, "dvf",	"PRfgh" },
+    { 0x0ff08f10, 0x0e500100, "rdf",	"PRfgh" },
+    { 0x0ff08f10, 0x0e600100, "pow",	"PRfgh" },
+    { 0x0ff08f10, 0x0e700100, "rpw",	"PRfgh" },
+    { 0x0ff08f10, 0x0e800100, "rmf",	"PRfgh" },
+    { 0x0ff08f10, 0x0e900100, "fml",	"PRfgh" },
+    { 0x0ff08f10, 0x0ea00100, "fdv",	"PRfgh" },
+    { 0x0ff08f10, 0x0eb00100, "frd",	"PRfgh" },
+    { 0x0ff08f10, 0x0ec00100, "pol",	"PRfgh" },
+    { 0x0f008f10, 0x0e000100, "fpbop",	"PRfgh" },
+    { 0x0ff08f10, 0x0e008100, "mvf",	"PRfh" },
+    { 0x0ff08f10, 0x0e108100, "mnf",	"PRfh" },
+    { 0x0ff08f10, 0x0e208100, "abs",	"PRfh" },
+    { 0x0ff08f10, 0x0e308100, "rnd",	"PRfh" },
+    { 0x0ff08f10, 0x0e408100, "sqt",	"PRfh" },
+    { 0x0ff08f10, 0x0e508100, "log",	"PRfh" },
+    { 0x0ff08f10, 0x0e608100, "lgn",	"PRfh" },
+    { 0x0ff08f10, 0x0e708100, "exp",	"PRfh" },
+    { 0x0ff08f10, 0x0e808100, "sin",	"PRfh" },
+    { 0x0ff08f10, 0x0e908100, "cos",	"PRfh" },
+    { 0x0ff08f10, 0x0ea08100, "tan",	"PRfh" },
+    { 0x0ff08f10, 0x0eb08100, "asn",	"PRfh" },
+    { 0x0ff08f10, 0x0ec08100, "acs",	"PRfh" },
+    { 0x0ff08f10, 0x0ed08100, "atn",	"PRfh" },
+    { 0x0f008f10, 0x0e008100, "fpuop",	"PRfh" },
+    { 0x0e100f00, 0x0c000100, "stf",	"QLv" },
+    { 0x0e100f00, 0x0c100100, "ldf",	"QLv" },
+    { 0x0ff00f10, 0x0e000110, "flt",	"PRgd" },
+    { 0x0ff00f10, 0x0e100110, "fix",	"PRdh" },
+    { 0x0ff00f10, 0x0e200110, "wfs",	"d" },
+    { 0x0ff00f10, 0x0e300110, "rfs",	"d" },
+    { 0x0ff00f10, 0x0e400110, "wfc",	"d" },
+    { 0x0ff00f10, 0x0e500110, "rfc",	"d" },
+    { 0x0ff0ff10, 0x0e90f110, "cmf",	"PRgh" },
+    { 0x0ff0ff10, 0x0eb0f110, "cnf",	"PRgh" },
+    { 0x0ff0ff10, 0x0ed0f110, "cmfe",	"PRgh" },
+    { 0x0ff0ff10, 0x0ef0f110, "cnfe",	"PRgh" },
+    { 0xff100010, 0xfe000010, "mcr2",	"#z" },
+    { 0x0f100010, 0x0e000010, "mcr",	"#z" },
+    { 0xff100010, 0xfe100010, "mrc2",	"#z" },
+    { 0x0f100010, 0x0e100010, "mrc",	"#z" },
+    { 0xff000010, 0xfe000000, "cdp2",	"#y" },
+    { 0x0f000010, 0x0e000000, "cdp",	"#y" },
+    { 0xfe100090, 0xfc100000, "ldc2",	"L#v" },
+    { 0x0e100090, 0x0c100000, "ldc",	"L#v" },
+    { 0xfe100090, 0xfc000000, "stc2",	"L#v" },
+    { 0x0e100090, 0x0c000000, "stc",	"L#v" },
+    { 0xf550f000, 0xf550f000, "pld",	"ne" },
+    { 0x0ff00ff0, 0x01000050, "qaad",	"dmn" },
+    { 0x0ff00ff0, 0x01400050, "qdaad",	"dmn" },
+    { 0x0ff00ff0, 0x01600050, "qdsub",	"dmn" },
+    { 0x0ff00ff0, 0x01200050, "dsub",	"dmn" },
+    { 0x0ff000f0, 0x01000080, "smlabb",	"nmsd" },   // d & n inverted!!
+    { 0x0ff000f0, 0x010000a0, "smlatb",	"nmsd" },   // d & n inverted!!
+    { 0x0ff000f0, 0x010000c0, "smlabt",	"nmsd" },   // d & n inverted!!
+    { 0x0ff000f0, 0x010000e0, "smlatt",	"nmsd" },   // d & n inverted!!
+    { 0x0ff000f0, 0x01400080, "smlalbb","ndms" },   // d & n inverted!!
+    { 0x0ff000f0, 0x014000a0, "smlaltb","ndms" },   // d & n inverted!!
+    { 0x0ff000f0, 0x014000c0, "smlalbt","ndms" },   // d & n inverted!!
+    { 0x0ff000f0, 0x014000e0, "smlaltt","ndms" },   // d & n inverted!!
+    { 0x0ff000f0, 0x01200080, "smlawb", "nmsd" },   // d & n inverted!!
+    { 0x0ff0f0f0, 0x012000a0, "smulwb","nms" },   // d & n inverted!!
+    { 0x0ff000f0, 0x012000c0, "smlawt", "nmsd" },   // d & n inverted!!
+    { 0x0ff0f0f0, 0x012000e0, "smulwt","nms" },   // d & n inverted!!
+    { 0x0ff0f0f0, 0x01600080, "smulbb","nms" },   // d & n inverted!!
+    { 0x0ff0f0f0, 0x016000a0, "smultb","nms" },   // d & n inverted!!
+    { 0x0ff0f0f0, 0x016000c0, "smulbt","nms" },   // d & n inverted!!
+    { 0x0ff0f0f0, 0x016000e0, "smultt","nms" },   // d & n inverted!!
+    { 0x00000000, 0x00000000, NULL,	NULL }
+};
+
+static char const arm32_insn_conditions[][4] = {
+	"eq", "ne", "cs", "cc",
+	"mi", "pl", "vs", "vc",
+	"hi", "ls", "ge", "lt",
+	"gt", "le", "",   "nv"
+};
+
+static char const insn_block_transfers[][4] = {
+	"da", "ia", "db", "ib"
+};
+
+static char const insn_stack_block_transfers[][4] = {
+	"ed", "ea", "fd", "fa"
+};
+
+static char const op_shifts[][4] = {
+	"lsl", "lsr", "asr", "ror"
+};
+
+static char const insn_fpa_rounding[][2] = {
+	"", "p", "m", "z"
+};
+
+static char const insn_fpa_precision[][2] = {
+	"s", "d", "e", "p"
+};
+
+static char const insn_fpaconstants[][8] = {
+	"0.0", "1.0", "2.0", "3.0",
+	"4.0", "5.0", "0.5", "10.0"
+};
+
+#define insn_condition(x)	arm32_insn_conditions[(x >> 28) & 0x0f]
+#define insn_blktrans(x)	insn_block_transfers[(x >> 23) & 3]
+#define insn_stkblktrans(x)	insn_stack_block_transfers[(x >> 23) & 3]
+#define op2_shift(x)		op_shifts[(x >> 5) & 3]
+#define insn_fparnd(x)		insn_fpa_rounding[(x >> 5) & 0x03]
+#define insn_fpaprec(x)		insn_fpa_precision[(((x >> 18) & 2)|(x >> 7)) & 1]
+#define insn_fpaprect(x)	insn_fpa_precision[(((x >> 21) & 2)|(x >> 15)) & 1]
+#define insn_fpaimm(x)		insn_fpaconstants[x & 0x07]
+
+/* Local prototypes */
+static void disasm_register_shift(const disasm_interface_t *di, u_int insn);
+static void disasm_print_reglist(const disasm_interface_t *di, u_int insn);
+static void disasm_insn_ldrstr(const disasm_interface_t *di, u_int insn,
+    u_int loc);
+static void disasm_insn_ldrhstrh(const disasm_interface_t *di, u_int insn,
+    u_int loc);
+static void disasm_insn_ldcstc(const disasm_interface_t *di, u_int insn,
+    u_int loc);
+static u_int disassemble_readword(u_int address);
+static void disassemble_printaddr(u_int address);
+
+u_int
+disasm(const disasm_interface_t *di, u_int loc, int altfmt)
+{
+	const struct arm32_insn *i_ptr = &arm32_i[0];
+
+	u_int insn;
+	int matchp;
+	int branch;
+	const char* f_ptr;
+	int fmt;
+
+	fmt = 0;
+	matchp = 0;
+	insn = di->di_readword(loc);
+
+/*	di->di_printf("loc=%08x insn=%08x : ", loc, insn);*/
+
+	while (i_ptr->name) {
+		if ((insn & i_ptr->mask) ==  i_ptr->pattern) {
+			matchp = 1;
+			break;
+		}
+		i_ptr++;
+	}
+
+	if (!matchp) {
+		di->di_printf("und%s\t%08x\n", insn_condition(insn), insn);
+		return(loc + INSN_SIZE);
+	}
+
+	/* If instruction forces condition code, don't print it. */
+	if ((i_ptr->mask & 0xf0000000) == 0xf0000000)
+		di->di_printf("%s", i_ptr->name);
+	else
+		di->di_printf("%s%s", i_ptr->name, insn_condition(insn));
+
+	f_ptr = i_ptr->format;
+
+	/* Insert tab if there are no instruction modifiers */
+
+	if (*(f_ptr) < 'A' || *(f_ptr) > 'Z') {
+		++fmt;
+		di->di_printf("\t");
+	}
+
+	while (*f_ptr) {
+		switch (*f_ptr) {
+		/* 2 - print Operand 2 of a data processing instruction */
+		case '2':
+			if (insn & 0x02000000) {
+				int rotate= ((insn >> 7) & 0x1e);
+
+				di->di_printf("#0x%08x",
+					      (insn & 0xff) << (32 - rotate) |
+					      (insn & 0xff) >> rotate);
+			} else {  
+				disasm_register_shift(di, insn);
+			}
+			break;
+		/* d - destination register (bits 12-15) */
+		case 'd':
+			di->di_printf("r%d", ((insn >> 12) & 0x0f));
+			break;
+		/* D - insert 'p' if Rd is R15 */
+		case 'D':
+			if (((insn >> 12) & 0x0f) == 15)
+				di->di_printf("p");
+			break;
+		/* n - n register (bits 16-19) */
+		case 'n':
+			di->di_printf("r%d", ((insn >> 16) & 0x0f));
+			break;
+		/* s - s register (bits 8-11) */
+		case 's':
+			di->di_printf("r%d", ((insn >> 8) & 0x0f));
+			break;
+		/* o - indirect register rn (bits 16-19) (used by swap) */
+		case 'o':
+			di->di_printf("[r%d]", ((insn >> 16) & 0x0f));
+			break;
+		/* m - m register (bits 0-4) */
+		case 'm':
+			di->di_printf("r%d", ((insn >> 0) & 0x0f));
+			break;
+		/* a - address operand of ldr/str instruction */
+		case 'a':
+			disasm_insn_ldrstr(di, insn, loc);
+			break;
+		/* e - address operand of ldrh/strh instruction */
+		case 'e':
+			disasm_insn_ldrhstrh(di, insn, loc);
+			break;
+		/* l - register list for ldm/stm instruction */
+		case 'l':
+			disasm_print_reglist(di, insn);
+			break;
+		/* f - 1st fp operand (register) (bits 12-14) */
+		case 'f':
+			di->di_printf("f%d", (insn >> 12) & 7);
+			break;
+		/* g - 2nd fp operand (register) (bits 16-18) */
+		case 'g':
+			di->di_printf("f%d", (insn >> 16) & 7);
+			break;
+		/* h - 3rd fp operand (register/immediate) (bits 0-4) */
+		case 'h':
+			if (insn & (1 << 3))
+				di->di_printf("#%s", insn_fpaimm(insn));
+			else
+				di->di_printf("f%d", insn & 7);
+			break;
+		/* b - branch address */
+		case 'b':
+			branch = ((insn << 2) & 0x03ffffff);
+			if (branch & 0x02000000)
+				branch |= 0xfc000000;
+			di->di_printaddr(loc + 8 + branch);
+			break;
+		/* t - blx address */
+		case 't':
+			branch = ((insn << 2) & 0x03ffffff) |
+			    (insn >> 23 & 0x00000002);
+			if (branch & 0x02000000)
+				branch |= 0xfc000000;
+			di->di_printaddr(loc + 8 + branch);
+			break;
+		/* X - block transfer type */
+		case 'X':
+			di->di_printf("%s", insn_blktrans(insn));
+			break;
+		/* Y - block transfer type (r13 base) */
+		case 'Y':
+			di->di_printf("%s", insn_stkblktrans(insn));
+			break;
+		/* c - comment field bits(0-23) */
+		case 'c':
+			di->di_printf("0x%08x", (insn & 0x00ffffff));
+			break;
+		/* k - breakpoint comment (bits 0-3, 8-19) */
+		case 'k':
+			di->di_printf("0x%04x",
+			    (insn & 0x000fff00) >> 4 | (insn & 0x0000000f));
+			break;
+		/* p - saved or current status register */
+		case 'p':
+			if (insn & 0x00400000)
+				di->di_printf("spsr");
+			else
+				di->di_printf("cpsr");
+			break;
+		/* F - PSR transfer fields */
+		case 'F':
+			di->di_printf("_");
+			if (insn & (1 << 16))
+				di->di_printf("c");
+			if (insn & (1 << 17))
+				di->di_printf("x");
+			if (insn & (1 << 18))
+				di->di_printf("s");
+			if (insn & (1 << 19))
+				di->di_printf("f");
+			break;
+		/* B - byte transfer flag */
+		case 'B':
+			if (insn & 0x00400000)
+				di->di_printf("b");
+			break;
+		/* L - co-processor transfer size */
+		case 'L':
+			if (insn & (1 << 22))
+				di->di_printf("l");
+			break;
+		/* S - set status flag */
+		case 'S':
+			if (insn & 0x00100000)
+				di->di_printf("s");
+			break;
+		/* P - fp precision */
+		case 'P':
+			di->di_printf("%s", insn_fpaprec(insn));
+			break;
+		/* Q - fp precision (for ldf/stf) */
+		case 'Q':
+			break;
+		/* R - fp rounding */
+		case 'R':
+			di->di_printf("%s", insn_fparnd(insn));
+			break;
+		/* W - writeback flag */
+		case 'W':
+			if (insn & (1 << 21))
+				di->di_printf("!");
+			break;
+		/* # - co-processor number */
+		case '#':
+			di->di_printf("p%d", (insn >> 8) & 0x0f);
+			break;
+		/* v - co-processor data transfer registers+addressing mode */
+		case 'v':
+			disasm_insn_ldcstc(di, insn, loc);
+			break;
+		/* x - instruction in hex */
+		case 'x':
+			di->di_printf("0x%08x", insn);
+			break;
+		/* y - co-processor data processing registers */
+		case 'y':
+			di->di_printf("%d, ", (insn >> 20) & 0x0f);
+
+			di->di_printf("c%d, c%d, c%d", (insn >> 12) & 0x0f,
+			    (insn >> 16) & 0x0f, insn & 0x0f);
+
+			di->di_printf(", %d", (insn >> 5) & 0x07);
+			break;
+		/* z - co-processor register transfer registers */
+		case 'z':
+			di->di_printf("%d, ", (insn >> 21) & 0x07);
+			di->di_printf("r%d, c%d, c%d, %d",
+			    (insn >> 12) & 0x0f, (insn >> 16) & 0x0f,
+			    insn & 0x0f, (insn >> 5) & 0x07);
+
+/*			if (((insn >> 5) & 0x07) != 0)
+				di->di_printf(", %d", (insn >> 5) & 0x07);*/
+			break;
+		default:
+			di->di_printf("[%c - unknown]", *f_ptr);
+			break;
+		}
+		if (*(f_ptr+1) >= 'A' && *(f_ptr+1) <= 'Z')
+			++f_ptr;
+		else if (*(++f_ptr)) {
+			++fmt;
+			if (fmt == 1)
+				di->di_printf("\t");
+			else
+				di->di_printf(", ");
+		}
+	};
+
+	di->di_printf("\n");
+
+	return(loc + INSN_SIZE);
+}
+
+
+static void
+disasm_register_shift(const disasm_interface_t *di, u_int insn)
+{
+	di->di_printf("r%d", (insn & 0x0f));
+	if ((insn & 0x00000ff0) == 0)
+		;
+	else if ((insn & 0x00000ff0) == 0x00000060)
+		di->di_printf(", rrx");
+	else {
+		if (insn & 0x10)
+			di->di_printf(", %s r%d", op2_shift(insn),
+			    (insn >> 8) & 0x0f);
+		else
+			di->di_printf(", %s #%d", op2_shift(insn),
+			    (insn >> 7) & 0x1f);
+	}
+}
+
+
+static void
+disasm_print_reglist(const disasm_interface_t *di, u_int insn)
+{
+	int loop;
+	int start;
+	int comma;
+
+	di->di_printf("{");
+	start = -1;
+	comma = 0;
+
+	for (loop = 0; loop < 17; ++loop) {
+		if (start != -1) {
+			if (loop == 16 || !(insn & (1 << loop))) {
+				if (comma)
+					di->di_printf(", ");
+				else
+					comma = 1;
+        			if (start == loop - 1)
+        				di->di_printf("r%d", start);
+        			else
+        				di->di_printf("r%d-r%d", start, loop - 1);
+        			start = -1;
+        		}
+        	} else {
+        		if (insn & (1 << loop))
+        			start = loop;
+        	}
+        }
+	di->di_printf("}");
+
+	if (insn & (1 << 22))
+		di->di_printf("^");
+}
+
+static void
+disasm_insn_ldrstr(const disasm_interface_t *di, u_int insn, u_int loc)
+{
+	int offset;
+
+	offset = insn & 0xfff;
+	if ((insn & 0x032f0000) == 0x010f0000) {
+		/* rA = pc, immediate index */
+		if (insn & 0x00800000)
+			loc += offset;
+		else
+			loc -= offset;
+		di->di_printaddr(loc + 8);
+ 	} else {
+		di->di_printf("[r%d", (insn >> 16) & 0x0f);
+		if ((insn & 0x03000fff) != 0x01000000) {
+			di->di_printf("%s, ", (insn & (1 << 24)) ? "" : "]");
+			if (!(insn & 0x00800000))
+				di->di_printf("-");
+			if (insn & (1 << 25))
+				disasm_register_shift(di, insn);
+			else
+				di->di_printf("#0x%03x", offset);
+		}
+		if (insn & (1 << 24))
+			di->di_printf("]");
+	}
+}
+
+static void
+disasm_insn_ldrhstrh(const disasm_interface_t *di, u_int insn, u_int loc)
+{
+	int offset;
+
+	offset = ((insn & 0xf00) >> 4) | (insn & 0xf);
+	if ((insn & 0x004f0000) == 0x004f0000) {
+		/* rA = pc, immediate index */
+		if (insn & 0x00800000)
+			loc += offset;
+		else
+			loc -= offset;
+		di->di_printaddr(loc + 8);
+ 	} else {
+		di->di_printf("[r%d", (insn >> 16) & 0x0f);
+		if ((insn & 0x01400f0f) != 0x01400000) {
+			di->di_printf("%s, ", (insn & (1 << 24)) ? "" : "]");
+			if (!(insn & 0x00800000))
+				di->di_printf("-");
+			if (insn & (1 << 22))
+				di->di_printf("#0x%02x", offset);
+			else
+				di->di_printf("r%d", (insn & 0x0f));
+		}
+		if (insn & (1 << 24))
+			di->di_printf("]");
+	}
+}
+
+static void
+disasm_insn_ldcstc(const disasm_interface_t *di, u_int insn, u_int loc)
+{
+	if (((insn >> 8) & 0xf) == 1)
+		di->di_printf("f%d, ", (insn >> 12) & 0x07);
+	else
+		di->di_printf("c%d, ", (insn >> 12) & 0x0f);
+
+	di->di_printf("[r%d", (insn >> 16) & 0x0f);
+
+	di->di_printf("%s, ", (insn & (1 << 24)) ? "" : "]");
+
+	if (!(insn & (1 << 23)))
+		di->di_printf("-");
+
+	di->di_printf("#0x%03x", (insn & 0xff) << 2);
+
+	if (insn & (1 << 24))
+		di->di_printf("]");
+
+	if (insn & (1 << 21))
+		di->di_printf("!");
+}
+
+static u_int
+disassemble_readword(u_int address)
+{
+	return(*((u_int *)address));
+}
+
+static void
+disassemble_printaddr(u_int address)
+{
+	printf("0x%08x", address);
+}
+
+static void
+disassemble_printf(const char *fmt, ...) {
+	va_list ap;
+	va_start(ap, fmt);
+	vprintf(fmt, ap);
+	va_end(ap);
+}
+
+static const disasm_interface_t disassemble_di = {
+	disassemble_readword, disassemble_printaddr, disassemble_printf
+};
+
+void
+disassemble(u_int address)
+{
+
+	(void)disasm(&disassemble_di, address, 0);
+}
+
+/* End of disassem.c */
diff --git a/tests/disassem.h b/tests/disassem.h
new file mode 100644
index 0000000..02747cd
--- /dev/null
+++ b/tests/disassem.h
@@ -0,0 +1,65 @@
+/*	$NetBSD: disassem.h,v 1.4 2001/03/04 04:15:58 matt Exp $	*/
+
+/*-
+ * Copyright (c) 1997 Mark Brinicombe.
+ * Copyright (c) 1997 Causality Limited.
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. 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.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by Mark Brinicombe.
+ * 4. The name of the company nor the name of the author may be used to
+ *    endorse or promote products derived from this software without specific
+ *    prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+ *
+ * Define the interface structure required by the disassembler.
+ *
+ * $FreeBSD: /repoman/r/ncvs/src/sys/arm/include/disassem.h,v 1.2 2005/01/05 21:58:48 imp Exp $
+ */
+
+#ifndef ANDROID_MACHINE_DISASSEM_H
+#define ANDROID_MACHINE_DISASSEM_H
+
+#include <sys/types.h>
+
+#if __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+	u_int	(*di_readword)(u_int);
+	void	(*di_printaddr)(u_int);	
+	void	(*di_printf)(const char *, ...);
+} disasm_interface_t;
+
+/* Prototypes for callable functions */
+
+u_int disasm(const disasm_interface_t *, u_int, int);
+void disassemble(u_int);
+
+#if __cplusplus
+}
+#endif
+
+#endif /* !ANDROID_MACHINE_DISASSEM_H */
diff --git a/tests/main.cpp b/tests/main.cpp
new file mode 100644
index 0000000..9235169
--- /dev/null
+++ b/tests/main.cpp
@@ -0,0 +1,338 @@
+#include <ctype.h>
+#include <dlfcn.h>
+#include <stdarg.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <getopt.h>
+
+#if defined(__arm__)
+#include <unistd.h>
+#endif
+
+#if defined(__arm__)
+#define PROVIDE_ARM_DISASSEMBLY
+#endif
+
+#ifdef PROVIDE_ARM_DISASSEMBLY
+#include "disassem.h"
+#endif
+
+#include <bcc/bcc.h>
+
+typedef int (*MainPtr)(int, char**);
+// This is a separate function so it can easily be set by breakpoint in gdb.
+static int run(MainPtr mainFunc, int argc, char** argv)
+{
+  return mainFunc(argc, argv);
+}
+
+static BCCvoid* symbolLookup(BCCvoid* pContext, const BCCchar* name)
+{
+  return (BCCvoid*) dlsym(RTLD_DEFAULT, name);
+}
+
+#ifdef PROVIDE_ARM_DISASSEMBLY
+
+static FILE* disasmOut;
+
+static u_int
+disassemble_readword(u_int address)
+{
+  return(*((u_int *)address));
+}
+
+static void
+disassemble_printaddr(u_int address)
+{
+  fprintf(disasmOut, "0x%08x", address);
+}
+
+static void
+disassemble_printf(const char *fmt, ...) {
+  va_list ap;
+  va_start(ap, fmt);
+  vfprintf(disasmOut, fmt, ap);
+  va_end(ap);
+}
+
+static int disassemble(BCCscript* script, FILE* out) {
+  disasmOut = out;
+  disasm_interface_t  di;
+  di.di_readword = disassemble_readword;
+  di.di_printaddr = disassemble_printaddr;
+  di.di_printf = disassemble_printf;
+
+  BCCvoid* base;
+  BCCsizei length;
+
+  BCCsizei numFunctions;
+  bccGetFunctions(script, &numFunctions, 0, NULL);
+  if (numFunctions) {
+    char** labels = new char*[numFunctions];
+    bccGetFunctions(script, NULL, numFunctions, labels);
+
+    for(BCCsizei i = 0; i < numFunctions; i++) {
+      bccGetFunctionBinary(script, labels[i], &base, &length);
+
+      unsigned long* pBase = (unsigned long*) base;
+      unsigned long* pEnd = (unsigned long*) (((unsigned char*) base) + length);
+
+      for(unsigned long* pInstruction = pBase; pInstruction < pEnd; pInstruction++) {
+        fprintf(out, "%08x: %08x  ", (int) pInstruction, (int) *pInstruction);
+        ::disasm(&di, (uint) pInstruction, 0);
+      }
+    }
+    delete[] labels;
+  }
+
+  return 1;
+}
+#else
+static int disassemble(BCCscript* script, FILE* out) {
+  return 1;
+}
+#endif // PROVIDE_ARM_DISASSEMBLY
+
+static int reflection(BCCscript* script, FILE* out) {
+#if 0
+  moduleHandle m = bccGetModuleHandle(script);
+
+  fprintf(out, "#types = %d\n", bccGetNumTypes(m));
+
+  for (int i = 0; i < bccGetNumTypes(m); i++) {
+    typeHandle h = bccGetTypeHandleOf(m, i);
+
+    const char *str = bccGetTypeName(m, h);
+    fprintf(out, "Type #%d:\n -Name: %s\n", i, str);
+
+    // Double-check using bccGetTypeHandle
+    if (h != bccGetTypeHandle(m, str)) {
+      fprintf(out, "typeHandle <-> nameHandle not 1:1\n");
+    }
+
+    fprintf(out, " -Structural: %s\n", bccGetTypeStruct(h));
+
+    fprintf(out, " -FieldNames: %s\n",
+            bccGetTypeFieldNames(m, h));
+
+    unsigned j = bccGetNumFields(h);
+    fprintf(out, " -#fields: %d\n", j);
+
+    if (j > 1) {
+      unsigned k;
+      for (k = 0; k < j; k++) {
+        typeHandle f = bccGetFieldType(h, k);
+        fprintf(out, "  Field #%d:\n   -Structural: %s\n   -Name: %s\n",
+                k,
+                bccGetTypeStruct(f),
+                bccGetFieldName(m, h, k));
+
+        fprintf(out, "   -Size: %d\n   -Offst: %d\n",
+                bccGetFieldSizeInBits(m, h, k),
+                bccGetFieldOffsetInBits(m, h, k));
+      }
+    }
+  }
+
+  bccDeleteModuleHandle(m);
+#endif
+
+  return 1;
+}
+
+const char* inFile = NULL;
+bool printTypeInformation = false;
+bool printListing = false;
+bool runResults = false;
+
+extern int opterr;
+extern int optind;
+
+static int parseOption(int argc, char** argv)
+{
+  int c;
+  while ((c = getopt (argc, argv, "RST")) != -1) {
+    opterr = 0;
+
+    switch(c) {
+      case 'R':
+        runResults = true;
+        break;
+
+      case 'S':
+        printListing = true;
+        break;
+
+      case 'T':
+        printTypeInformation = true;
+        break;
+
+      case '?':
+        // ignore any error
+        break;
+
+      default:
+        // Critical error occurs
+        return 0;
+        break;
+    }
+  }
+
+  if(optind >= argc) {
+    fprintf(stderr, "input file required\n");
+    return 0;
+  }
+
+  inFile = argv[optind];
+
+  return 1;
+}
+
+static BCCscript* loadScript() {
+  FILE* in = stdin;
+
+  if (!inFile) {
+    fprintf(stderr, "input file required\n");
+    return NULL;
+  }
+
+  if (inFile) {
+    in = fopen(inFile, "r");
+    if (!in) {
+      fprintf(stderr, "Could not open input file %s\n", inFile);
+      return NULL;
+    }
+  }
+
+  fseek(in, 0, SEEK_END);
+  size_t codeSize = (size_t) ftell(in);
+  rewind(in);
+  BCCchar* bitcode = new BCCchar[codeSize + 1];
+  size_t bytesRead = fread(bitcode, 1, codeSize, in);
+  if (bytesRead != codeSize)
+      fprintf(stderr, "Could not read all of file %s\n", inFile);
+
+  BCCscript* script = bccCreateScript();
+
+  bitcode[codeSize] = '\0'; /* must be null-terminated */
+  bccScriptBitcode(script, bitcode, codeSize);
+  delete [] bitcode;
+
+  return script;
+}
+
+static int compile(BCCscript* script) {
+  bccRegisterSymbolCallback(script, symbolLookup, NULL);
+
+  bccCompileScript(script);
+
+  int result = bccGetError(script);
+  if (result != 0) {
+    BCCsizei bufferLength;
+    bccGetScriptInfoLog(script, 0, &bufferLength, NULL);
+    char* buf = (char*) malloc(bufferLength + 1);
+    if (buf != NULL) {
+        bccGetScriptInfoLog(script, bufferLength + 1, NULL, buf);
+        fprintf(stderr, "%s", buf);
+        free(buf);
+    } else {
+        fprintf(stderr, "Out of memory.\n");
+    }
+    bccDeleteScript(script);
+    return 0;
+  }
+
+  {
+    BCCsizei numPragmaStrings;
+    bccGetPragmas(script, &numPragmaStrings, 0, NULL);
+    if (numPragmaStrings) {
+      char** strings = new char*[numPragmaStrings];
+      bccGetPragmas(script, NULL, numPragmaStrings, strings);
+      for(BCCsizei i = 0; i < numPragmaStrings; i += 2)
+        fprintf(stderr, "#pragma %s(%s)\n", strings[i], strings[i+1]);
+      delete[] strings;
+    }
+  }
+
+  return 1;
+}
+
+static int runMain(BCCscript* script, int argc, char** argv) {
+  MainPtr mainPointer = 0;
+
+  bccGetScriptLabel(script, "main", (BCCvoid**) &mainPointer);
+
+  int result = bccGetError(script);
+  if (result != BCC_NO_ERROR) {
+    fprintf(stderr, "Could not find main: %d\n", result);
+  } else {
+    fprintf(stderr, "Executing compiled code:\n");
+    int codeArgc = argc - optind;
+    char** codeArgv = argv + optind;
+    //codeArgv[0] = (char*) (inFile ? inFile : "stdin");
+    result = run(mainPointer, codeArgc, codeArgv);
+    fprintf(stderr, "result: %d\n", result);
+  }
+
+  return 1;
+
+}
+
+int main(int argc, char** argv)
+{
+  int result = 0;
+  BCCscript* script;
+
+  if(!parseOption(argc, argv)) {
+    result = 1;
+    fprintf(stderr, "failed to parse option\n");
+    goto exit;
+  }
+
+  if((script = loadScript()) == NULL) {
+    result = 2;
+    fprintf(stderr, "failed to load source\n");
+    goto exit;
+  }
+
+  if(printTypeInformation && !reflection(script, stderr)) {
+    result = 3;
+    fprintf(stderr, "failed to retrieve type information\n");
+    goto exit;
+  }
+
+  if(!compile(script)) {
+    result = 4;
+    fprintf(stderr, "failed to compile\n");
+    goto exit;
+  }
+
+  BCCsizei numVars;
+  bccGetVars(script, &numVars, 0, NULL);
+  //  fprintf(out, "numVars=%d\n", numVars);
+  if (numVars) {
+    void** labels = new void*[numVars];
+    bccGetVars(script, NULL, numVars, labels);
+    for(BCCsizei i = 0; i < numVars; i++) {
+      //fprintf(out, "%x\n", labels[i]);
+    }
+  }
+
+  if(printListing && !disassemble(script, stderr)) {
+    result = 5;
+    fprintf(stderr, "failed to disassemble\n");
+    goto exit;
+  }
+
+  if(runResults && !runMain(script, argc, argv)) {
+    result = 6;
+    fprintf(stderr, "failed to execute\n");
+    goto exit;
+  }
+
+exit:
+
+  return result;
+}
diff --git a/tests/test b/tests/test
new file mode 100755
index 0000000..8fd6916
--- /dev/null
+++ b/tests/test
@@ -0,0 +1,6 @@
+#!/bin/bash
+
+SCRIPT_DIR=`dirname $BASH_SOURCE`
+cd $SCRIPT_DIR
+python test.py "$@"
+
diff --git a/tests/test.py b/tests/test.py
new file mode 100644
index 0000000..045c899
--- /dev/null
+++ b/tests/test.py
@@ -0,0 +1,494 @@
+#
+# Test the bcc compiler
+
+import unittest
+import subprocess
+import os
+import sys
+
+gArmInitialized = False
+gUseArm = True
+gUseX86 = True
+gRunOTCCOutput = True
+
+
+def parseArgv():
+    global gUseArm
+    global gUseX86
+    global gRunOTCCOutput
+    for arg in sys.argv[1:]:
+        if arg == "--noarm":
+            print "--noarm: not testing ARM"
+            gUseArm = False
+        elif arg == "--nox86":
+            print "--nox86: not testing x86"
+            gUseX86 = False
+        elif arg == "--norunotcc":
+            print "--norunotcc detected, not running OTCC output"
+            gRunOTCCOutput = False
+        else:
+            print "Unknown parameter: ", arg
+            raise "Unknown parameter"
+    sys.argv = sys.argv[0:1]
+
+def compile(args):
+    proc = subprocess.Popen(["../libbcc_driver"] + args, stderr=subprocess.PIPE, stdout=subprocess.PIPE)
+    result = proc.communicate()
+    return result
+
+def runCmd(args):
+    proc = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    result = proc.communicate()
+    return result[0].strip()
+
+def uname():
+    return runCmd(["uname"])
+
+def unameM():
+    return runCmd(["uname", "-m"])
+
+def which(item):
+    return runCmd(["which", item])
+
+def fileType(item):
+    return runCmd(["file", item])
+
+def outputCanRun():
+    ft = fileType(which("bcc"))
+    return ft.find("ELF 32-bit LSB executable, Intel 80386") >= 0
+
+def checkEnvironment():
+    global gRunOTCCOutput
+    gRunOTCCOutput = uname() == "Linux" and unameM() != "x86_64" and outputCanRun()
+
+def adb(args):
+    return runCmd(["adb"] + args)
+
+def setupArm():
+    global gArmInitialized
+    if gArmInitialized:
+        return
+    print "Setting up arm"
+    adb(["remount"])
+    adb(["shell", "rm", "/system/bin/bcc"])
+    adb(["shell", "mkdir", "/system/bin/bccdata"])
+    adb(["shell", "mkdir", "/system/bin/bccdata/data"])
+    # Clear out old data TODO: handle recursion
+    adb(["shell", "rm", "/system/bin/bccdata/data/*"])
+    # Copy over data
+    for root, dirs, files in os.walk("data"):
+        for d in dirs:
+            adb(["shell", "mkdir", os.path.join(root, d)])
+        for f in files:
+            adb(["push", os.path.join(root, f), os.path.join("/system/bin/bccdata", root, f)])
+    # Copy over compiler
+    adb(["sync"])
+    gArmInitialized = True
+
+def compileArm(args):
+    setupArm()
+    proc = subprocess.Popen(["adb", "shell", "/system/bin/bcc"] + args, stdout=subprocess.PIPE)
+    result = proc.communicate()
+    return result[0].replace("\r","")
+
+def compare(a, b):
+    if a != b:
+        firstDiff = firstDifference(a, b)
+        print "Strings differ at character %d. Common: %s. Difference '%s' != '%s'" % (
+            firstDiff, a[0:firstDiff], safeAccess(a, firstDiff), safeAccess(b, firstDiff))
+
+def safeAccess(s, i):
+    if 0 <= i < len(s):
+        return s[i]
+    else:
+        return '?'
+
+def firstDifference(a, b):
+    commonLen = min(len(a), len(b))
+    for i in xrange(0, commonLen):
+        if a[i] != b[i]:
+            return i
+    return commonLen
+
+# a1 and a2 are the expected stdout and stderr.
+# b1 and b2 are the actual stdout and stderr.
+# Compare the two, sets. Allow any individual line
+# to appear in either stdout or stderr. This is because
+# the way we obtain output on the ARM combines both
+# streams into one sequence.
+
+def compareOuput(a1,a2,b1,b2):
+    while True:
+        totalLen = len(a1) + len(a2) + len(b1) + len(b2)
+        a1, b1 = matchCommon(a1, b1)
+        a1, b2 = matchCommon(a1, b2)
+        a2, b1 = matchCommon(a2, b1)
+        a2, b2 = matchCommon(a2, b2)
+        newTotalLen = len(a1) + len(a2) + len(b1) + len(b2)
+        if newTotalLen == 0:
+            return True
+        if newTotalLen == totalLen:
+            print "Failed at %d %d %d %d" % (len(a1), len(a2), len(b1), len(b2))
+            print "a1", a1
+            print "a2", a2
+            print "b1", b1
+            print "b2", b2
+            return False
+
+def matchCommon(a, b):
+    """Remove common items from the beginning of a and b,
+       return just the tails that are different."""
+    while len(a) > 0 and len(b) > 0 and a[0] == b[0]:
+        a = a[1:]
+        b = b[1:]
+    return a, b
+
+def rewritePaths(args):
+    return [rewritePath(x) for x in args]
+
+def rewritePath(p):
+    """Take a path that's correct on the x86 and convert to a path
+       that's correct on ARM."""
+    if p.startswith("data/"):
+        p = "/system/bin/bccdata/" + p
+    return p
+
+class TestACC(unittest.TestCase):
+
+    def checkResult(self, out, err, stdErrResult, stdOutResult=""):
+        a1 = out.splitlines()
+        a2 = err.splitlines()
+        b2 = stdErrResult.splitlines()
+        b1 = stdOutResult.splitlines()
+        self.assertEqual(True, compareOuput(a1,a2,b1,b2))
+
+    def compileCheck(self, args, stdErrResult, stdOutResult="",
+                     targets=['arm', 'x86']):
+        global gUseArm
+        global gUseX86
+        targetSet = frozenset(targets)
+        if gUseX86 and 'x86' in targetSet:
+            print args
+            out, err = compile(args)
+            self.checkResult(out, err, stdErrResult, stdOutResult)
+        if gUseArm and 'arm' in targetSet:
+            out = compileArm(rewritePaths(args))
+            self.checkResult(out, "", stdErrResult, stdOutResult)
+
+    def compileCheckArm(self, args, result):
+        self.assertEqual(compileArm(args), result)
+
+    def testCompileReturnVal(self):
+        self.compileCheck(["data/returnval-ansi.bc"], "")
+
+    def testCompileOTCCANSII(self):
+        self.compileCheck(["data/otcc-ansi.bc"], "", "", ['x86'])
+
+    def testRunReturnVal(self):
+        self.compileCheck(["-R", "data/returnval-ansi.bc"],
+        "Executing compiled code:\nresult: 42\n")
+
+    def testStringLiteralConcatenation(self):
+        self.compileCheck(["-R", "data/testStringConcat.bc"],
+        "Executing compiled code:\nresult: 13\n", "Hello, world\n")
+
+    def testRunOTCCANSI(self):
+        global gRunOTCCOutput
+        if gRunOTCCOutput:
+            self.compileCheck(["-R", "data/otcc-ansi.bc", "data/returnval.c"],
+                "Executing compiled code:\notcc-ansi.c: About to execute compiled code:\natcc-ansi.c: result: 42\nresult: 42\n", "",
+                 ['x86'])
+
+    def testRunOTCCANSI2(self):
+        global gRunOTCCOutput
+        if gRunOTCCOutput:
+            self.compileCheck(["-R", "data/otcc-ansi.bc", "data/otcc.c", "data/returnval.c"],
+                "Executing compiled code:\notcc-ansi.c: About to execute compiled code:\notcc.c: about to execute compiled code.\natcc-ansi.c: result: 42\nresult: 42\n", "",['x86'])
+
+    def testRunConstants(self):
+        self.compileCheck(["-R", "data/constants.bc"],
+            "Executing compiled code:\nresult: 0\n",
+            "0 = 0\n010 = 8\n0x10 = 16\n'\\a' = 7\n'\\b' = 8\n'\\f' = 12\n'\\n' = 10\n'\\r' = 13\n'\\t' = 9\n'\\v' = 11\n'\\\\' = 92\n'\\'' = 39\n" +
+            "'\\\"' = 34\n'\\?' = 63\n'\\0' = 0\n'\\1' = 1\n'\\12' = 10\n'\\123' = 83\n'\\x0' = 0\n'\\x1' = 1\n'\\x12' = 18\n'\\x123' = 35\n'\\x1f' = 31\n'\\x1F' = 31\n")
+
+    def testRunFloat(self):
+        self.compileCheck(["-R", "data/float.bc"],
+            "Executing compiled code:\nresult: 0\n",
+            """Constants: 0 0 0 0.01 0.01 0.1 10 10 0.1
+int: 1 float: 2.2 double: 3.3
+ ftoi(1.4f)=1
+ dtoi(2.4)=2
+ itof(3)=3
+ itod(4)=4
+globals: 1 2 3 4
+args: 1 2 3 4
+locals: 1 2 3 4
+cast rval: 2 4
+cast lval: 1.1 2 3.3 4
+""")
+
+    def testRunFlops(self):
+        self.compileCheck(["-R", "data/flops.bc"],
+            """Executing compiled code:
+result: 0""",
+"""-1.1 = -1.1
+!1.2 = 0
+!0 = 1
+double op double:
+1 + 2 = 3
+1 - 2 = -1
+1 * 2 = 2
+1 / 2 = 0.5
+float op float:
+1 + 2 = 3
+1 - 2 = -1
+1 * 2 = 2
+1 / 2 = 0.5
+double op float:
+1 + 2 = 3
+1 - 2 = -1
+1 * 2 = 2
+1 / 2 = 0.5
+double op int:
+1 + 2 = 3
+1 - 2 = -1
+1 * 2 = 2
+1 / 2 = 0.5
+int op double:
+1 + 2 = 3
+1 - 2 = -1
+1 * 2 = 2
+1 / 2 = 0.5
+double op double:
+1 op 2: < 1   <= 1   == 0   >= 0   > 0   != 1
+1 op 1: < 0   <= 1   == 1   >= 1   > 0   != 0
+2 op 1: < 0   <= 0   == 0   >= 1   > 1   != 1
+double op float:
+1 op 2: < 1   <= 1   == 0   >= 0   > 0   != 1
+1 op 1: < 0   <= 1   == 1   >= 1   > 0   != 0
+2 op 1: < 0   <= 0   == 0   >= 1   > 1   != 1
+float op float:
+1 op 2: < 1   <= 1   == 0   >= 0   > 0   != 1
+1 op 1: < 0   <= 1   == 1   >= 1   > 0   != 0
+2 op 1: < 0   <= 0   == 0   >= 1   > 1   != 1
+int op double:
+1 op 2: < 1   <= 1   == 0   >= 0   > 0   != 1
+1 op 1: < 0   <= 1   == 1   >= 1   > 0   != 0
+2 op 1: < 0   <= 0   == 0   >= 1   > 1   != 1
+double op int:
+1 op 2: < 1   <= 1   == 0   >= 0   > 0   != 1
+1 op 1: < 0   <= 1   == 1   >= 1   > 0   != 0
+2 op 1: < 0   <= 0   == 0   >= 1   > 1   != 1
+branching: 1 0 1
+testpassi: 1 2 3 4 5 6 7 8 9 10 11 12
+testpassf: 1 2 3 4 5 6 7 8 9 10 11 12
+testpassd: 1 2 3 4 5 6 7 8 9 10 11 12
+testpassi: 1 2 3 4 5 6 7 8 9 10 11 12
+testpassf: 1 2 3 4 5 6 7 8 9 10 11 12
+testpassd: 1 2 3 4 5 6 7 8 9 10 11 12
+testpassi: 1 2 3 4 5 6 7 8 9 10 11 12
+testpassf: 1 2 3 4 5 6 7 8 9 10 11 12
+testpassd: 1 2 3 4 5 6 7 8 9 10 11 12
+testpassidf: 1 2 3
+""")
+    def testCasts(self):
+        self.compileCheck(["-R", "data/casts.bc"],
+            """Executing compiled code:
+result: 0""", """Reading from a pointer: 3 3
+Writing to a pointer: 4
+Testing casts: 3 3 4.5 4
+Testing reading (int*): 4
+Testing writing (int*): 8 9
+Testing reading (char*): 0x78 0x56 0x34 0x12
+Testing writing (char*): 0x87654321
+f(10)
+Function pointer result: 70
+Testing read/write (float*): 8.8 9.9
+Testing read/write (double*): 8.8 9.9
+""")
+
+    def testChar(self):
+        self.compileCheck(["-R", "data/char.bc"], """Executing compiled code:
+result: 0""", """a = 99, b = 41
+ga = 100, gb = 44""")
+
+    def testPointerArithmetic(self):
+        self.compileCheck(["-R", "data/pointers.bc"], """Executing compiled code:
+result: 0""", """Pointer difference: 1 4
+Pointer addition: 2
+Pointer comparison to zero: 0 0 1
+Pointer comparison: 1 0 0 0 1
+""")
+    def testRollo3(self):
+        self.compileCheck(["-R", "data/rollo3.bc"], """Executing compiled code:
+result: 10""", """""")
+
+    def testFloatDouble(self):
+        self.compileCheck(["-R", "data/floatdouble.bc"], """Executing compiled code:
+result: 0""", """0.002 0.1 10""")
+
+    def testIncDec(self):
+        self.compileCheck(["-R", "data/inc.bc"], """Executing compiled code:
+0
+1
+2
+1
+1
+2
+1
+0
+result: 0
+""","""""")
+
+    def testIops(self):
+        self.compileCheck(["-R", "data/iops.bc"], """Executing compiled code:
+result: 0""", """Literals: 1 -1
+++
+0
+1
+2
+3
+4
+5
+6
+7
+8
+9
+--
+10
+9
+8
+7
+6
+5
+4
+3
+2
+1
+0
+""")
+
+    def testFilm(self):
+        self.compileCheck(["-R", "data/film.bc"], """Executing compiled code:
+result: 0""", """testing...
+Total bad: 0
+""")
+
+    def testpointers2(self):
+        self.compileCheck(["-R", "data/pointers2.bc"], """Executing compiled code:
+result: 0""", """a = 0, *pa = 0
+a = 2, *pa = 2
+a = 0, *pa = 0 **ppa = 0
+a = 2, *pa = 2 **ppa = 2
+a = 0, *pa = 0 **ppa = 0
+a = 2, *pa = 2 **ppa = 2
+""")
+
+    def testassignmentop(self):
+        self.compileCheck(["-R", "data/assignmentop.bc"], """Executing compiled code:
+result: 0""", """2 *= 5  10
+20 /= 5  4
+17 %= 5  2
+17 += 5  22
+17 -= 5  12
+17<<= 1  34
+17>>= 1  8
+17&= 1  1
+17^= 1  16
+16|= 1  17
+*f() = *f() + 10;
+f()
+f()
+a = 10
+*f() += 10;
+f()
+a = 10
+""")
+
+    def testcomma(self):
+        self.compileCheck(["-R", "data/comma.bc"], """Executing compiled code:
+result: 0""", """statement: 10
+if: a = 0
+while: b = 11
+for: b = 22
+return: 30
+arg: 12
+""")
+
+    def testBrackets(self):
+        self.compileCheck(["-R", "data/brackets.bc"], """Executing compiled code:
+Errors: 0
+2D Errors: 0
+result: 0
+""","""""")
+
+    def testShort(self):
+        self.compileCheck(["-R", "data/short.bc"], """Executing compiled code:
+result: -2
+""","""""")
+
+    def testAssignment(self):
+        self.compileCheck(["-R", "data/assignment.bc"], """Executing compiled code:
+result: 7
+""","""""")
+
+    def testArray(self):
+        self.compileCheck(["-R", "data/array.bc"], """Executing compiled code:
+localInt: 3
+localDouble: 3 3
+globalChar: 3
+globalDouble: 3
+testArgs: 0 2 4
+testDecay: Hi!
+test2D:
+abcdefghijklmnopabcd
+defghijklmnopabcdefg
+ghijklmnopabcdefghij
+jklmnopabcdefghijklm
+mnopabcdefghijklmnop
+pabcdefghijklmnopabc
+cdefghijklmnopabcdef
+fghijklmnopabcdefghi
+ijklmnopabcdefghijkl
+lmnopabcdefghijklmno
+result: 0
+""","""""")
+
+    def testDefines(self):
+        self.compileCheck(["-R", "data/defines.bc"], """Executing compiled code:
+result: 3
+""","""""")
+
+    def testFuncArgs(self):
+        self.compileCheck(["-R", "data/funcargs.bc"], """Executing compiled code:
+result: 4
+""","""""")
+
+    def testB2071670(self):
+        self.compileCheck(["-R", "data/b2071670.bc"], """Executing compiled code:
+result: 1092616192
+""","""""")
+
+    def testStructs(self):
+        self.compileCheck(["-R", "data/structs.bc"], """Executing compiled code:
+testCopying: 37 == 37
+testUnion: 1 == 0x3f800000
+testArgs: (6, 8, 10, 12)
+result: 6
+""","""""")
+
+    def testAddressOf(self):
+        self.compileCheck(["-R", "data/addressOf.bc"], """Executing compiled code:
+testStruct: 10 10 10
+testArray: 1 1 1
+result: 0
+""","""""")
+
+def main():
+    checkEnvironment()
+    parseArgv()
+    unittest.main()
+
+if __name__ == '__main__':
+    main()
+