From 67d8bf8483828720f4bbd18d66827a9487f1838a Mon Sep 17 00:00:00 2001
From: Klas Segeljakt <klasseg@kth.se>
Date: Wed, 16 Aug 2023 14:58:17 +0200
Subject: [PATCH] Update Arc-MLIR to support Arc-Lang v1

---
 arc-mlir/src/CMakeLists.txt                   |    29 +-
 arc-mlir/src/include/Arc/CMakeLists.txt       |     4 +-
 arc-mlir/src/include/Rust/Rust.h              |     2 +-
 arc-mlir/src/include/Rust/Rust.td             |    21 -
 arc-mlir/src/include/Rust/RustPrinterStream.h |    48 +-
 arc-mlir/src/lib/Rust/Dialect.cpp             |   147 +-
 arc-mlir/src/tests/CMakeLists.txt             |     7 +-
 arc-mlir/src/tests/arc-to-rust/adt.mlir       |    25 +-
 .../src/tests/arc-to-rust/adt.mlir.rust-tests |    34 +-
 arc-mlir/src/tests/arc-to-rust/arc-cmpf.mlir  |    97 +-
 .../arc-to-rust/arc-cmpf.mlir.rust-tests      |  1712 +-
 arc-mlir/src/tests/arc-to-rust/arc-cmpi.mlir  |   479 +-
 .../arc-to-rust/arc-cmpi.mlir.rust-tests      | 15106 ++++++++--------
 arc-mlir/src/tests/arc-to-rust/bool-ops.mlir  |     4 +-
 .../arc-to-rust/bool-ops.mlir.rust-tests      |    39 +-
 .../src/tests/arc-to-rust/calls-streams.mlir  |    17 -
 .../arc-to-rust/calls-streams.mlir.rust-tests |    17 -
 arc-mlir/src/tests/arc-to-rust/calls.mlir     |    83 +-
 .../tests/arc-to-rust/calls.mlir.rust-tests   |    35 +-
 .../tests/arc-to-rust/enums.mlir.rust-tests   |    39 +-
 .../float-tensor-arith.mlir.rust-tests        |    59 -
 .../arc-to-rust/foreign-calls.mlir.rust-tests |    14 +-
 .../func-arguments.mlir.rust-tests            |    15 +-
 .../src/tests/arc-to-rust/ifs.mlir.rust-tests |    27 +-
 arc-mlir/src/tests/arc-to-rust/int-arith.mlir |   399 +-
 .../arc-to-rust/int-arith.mlir.rust-tests     |  7105 ++++----
 .../arc-to-rust/int-bitops.mlir.rust-tests    |  6105 ++++---
 .../int-tensor-arith.mlir.rust-tests          |   209 -
 arc-mlir/src/tests/arc-to-rust/loops.mlir     |    10 +-
 .../tests/arc-to-rust/loops.mlir.rust-tests   |    23 +-
 arc-mlir/src/tests/arc-to-rust/panic.mlir     |     1 -
 .../tests/arc-to-rust/select.mlir.rust-tests  |    13 +-
 arc-mlir/src/tests/arc-to-rust/simple.mlir    |     8 -
 .../tests/arc-to-rust/simple.mlir.rust-tests  |    35 +-
 arc-mlir/src/tests/arc-to-rust/spawn.mlir     |    32 -
 arc-mlir/src/tests/arc-to-rust/structs.mlir   |     3 -
 .../tests/arc-to-rust/structs.mlir.rust-tests |    21 +-
 .../tests/arc-to-rust/tensors.mlir.rust-tests |    46 -
 arc-mlir/src/tests/arc-to-rust/unary-ops.mlir |   239 +-
 .../arc-to-rust/unary-ops.mlir.rust-tests     |   368 +-
 arc-mlir/src/tests/lit.cfg.py                 |     2 +-
 arc-mlir/src/tests/lit.site.cfg.py.in         |     4 +-
 arc-mlir/src/tools/CMakeLists.txt             |    10 +-
 arc-mlir/src/tools/arc-mlir-rust-test.in      |    20 +-
 arc-mlir/src/tools/arc.in                     |    26 +-
 45 files changed, 16655 insertions(+), 16084 deletions(-)
 delete mode 100644 arc-mlir/src/tests/arc-to-rust/calls-streams.mlir
 delete mode 100644 arc-mlir/src/tests/arc-to-rust/calls-streams.mlir.rust-tests
 delete mode 100644 arc-mlir/src/tests/arc-to-rust/float-tensor-arith.mlir.rust-tests
 delete mode 100644 arc-mlir/src/tests/arc-to-rust/int-tensor-arith.mlir.rust-tests
 delete mode 100644 arc-mlir/src/tests/arc-to-rust/spawn.mlir
 delete mode 100644 arc-mlir/src/tests/arc-to-rust/tensors.mlir.rust-tests

diff --git a/arc-mlir/src/CMakeLists.txt b/arc-mlir/src/CMakeLists.txt
index 2e6ebe942..ff99e51d9 100644
--- a/arc-mlir/src/CMakeLists.txt
+++ b/arc-mlir/src/CMakeLists.txt
@@ -1,4 +1,5 @@
-set(ARC_MLIR_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+set(ARC_MLIR_SRC_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+
 include_directories(../llvm-project/mlir/include/)
 include_directories(include/)
 include_directories(${CMAKE_CURRENT_BINARY_DIR}/../mlir/include/)
@@ -20,25 +21,21 @@ get_filename_component(ARC_CARGO_BIN "../../bin"
 get_filename_component(ARC_TOOLS_BIN_DIR "../../bin"
   REALPATH BASE_DIR ${CMAKE_CURRENT_BINARY_DIR} CACHE)
 
-get_filename_component(ARC_LANG_SRC_DIR "../../arc-lang"
+get_filename_component(ARC_LANG_DIR "../../arc-lang"
   REALPATH BASE_DIR ${CMAKE_CURRENT_SOURCE_DIR} CACHE)
 
-get_filename_component(ARC_LANG_BUILD_DIR "../../arc-lang/build"
+get_filename_component(ARC_LANG_TARGET_DIR "../../arc-lang/target"
   REALPATH BASE_DIR ${CMAKE_CURRENT_BINARY_DIR} CACHE)
 
-get_filename_component(ARC_RUNTIME_SRC_DIR "../../arc-runtime"
+get_filename_component(ARC_RUNTIME_DIR "../../arc-lang/crates/runtime/"
   REALPATH BASE_DIR ${CMAKE_CURRENT_SOURCE_DIR} CACHE)
 
-get_filename_component(ARC_MLIR_SRC_DIR "../"
+get_filename_component(ARC_MLIR_DIR "../"
   REALPATH BASE_DIR ${CMAKE_CURRENT_SOURCE_DIR} CACHE)
 
-add_custom_target(dune-build ALL
-  WORKING_DIRECTORY ${ARC_LANG_SRC_DIR}
-  COMMAND mkdir -p ${ARC_LANG_BUILD_DIR}
-  COMMAND ${ARC_LANG_SRC_DIR}/dune-wrapper build
-    --root ${ARC_LANG_SRC_DIR}
-    --build-dir ${ARC_LANG_BUILD_DIR} src/main.exe
-  COMMAND mv -f ${ARC_LANG_BUILD_DIR}/default/src/main.exe ${ARC_LANG_EXE}
+add_custom_target(arc-lang ALL
+  COMMAND cargo build --manifest-path=${ARC_LANG_DIR}/Cargo.toml --release --target-dir=${ARC_LANG_TARGET_DIR}
+  COMMAND mv -f ${ARC_LANG_TARGET_DIR}/release/arc-lang ${ARC_LANG_EXE}
 )
 
 add_subdirectory(include)
@@ -46,11 +43,11 @@ add_subdirectory(lib)
 add_subdirectory(tests)
 add_subdirectory(tools)
 
-add_custom_target(arc-runtime-check DEPENDS check-arc-mlir
-  COMMAND cd ${ARC_SCRIPT_SRC_DIR}; ${ARC_CARGO_BIN}/arc-cargo test --package=arc-runtime
+add_custom_target(arc-lang-check DEPENDS check-arc-mlir
+  COMMAND cd ${ARC_LANG_DIR}; ${ARC_CARGO_BIN}/arc-cargo test
 )
 
-install(DIRECTORY ${ARC_LANG_SRC_DIR}/stdlib DESTINATION share/arc/)
-install(DIRECTORY ${ARC_RUNTIME_SRC_DIR} DESTINATION share/arc/)
+install(DIRECTORY ${ARC_LANG_DIR}/stdlib DESTINATION share/arc/)
+install(DIRECTORY ${ARC_RUNTIME_DIR} DESTINATION share/arc/)
 install(PROGRAMS ${LLVM_TOOLS_BINARY_DIR}/arc DESTINATION bin)
 install(PROGRAMS ${LLVM_TOOLS_BINARY_DIR}/arc-lang DESTINATION bin)
diff --git a/arc-mlir/src/include/Arc/CMakeLists.txt b/arc-mlir/src/include/Arc/CMakeLists.txt
index be08d6824..328b44937 100644
--- a/arc-mlir/src/include/Arc/CMakeLists.txt
+++ b/arc-mlir/src/include/Arc/CMakeLists.txt
@@ -3,7 +3,7 @@ set(MLIR_INCLUDE_DIR
   ${CMAKE_CURRENT_SOURCE_DIR}/../../../llvm-project/mlir/include/
 )
 
-set(LLVM_TARGET_DEFINITIONS ${ARC_MLIR_SOURCE_DIR}/include/Arc/Arc.td)
+set(LLVM_TARGET_DEFINITIONS ${ARC_MLIR_SRC_DIR}/include/Arc/Arc.td)
 set(TBLGEN_INCDIRS "-I${CMAKE_CURRENT_SOURCE_DIR}/../../../llvm-project/mlir/include/")
 
 mlir_tablegen(ArcOps.h.inc -gen-op-decls)
@@ -15,7 +15,7 @@ mlir_tablegen(ArcOpsEnums.cpp.inc -gen-enum-defs)
 
 add_public_tablegen_target(ArcDialectOpsEnumsIncGen)
 
-set(LLVM_TARGET_DEFINITIONS ${ARC_MLIR_SOURCE_DIR}/include/Arc/Opts.td)
+set(LLVM_TARGET_DEFINITIONS ${ARC_MLIR_SRC_DIR}/include/Arc/Opts.td)
 set(TBLGEN_INCDIRS "-I${CMAKE_CURRENT_SOURCE_DIR}/../../../llvm-project/mlir/include/")
 mlir_tablegen(ArcOpts.h.inc -gen-rewriters ${TBLGEN_INCDIRS} "-I${CMAKE_CURRENT_SOURCE_DIR}/include")
 add_public_tablegen_target(ArcDialectOptsIncGen)
diff --git a/arc-mlir/src/include/Rust/Rust.h b/arc-mlir/src/include/Rust/Rust.h
index 236deacc8..8c02d3722 100644
--- a/arc-mlir/src/include/Rust/Rust.h
+++ b/arc-mlir/src/include/Rust/Rust.h
@@ -48,7 +48,7 @@ LogicalResult writeModuleAsInline(ModuleOp module, llvm::raw_ostream &o);
 /// A single place to define the versions for the external crates
 /// used by the Rust code generated by the backend.
 struct CrateVersions {
-  static const char *ndarray;
+
 };
 
 bool isRustFunctionType(Type type);
diff --git a/arc-mlir/src/include/Rust/Rust.td b/arc-mlir/src/include/Rust/Rust.td
index 4fcf0f703..ae5785fc4 100644
--- a/arc-mlir/src/include/Rust/Rust.td
+++ b/arc-mlir/src/include/Rust/Rust.td
@@ -513,27 +513,6 @@ def Rust_RustBinaryOp : Rust_Op<"binaryop", [SameTypeOperands]> {
   }];
 }
 
-def Rust_RustBinaryRcOp : Rust_Op<"binaryrcop", [SameTypeOperands]> {
-  let summary = "a Rust binary operation operating on a Rc value.";
-  let description = [{
-    A Rust binary operation, the op attribute is the string representation of
-    the operator in Rust syntax. The operands will be dereferenced and the
-    result wrapped in a Rc.
-  }];
-
-  let arguments = (ins StrAttr : $op, AnyRustType : $LHS, AnyRustType : $RHS);
-  let results = (outs AnyRustType);
-
-  let extraClassDeclaration = [{
-    StringRef getOperator() {
-      return (*this)->getAttrOfType<StringAttr>("op").getValue();
-    }
-
-    // Write this operation as Rust code to the stream
-    void writeRust(RustPrinterStream &);
-  }];
-}
-
 def Rust_RustCompOp : Rust_Op<"compop", [SameTypeOperands]> {
   let summary = "a Rust comparison operation.";
   let description = [{
diff --git a/arc-mlir/src/include/Rust/RustPrinterStream.h b/arc-mlir/src/include/Rust/RustPrinterStream.h
index ee16960ca..e9e3f96e1 100644
--- a/arc-mlir/src/include/Rust/RustPrinterStream.h
+++ b/arc-mlir/src/include/Rust/RustPrinterStream.h
@@ -84,53 +84,15 @@ class RustPrinterStream {
         Includefile(includefile){};
 
   void flush(llvm::raw_ostream &o) {
-    o << "#![allow(non_snake_case)]\n"
-      << "#![allow(unused_must_use)]\n"
-      << "#![allow(non_camel_case_types)]"
-      << "#![allow(dead_code)]\n"
-      << "#![allow(unused_variables)]\n"
-      << "#![allow(unused_imports)]\n"
-      << "#![allow(unused_braces)]\n"
+    o << "#![allow(unused)]\n"
+      << "#![allow(non_snake_case)]\n"
       << "#![allow(non_camel_case_types)]\n";
 
     o << "pub mod " << ModuleName
       << "{\n"
          "use super::*;\n"
-         "pub use arc_runtime::prelude::*;\n";
-
-    o << "pub use hexf::*;\n";
-
-    if (!DeclaredFunctions.empty() || !DeclaredTasks.empty()) {
-      o << "declare!(";
-      o << "functions: [ ";
-      for (Operation *t : DeclaredFunctions) {
-        if (t->hasAttr("arc.rust_name"))
-          o << t->getAttrOfType<StringAttr>("arc.rust_name").getValue();
-        else
-          o << t->getAttrOfType<StringAttr>("sym_name").getValue();
-        o << ", ";
-      }
-      o << "],";
-      o << "tasks: [ ";
-      for (RustFuncOp &t : DeclaredTasks) {
-        if (t->hasAttr("arc.rust_name"))
-          o << t->getAttrOfType<StringAttr>("arc.rust_name").getValue();
-        else
-          o << t->getAttrOfType<StringAttr>("sym_name").getValue();
-        o << "(";
-        unsigned numFuncArguments = t.getNumArguments();
-        for (unsigned i = 0; i < numFuncArguments; i++) {
-          Value v = t.front().getArgument(i);
-          if (i != 0)
-            o << ", ";
-          o << "v" << std::to_string(Value2ID[v]) << ": ";
-          printType(o, v.getType());
-        }
-        o << "), ";
-      }
-      o << "]";
-      o << ");\n";
-    }
+         "pub use runtime::prelude::*;\n"
+         "pub use hexf::*;\n";
 
     for (auto i : CrateDirectives)
       o << i.second << "\n";
@@ -180,7 +142,7 @@ class RustPrinterStream {
     if (id < 0)
       return "C" + std::to_string(-id);
     else
-      return "val!(v" + std::to_string(id) + ")";
+      return "v" + std::to_string(id) + ".clone()";
   }
 
   std::string getConstant(RustConstantOp v);
diff --git a/arc-mlir/src/lib/Rust/Dialect.cpp b/arc-mlir/src/lib/Rust/Dialect.cpp
index acd6434a6..837a5dad4 100644
--- a/arc-mlir/src/lib/Rust/Dialect.cpp
+++ b/arc-mlir/src/lib/Rust/Dialect.cpp
@@ -71,18 +71,18 @@ void RustDialect::initialize() {
 
   auto ctx = getContext();
 
-  floatTy = RustType::get(ctx, "f32");
-  doubleTy = RustType::get(ctx, "f64");
-  boolTy = RustType::get(ctx, "bool");
-  i8Ty = RustType::get(ctx, "i8");
-  i16Ty = RustType::get(ctx, "i16");
-  i32Ty = RustType::get(ctx, "i32");
-  i64Ty = RustType::get(ctx, "i64");
-  u8Ty = RustType::get(ctx, "u8");
-  u16Ty = RustType::get(ctx, "u16");
-  u32Ty = RustType::get(ctx, "u32");
-  u64Ty = RustType::get(ctx, "u64");
-  noneTy = RustType::get(ctx, "unit");
+  floatTy = RustType::get(ctx, "F32");
+  doubleTy = RustType::get(ctx, "F64");
+  boolTy = RustType::get(ctx, "Bool");
+  i8Ty = RustType::get(ctx, "I8");
+  i16Ty = RustType::get(ctx, "I16");
+  i32Ty = RustType::get(ctx, "I32");
+  i64Ty = RustType::get(ctx, "I64");
+  u8Ty = RustType::get(ctx, "U8");
+  u16Ty = RustType::get(ctx, "U16");
+  u32Ty = RustType::get(ctx, "U32");
+  u64Ty = RustType::get(ctx, "U64");
+  noneTy = RustType::get(ctx, "()");
 }
 
 //===----------------------------------------------------------------------===//
@@ -274,8 +274,6 @@ static RustPrinterStream &writeRust(Operation &operation,
     op.writeRust(PS);
   else if (RustBinaryOp op = dyn_cast<RustBinaryOp>(operation))
     op.writeRust(PS);
-  else if (RustBinaryRcOp op = dyn_cast<RustBinaryRcOp>(operation))
-    op.writeRust(PS);
   else if (RustCallOp op = dyn_cast<RustCallOp>(operation))
     op.writeRust(PS);
   else if (RustCallIndirectOp op = dyn_cast<RustCallIndirectOp>(operation))
@@ -329,8 +327,6 @@ std::string RustPrinterStream::getConstant(RustConstantOp v) {
     if (Operation *target = SymbolTable::lookupNearestSymbolFrom(v, str)) {
       if (target->hasAttr("arc.rust_name"))
         str = target->getAttrOfType<StringAttr>("arc.rust_name");
-      if (target->hasAttr("rust.declare"))
-        DeclaredFunctions.insert(target);
     }
 
     auto found = Value2ID.find(v);
@@ -339,25 +335,26 @@ std::string RustPrinterStream::getConstant(RustConstantOp v) {
       id = NextID++;
       Value2ID[v] = id;
       // A function constant has uses, or else we would not ouput it.
-      Body << "let v" << id << " : ";
-
-      Body << ::getMangledName(fType, *this);
-      Body << " = function!(" << str.getValue() << ");\n";
+      Body << "let v" << id << " : "
+           << ::getMangledName(fType, *this)
+           << " = " << str.getValue() << ";\n";
     } else
       id = found->second;
     return "v" + std::to_string(id);
+  } else {
+    auto found = Value2ID.find(v);
+    int id = 0;
+    if (found == Value2ID.end()) {
+      id = --NextConstID;
+      Value2ID[v] = id;
+    } else
+      id = found->second;
+    Constants
+      << "const C" << -id << " : " << v.getType()
+      << " = "
+      << v.getType() << "::new(" << str.getValue() << ")" << ";\n";
+    return "C" + std::to_string(-id);
   }
-  auto found = Value2ID.find(v);
-  int id = 0;
-  if (found == Value2ID.end()) {
-    id = --NextConstID;
-    Value2ID[v] = id;
-  } else
-    id = found->second;
-  Constants << "const C" << -id << " : ";
-  ::printAsRust(v.getType(), Constants, *this);
-  Constants << " = " << str.getValue() << ";\n";
-  return "C" + std::to_string(-id);
 }
 
 void RustCallOp::writeRust(RustPrinterStream &PS) {
@@ -373,14 +370,10 @@ void RustCallOp::writeRust(RustPrinterStream &PS) {
   if (target && target->hasAttr("arc.rust_name"))
     callee = target->getAttrOfType<StringAttr>("arc.rust_name").getValue();
 
-  if (target && target->hasAttr("rust.async"))
-    PS << "call_async!(";
-  else
-    PS << "call!(";
   PS << callee << "(";
   for (auto a : getOperands())
     PS << a << ", ";
-  PS << "));\n";
+  PS << ");\n";
 }
 
 void RustCallIndirectOp::writeRust(RustPrinterStream &PS) {
@@ -389,29 +382,18 @@ void RustCallIndirectOp::writeRust(RustPrinterStream &PS) {
     auto r = getResult(0);
     PS.let(r);
   }
-  PS << "call_indirect!((" << getCallee() << ")(";
+  PS << "(" << getCallee() << ")(";
   for (auto a : getArgOperands())
     PS << a << ", ";
-  PS << "));\n";
+  PS << ");\n";
 }
 
 // Write this function as Rust code to os
 void RustFuncOp::writeRust(RustPrinterStream &PS) {
-  if ((*this)->hasAttr("arc.is_task"))
-    PS.addTask(*this);
-
-  if ((*this)->hasAttr("rust.declare"))
-    PS.addDeclaredFunction(getOperation());
-
   if ((*this)->hasAttr("rust.annotation"))
     PS << (*this)->getAttrOfType<StringAttr>("rust.annotation").getValue()
        << "\n";
-  else
-    PS << "#[rewrite]\n";
-  PS << "pub ";
-  if ((*this)->hasAttr("rust.async"))
-    PS << "async ";
-  PS << "fn ";
+  PS << "pub fn ";
   if ((*this)->hasAttr("arc.rust_name"))
     PS << (*this)->getAttrOfType<StringAttr>("arc.rust_name").getValue();
   else
@@ -422,14 +404,7 @@ void RustFuncOp::writeRust(RustPrinterStream &PS) {
   unsigned numFuncArguments = getNumArguments();
   for (unsigned i = 0; i < numFuncArguments; i++) {
     Value v = front().getArgument(i);
-    Type t = v.getType();
-    if (i != 0)
-      PS << ", ";
-    if ((*this)->hasAttr("arc.is_task")) {
-      if (RustSinkStreamType st = t.dyn_cast<RustSinkStreamType>())
-        PS << "#[output]";
-    }
-    PS.printAsArg(v) << ": " << v.getType();
+    PS.printAsArg(v) << ": " << v.getType() << ", ";
   }
   PS << ") ";
   FunctionType funcTy = getFunctionType();
@@ -458,19 +433,14 @@ void RustExtFuncOp::writeRust(RustPrinterStream &PS) {
     return;
 
   PS << (*this)->getAttrOfType<StringAttr>("rust.annotation").getValue()
-     << "\npub ";
-  if ((*this)->hasAttr("rust.async"))
-    PS << "async ";
-  PS << "fn " << getName() << "(";
+     << "\npub fn " << getName() << "(";
 
   FunctionType fType = getFunctionType();
 
   unsigned numFuncArguments = fType.getNumInputs();
   for (unsigned i = 0; i < numFuncArguments; i++) {
     Type t = fType.getInput(i);
-    if (i != 0)
-      PS << ", ";
-    PS << "arg" << i << " : " << t;
+    PS << "arg" << i << " : " << t << ", ";
   }
   PS << ") ";
   if (fType.getNumResults()) { // The return type
@@ -480,7 +450,7 @@ void RustExtFuncOp::writeRust(RustPrinterStream &PS) {
 }
 
 void RustReturnOp::writeRust(RustPrinterStream &PS) {
-  if (getNumOperands())
+  if (getNumOperands() > 0)
     PS << "return " << getOperand(0) << ";\n";
   else
     PS << "return;\n";
@@ -624,7 +594,7 @@ void RustLoopYieldOp::writeRust(RustPrinterStream &PS) {
 void RustMakeEnumOp::writeRust(RustPrinterStream &PS) {
   auto r = getResult();
   RustEnumType et = r.getType().cast<RustEnumType>();
-  PS.let(r) << "enwrap!(" << et << "::" << getVariant() << ", ";
+  PS.let(r) << et << "::" << getVariant() << "(";
   if (getValues().size())
     PS << getValues()[0];
   else
@@ -635,15 +605,13 @@ void RustMakeEnumOp::writeRust(RustPrinterStream &PS) {
 void RustMakeStructOp::writeRust(RustPrinterStream &PS) {
   auto r = getResult();
   RustStructType st = r.getType().cast<RustStructType>();
-  PS.let(r) << "new!(" << st << " { ";
+  PS.let(r) << st << " { ";
   auto args = getOperands();
   for (unsigned i = 0; i < args.size(); i++) {
-    if (i != 0)
-      PS << ", ";
     auto v = args[i];
-    PS << st.getFieldName(i) << " : " << v;
+    PS << st.getFieldName(i) << " : " << v << ", ";
   }
-  PS << "});\n";
+  PS << "};\n";
 }
 
 void RustMethodCallOp::writeRust(RustPrinterStream &PS) {
@@ -651,10 +619,8 @@ void RustMethodCallOp::writeRust(RustPrinterStream &PS) {
   PS.let(r) << getObj() << "." << getMethod() << "(";
   auto args = getOps();
   for (unsigned i = 0; i < args.size(); i++) {
-    if (i != 0)
-      PS << ", ";
     auto v = args[i];
-    PS << v;
+    PS << v << ", ";
   }
   PS << ");\n";
 }
@@ -664,12 +630,6 @@ void RustBinaryOp::writeRust(RustPrinterStream &PS) {
   PS.let(r) << getLHS() << " " << getOperator() << " " << getRHS() << ";\n";
 }
 
-void RustBinaryRcOp::writeRust(RustPrinterStream &PS) {
-  auto r = getResult();
-  PS.let(r) << "Rc::new(&*" << getLHS() << " " << getOperator() << " &*"
-            << getRHS() << ");\n";
-}
-
 void RustCompOp::writeRust(RustPrinterStream &PS) {
   auto r = getResult();
   PS.let(r) << getLHS() << " " << getOperator() << " " << getRHS() << ";\n";
@@ -678,20 +638,20 @@ void RustCompOp::writeRust(RustPrinterStream &PS) {
 void RustEnumAccessOp::writeRust(RustPrinterStream &PS) {
   auto r = getResult();
   RustEnumType et = getTheEnum().getType().cast<RustEnumType>();
-  PS.let(r) << "unwrap!(" << et << "::" << getVariant() << ", " << getTheEnum()
+  PS.let(r) << "unwrap!(" << getTheEnum() << ", " << et << "::" << getVariant() 
             << ");\n";
 }
 
 void RustEnumCheckOp::writeRust(RustPrinterStream &PS) {
   auto r = getResult();
   RustEnumType et = getTheEnum().getType().cast<RustEnumType>();
-  PS.let(r) << "is!(" << et << "::" << getVariant() << ", " << getTheEnum()
-            << ");\n";
+  PS.let(r) << "matches!(" << getTheEnum() << ", " << et << "::" << getVariant()
+            << "(_)" << ");\n";
 }
 
 void RustFieldAccessOp::writeRust(RustPrinterStream &PS) {
   auto r = getResult();
-  PS.let(r) << "access!(" << getAggregate() << ", " << getField() << ");\n";
+  PS.let(r) << getAggregate() << "." << getField() << ";\n";
 }
 
 void RustIfOp::writeRust(RustPrinterStream &PS) {
@@ -753,6 +713,7 @@ void RustPanicOp::writeRust(RustPrinterStream &PS) {
   PS << ");\n";
 }
 
+// TODO: The runtime right now requires code to be synchronous.
 void RustReceiveOp::writeRust(RustPrinterStream &PS) {
   auto r = getResult();
   PS.let(r) << "pull!(" << getSource();
@@ -764,10 +725,12 @@ void RustReceiveOp::writeRust(RustPrinterStream &PS) {
   PS << ");\n";
 }
 
+// TODO: The runtime right now requires code to be synchronous.
 void RustSendOp::writeRust(RustPrinterStream &PS) {
   PS << "push!(" << getValue() << "," << getSink() << ");\n";
 }
 
+// TODO: The runtime right now requires code to be synchronous.
 void RustSpawnOp::writeRust(RustPrinterStream &PS) {
   StringRef callee = getCallee();
   StringAttr calleeName = StringAttr::get(this->getContext(), getCallee());
@@ -785,7 +748,6 @@ void RustSpawnOp::writeRust(RustPrinterStream &PS) {
 // Crate versions
 //===----------------------------------------------------------------------===//
 namespace rust {
-const char *CrateVersions::ndarray = "0.13.0";
 } // namespace rust
 
 //===----------------------------------------------------------------------===//
@@ -852,7 +814,7 @@ void RustType::printAsRust(llvm::raw_ostream &o, rust::RustPrinterStream &ps) {
 }
 
 bool RustTypeStorage::isBool() const {
-  return mangledName.compare("bool") == 0;
+  return mangledName.compare("Bool") == 0;
 }
 
 bool RustType::isBool() const { return getImpl()->isBool(); }
@@ -994,7 +956,7 @@ std::string RustEnumTypeStorage::getMangledName(rust::RustPrinterStream &ps) {
   mangledName = mangled.str();
 
   llvm::raw_ostream &tyStream = ps.getNamedTypesStream();
-  tyStream << "#[rewrite]\n";
+  tyStream << "#[data]\n";
   tyStream << "pub enum " << mangledName << " {\n";
   for (unsigned i = 0; i < enumVariants.size(); i++) {
     tyStream << "  " << enumVariants[i].first.getValue() << "("
@@ -1380,10 +1342,7 @@ std::string RustStructTypeStorage::getMangledName(rust::RustPrinterStream &ps) {
 
   llvm::raw_ostream &tyStream = ps.getNamedTypesStream();
 
-  if (isCompact())
-    tyStream << "#[rewrite(compact)]\n";
-  else
-    tyStream << "#[rewrite]\n";
+  tyStream << "#[data]\n";
   tyStream << "pub struct " << mangledName << " {\n  ";
 
   for (unsigned i = 0; i < structFields.size(); i++) {
@@ -1613,13 +1572,13 @@ std::string RustPrinterStream::getMangledName(FunctionType fTy) {
   FunctionTypes[fTy] = mn;
   llvm::raw_ostream &tyStream = getNamedTypesStream();
 
-  tyStream << "type " << mn << " = function!((";
+  tyStream << "type " << mn << " = fn(";
   for (Type t : fTy.getInputs())
     tyStream << ::getMangledName(t, *this) << ", ";
   tyStream << ")";
   if (fTy.getNumResults())
     tyStream << " -> " << ::getMangledName(fTy.getResult(0), *this);
-  tyStream << ");\n";
+  tyStream << ";\n";
 
   return mn;
 }
diff --git a/arc-mlir/src/tests/CMakeLists.txt b/arc-mlir/src/tests/CMakeLists.txt
index dd7d70b7c..870f84868 100644
--- a/arc-mlir/src/tests/CMakeLists.txt
+++ b/arc-mlir/src/tests/CMakeLists.txt
@@ -12,8 +12,11 @@ configure_lit_site_cfg(
 )
 
 set(ARC_MLIR_TEST_DEPENDS
-  FileCheck count not
-  arc-mlir dune-build
+  FileCheck
+  count
+  not
+  arc-mlir
+  arc-lang
 )
 
 add_lit_testsuite(check-arc-mlir "Running the ARC-MLIR regression tests"
diff --git a/arc-mlir/src/tests/arc-to-rust/adt.mlir b/arc-mlir/src/tests/arc-to-rust/adt.mlir
index dabe19c1a..6116ebd7b 100644
--- a/arc-mlir/src/tests/arc-to-rust/adt.mlir
+++ b/arc-mlir/src/tests/arc-to-rust/adt.mlir
@@ -3,7 +3,6 @@
 // RUN: arc-mlir-rust-test %t-roundtrip-scf %s -rustinclude %s.rust-tests -canonicalize -remove-scf -canonicalize -to-scf -canonicalize
 
 module @arctorustadt {
-
   func.func @ok0(%in : !arc.adt<"i32">) -> () {
     return
   }
@@ -17,23 +16,23 @@ module @arctorustadt {
     return %out : !arc.adt<"i32">
   }
 
-  func.func @ok6(%in : !arc.generic_adt<"crate::arctorustadt::tests::sharable_Foo::Foo", ui32>)
-     -> !arc.generic_adt<"crate::arctorustadt::tests::sharable_Foo::Foo", ui32> {
-     return %in : !arc.generic_adt<"crate::arctorustadt::tests::sharable_Foo::Foo", ui32>
+  func.func @ok6(%in : !arc.generic_adt<"crate::arctorustadt::tests::Foo", ui32>)
+     -> !arc.generic_adt<"crate::arctorustadt::tests::Foo", ui32> {
+     return %in : !arc.generic_adt<"crate::arctorustadt::tests::Foo", ui32>
   }
 
-  func.func @ok7(%in : !arc.generic_adt<"crate::arctorustadt::tests::sharable_Bar::Bar", ui32, !arc.generic_adt<"crate::arctorustadt::tests::sharable_Foo::Foo", f64>>)
-    -> !arc.generic_adt<"crate::arctorustadt::tests::sharable_Bar::Bar", ui32, !arc.generic_adt<"crate::arctorustadt::tests::sharable_Foo::Foo", f64>> {
-    return %in : !arc.generic_adt<"crate::arctorustadt::tests::sharable_Bar::Bar", ui32, !arc.generic_adt<"crate::arctorustadt::tests::sharable_Foo::Foo", f64>>
+  func.func @ok7(%in : !arc.generic_adt<"crate::arctorustadt::tests::Bar", ui32, !arc.generic_adt<"crate::arctorustadt::tests::Foo", f64>>)
+    -> !arc.generic_adt<"crate::arctorustadt::tests::Bar", ui32, !arc.generic_adt<"crate::arctorustadt::tests::Foo", f64>> {
+    return %in : !arc.generic_adt<"crate::arctorustadt::tests::Bar", ui32, !arc.generic_adt<"crate::arctorustadt::tests::Foo", f64>>
   }
 
-  func.func @ok8(%in : !arc.generic_adt<"crate::arctorustadt::tests::sharable_Bar::Bar", ui32, !arc.adt<"i32">>)
-    -> !arc.generic_adt<"crate::arctorustadt::tests::sharable_Bar::Bar", ui32, !arc.adt<"i32">> {
-    return %in : !arc.generic_adt<"crate::arctorustadt::tests::sharable_Bar::Bar", ui32, !arc.adt<"i32">>
+  func.func @ok8(%in : !arc.generic_adt<"crate::arctorustadt::tests::Bar", ui32, !arc.adt<"i32">>)
+    -> !arc.generic_adt<"crate::arctorustadt::tests::Bar", ui32, !arc.adt<"i32">> {
+    return %in : !arc.generic_adt<"crate::arctorustadt::tests::Bar", ui32, !arc.adt<"i32">>
   }
 
-  func.func @ok9(%in : !arc.struct<foo : !arc.generic_adt<"crate::arctorustadt::tests::sharable_Bar::Bar", ui32, !arc.adt<"i32">>>)
-    -> !arc.struct<foo : !arc.generic_adt<"crate::arctorustadt::tests::sharable_Bar::Bar", ui32, !arc.adt<"i32">>> {
-    return %in : !arc.struct<foo : !arc.generic_adt<"crate::arctorustadt::tests::sharable_Bar::Bar", ui32, !arc.adt<"i32">>>
+  func.func @ok9(%in : !arc.struct<foo : !arc.generic_adt<"crate::arctorustadt::tests::Bar", ui32, !arc.adt<"i32">>>)
+    -> !arc.struct<foo : !arc.generic_adt<"crate::arctorustadt::tests::Bar", ui32, !arc.adt<"i32">>> {
+    return %in : !arc.struct<foo : !arc.generic_adt<"crate::arctorustadt::tests::Bar", ui32, !arc.adt<"i32">>>
   }
 }
diff --git a/arc-mlir/src/tests/arc-to-rust/adt.mlir.rust-tests b/arc-mlir/src/tests/arc-to-rust/adt.mlir.rust-tests
index ef30d7b65..f06e84590 100644
--- a/arc-mlir/src/tests/arc-to-rust/adt.mlir.rust-tests
+++ b/arc-mlir/src/tests/arc-to-rust/adt.mlir.rust-tests
@@ -1,25 +1,21 @@
 #[cfg(test)]
 mod tests {
-  use crate::arctorustadt::*;
+    use crate::arctorustadt::*;
 
-  #[rewrite]
-  pub struct Foo<A> {
-    pub a: A,
-  }
+    #[data]
+    pub struct Foo<A> {
+        pub a: A,
+    }
 
-  #[rewrite]
-  pub struct Bar<A, B> {
-    pub a: A,
-    pub b: B,
-  }
+    #[data]
+    pub struct Bar<A, B> {
+        pub a: A,
+        pub b: B,
+    }
 
-  #[rewrite(main)]
-  #[test]
-  fn test() {
-   let tmp0 = call!(ok2(4711));
-   assert_eq!(tmp0, 4711);
-
-   let tmp2 = call!(ok4());
-   assert_eq!(tmp2, 4711);
-  }
+    #[test]
+    fn test() {
+        assert_eq!(ok2(4711), 4711);
+        assert_eq!(ok4(), 4711);
+    }
 }
diff --git a/arc-mlir/src/tests/arc-to-rust/arc-cmpf.mlir b/arc-mlir/src/tests/arc-to-rust/arc-cmpf.mlir
index 8971e5625..44dca3755 100644
--- a/arc-mlir/src/tests/arc-to-rust/arc-cmpf.mlir
+++ b/arc-mlir/src/tests/arc-to-rust/arc-cmpf.mlir
@@ -2,64 +2,63 @@
 // RUN: arc-mlir-rust-test %t-roundtrip-scf %s -rustinclude %s.rust-tests -canonicalize -remove-scf -canonicalize -to-scf -canonicalize
 
 module @arctorustarcarccmpf {
-func.func @oeq_f32(%a : f32, %b : f32) -> i1 {
-  %r = arith.cmpf "oeq", %a, %b : f32
-  return %r : i1
-}
+  func.func @oeq_f32(%a : f32, %b : f32) -> i1 {
+    %r = arith.cmpf "oeq", %a, %b : f32
+    return %r : i1
+  }
 
-func.func @one_f32(%a : f32, %b : f32) -> i1 {
-  %r = arith.cmpf "one", %a, %b : f32
-  return %r : i1
-}
+  func.func @one_f32(%a : f32, %b : f32) -> i1 {
+    %r = arith.cmpf "one", %a, %b : f32
+    return %r : i1
+  }
 
-func.func @olt_f32(%a : f32, %b : f32) -> i1 {
-  %r = arith.cmpf "olt", %a, %b : f32
-  return %r : i1
-}
+  func.func @olt_f32(%a : f32, %b : f32) -> i1 {
+    %r = arith.cmpf "olt", %a, %b : f32
+    return %r : i1
+  }
 
-func.func @ole_f32(%a : f32, %b : f32) -> i1 {
-  %r = arith.cmpf "ole", %a, %b : f32
-  return %r : i1
-}
+  func.func @ole_f32(%a : f32, %b : f32) -> i1 {
+    %r = arith.cmpf "ole", %a, %b : f32
+    return %r : i1
+  }
 
-func.func @ogt_f32(%a : f32, %b : f32) -> i1 {
-  %r = arith.cmpf "ogt", %a, %b : f32
-  return %r : i1
-}
+  func.func @ogt_f32(%a : f32, %b : f32) -> i1 {
+    %r = arith.cmpf "ogt", %a, %b : f32
+    return %r : i1
+  }
 
-func.func @oge_f32(%a : f32, %b : f32) -> i1 {
-  %r = arith.cmpf "oge", %a, %b : f32
-  return %r : i1
-}
+  func.func @oge_f32(%a : f32, %b : f32) -> i1 {
+    %r = arith.cmpf "oge", %a, %b : f32
+    return %r : i1
+  }
 
-func.func @oeq_f64(%a : f64, %b : f64) -> i1 {
-  %r = arith.cmpf "oeq", %a, %b : f64
-  return %r : i1
-}
+  func.func @oeq_f64(%a : f64, %b : f64) -> i1 {
+    %r = arith.cmpf "oeq", %a, %b : f64
+    return %r : i1
+  }
 
-func.func @one_f64(%a : f64, %b : f64) -> i1 {
-  %r = arith.cmpf "one", %a, %b : f64
-  return %r : i1
-}
-
-func.func @olt_f64(%a : f64, %b : f64) -> i1 {
-  %r = arith.cmpf "olt", %a, %b : f64
-  return %r : i1
-}
+  func.func @one_f64(%a : f64, %b : f64) -> i1 {
+    %r = arith.cmpf "one", %a, %b : f64
+    return %r : i1
+  }
 
-func.func @ole_f64(%a : f64, %b : f64) -> i1 {
-  %r = arith.cmpf "ole", %a, %b : f64
-  return %r : i1
-}
+  func.func @olt_f64(%a : f64, %b : f64) -> i1 {
+    %r = arith.cmpf "olt", %a, %b : f64
+    return %r : i1
+  }
 
-func.func @ogt_f64(%a : f64, %b : f64) -> i1 {
-  %r = arith.cmpf "ogt", %a, %b : f64
-  return %r : i1
-}
+  func.func @ole_f64(%a : f64, %b : f64) -> i1 {
+    %r = arith.cmpf "ole", %a, %b : f64
+    return %r : i1
+  }
 
-func.func @oge_f64(%a : f64, %b : f64) -> i1 {
-  %r = arith.cmpf "oge", %a, %b : f64
-  return %r : i1
-}
+  func.func @ogt_f64(%a : f64, %b : f64) -> i1 {
+    %r = arith.cmpf "ogt", %a, %b : f64
+    return %r : i1
+  }
 
+  func.func @oge_f64(%a : f64, %b : f64) -> i1 {
+    %r = arith.cmpf "oge", %a, %b : f64
+    return %r : i1
+  }
 }
diff --git a/arc-mlir/src/tests/arc-to-rust/arc-cmpf.mlir.rust-tests b/arc-mlir/src/tests/arc-to-rust/arc-cmpf.mlir.rust-tests
index bfd364166..b2afdd259 100644
--- a/arc-mlir/src/tests/arc-to-rust/arc-cmpf.mlir.rust-tests
+++ b/arc-mlir/src/tests/arc-to-rust/arc-cmpf.mlir.rust-tests
@@ -1,425 +1,1295 @@
 #[cfg(test)]
 mod tests {
-use crate::arctorustarcarccmpf::*;
+    use crate::arctorustarcarccmpf::*;
 
-#[rewrite(main)]
-#[test]
-  fn test_0() {
-    assert_eq!(call!(oeq_f32(-3.14000000000000012434e+00, -1.00000000000000000000e+00)), false);
-    assert_eq!(call!(oeq_f32(-3.14000000000000012434e+00, 0.00000000000000000000e+00)), false);
-    assert_eq!(call!(oeq_f32(-3.14000000000000012434e+00, 1.00000000000000000000e+00)), false);
-    assert_eq!(call!(oeq_f32(-3.14000000000000012434e+00, 3.14000000000000012434e+00)), false);
-    assert_eq!(call!(oeq_f32(-1.00000000000000000000e+00, -3.14000000000000012434e+00)), false);
-    assert_eq!(call!(oeq_f32(-1.00000000000000000000e+00, 0.00000000000000000000e+00)), false);
-    assert_eq!(call!(oeq_f32(-1.00000000000000000000e+00, 1.00000000000000000000e+00)), false);
-    assert_eq!(call!(oeq_f32(-1.00000000000000000000e+00, 3.14000000000000012434e+00)), false);
-    assert_eq!(call!(oeq_f32(0.00000000000000000000e+00, -3.14000000000000012434e+00)), false);
-    assert_eq!(call!(oeq_f32(0.00000000000000000000e+00, -1.00000000000000000000e+00)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_1() {
-    assert_eq!(call!(oeq_f32(0.00000000000000000000e+00, 1.00000000000000000000e+00)), false);
-    assert_eq!(call!(oeq_f32(0.00000000000000000000e+00, 3.14000000000000012434e+00)), false);
-    assert_eq!(call!(oeq_f32(1.00000000000000000000e+00, -3.14000000000000012434e+00)), false);
-    assert_eq!(call!(oeq_f32(1.00000000000000000000e+00, -1.00000000000000000000e+00)), false);
-    assert_eq!(call!(oeq_f32(1.00000000000000000000e+00, 0.00000000000000000000e+00)), false);
-    assert_eq!(call!(oeq_f32(1.00000000000000000000e+00, 3.14000000000000012434e+00)), false);
-    assert_eq!(call!(oeq_f32(3.14000000000000012434e+00, -3.14000000000000012434e+00)), false);
-    assert_eq!(call!(oeq_f32(3.14000000000000012434e+00, -1.00000000000000000000e+00)), false);
-    assert_eq!(call!(oeq_f32(3.14000000000000012434e+00, 0.00000000000000000000e+00)), false);
-    assert_eq!(call!(oeq_f32(3.14000000000000012434e+00, 1.00000000000000000000e+00)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_2() {
-    assert_eq!(call!(oeq_f32(-3.14000000000000012434e+00, -3.14000000000000012434e+00)), true);
-    assert_eq!(call!(oeq_f32(-1.00000000000000000000e+00, -1.00000000000000000000e+00)), true);
-    assert_eq!(call!(oeq_f32(0.00000000000000000000e+00, 0.00000000000000000000e+00)), true);
-    assert_eq!(call!(oeq_f32(1.00000000000000000000e+00, 1.00000000000000000000e+00)), true);
-    assert_eq!(call!(oeq_f32(3.14000000000000012434e+00, 3.14000000000000012434e+00)), true);
-    assert_eq!(call!(oeq_f64(-3.14000000000000012434e+00, -1.00000000000000000000e+00)), false);
-    assert_eq!(call!(oeq_f64(-3.14000000000000012434e+00, 0.00000000000000000000e+00)), false);
-    assert_eq!(call!(oeq_f64(-3.14000000000000012434e+00, 1.00000000000000000000e+00)), false);
-    assert_eq!(call!(oeq_f64(-3.14000000000000012434e+00, 3.14000000000000012434e+00)), false);
-    assert_eq!(call!(oeq_f64(-1.00000000000000000000e+00, -3.14000000000000012434e+00)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_3() {
-    assert_eq!(call!(oeq_f64(-1.00000000000000000000e+00, 0.00000000000000000000e+00)), false);
-    assert_eq!(call!(oeq_f64(-1.00000000000000000000e+00, 1.00000000000000000000e+00)), false);
-    assert_eq!(call!(oeq_f64(-1.00000000000000000000e+00, 3.14000000000000012434e+00)), false);
-    assert_eq!(call!(oeq_f64(0.00000000000000000000e+00, -3.14000000000000012434e+00)), false);
-    assert_eq!(call!(oeq_f64(0.00000000000000000000e+00, -1.00000000000000000000e+00)), false);
-    assert_eq!(call!(oeq_f64(0.00000000000000000000e+00, 1.00000000000000000000e+00)), false);
-    assert_eq!(call!(oeq_f64(0.00000000000000000000e+00, 3.14000000000000012434e+00)), false);
-    assert_eq!(call!(oeq_f64(1.00000000000000000000e+00, -3.14000000000000012434e+00)), false);
-    assert_eq!(call!(oeq_f64(1.00000000000000000000e+00, -1.00000000000000000000e+00)), false);
-    assert_eq!(call!(oeq_f64(1.00000000000000000000e+00, 0.00000000000000000000e+00)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_4() {
-    assert_eq!(call!(oeq_f64(1.00000000000000000000e+00, 3.14000000000000012434e+00)), false);
-    assert_eq!(call!(oeq_f64(3.14000000000000012434e+00, -3.14000000000000012434e+00)), false);
-    assert_eq!(call!(oeq_f64(3.14000000000000012434e+00, -1.00000000000000000000e+00)), false);
-    assert_eq!(call!(oeq_f64(3.14000000000000012434e+00, 0.00000000000000000000e+00)), false);
-    assert_eq!(call!(oeq_f64(3.14000000000000012434e+00, 1.00000000000000000000e+00)), false);
-    assert_eq!(call!(oeq_f64(-3.14000000000000012434e+00, -3.14000000000000012434e+00)), true);
-    assert_eq!(call!(oeq_f64(-1.00000000000000000000e+00, -1.00000000000000000000e+00)), true);
-    assert_eq!(call!(oeq_f64(0.00000000000000000000e+00, 0.00000000000000000000e+00)), true);
-    assert_eq!(call!(oeq_f64(1.00000000000000000000e+00, 1.00000000000000000000e+00)), true);
-    assert_eq!(call!(oeq_f64(3.14000000000000012434e+00, 3.14000000000000012434e+00)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_5() {
-    assert_eq!(call!(oge_f32(-3.14000000000000012434e+00, -1.00000000000000000000e+00)), false);
-    assert_eq!(call!(oge_f32(-3.14000000000000012434e+00, 0.00000000000000000000e+00)), false);
-    assert_eq!(call!(oge_f32(-3.14000000000000012434e+00, 1.00000000000000000000e+00)), false);
-    assert_eq!(call!(oge_f32(-3.14000000000000012434e+00, 3.14000000000000012434e+00)), false);
-    assert_eq!(call!(oge_f32(-1.00000000000000000000e+00, 0.00000000000000000000e+00)), false);
-    assert_eq!(call!(oge_f32(-1.00000000000000000000e+00, 1.00000000000000000000e+00)), false);
-    assert_eq!(call!(oge_f32(-1.00000000000000000000e+00, 3.14000000000000012434e+00)), false);
-    assert_eq!(call!(oge_f32(0.00000000000000000000e+00, 1.00000000000000000000e+00)), false);
-    assert_eq!(call!(oge_f32(0.00000000000000000000e+00, 3.14000000000000012434e+00)), false);
-    assert_eq!(call!(oge_f32(1.00000000000000000000e+00, 3.14000000000000012434e+00)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_6() {
-    assert_eq!(call!(oge_f32(-3.14000000000000012434e+00, -3.14000000000000012434e+00)), true);
-    assert_eq!(call!(oge_f32(-1.00000000000000000000e+00, -3.14000000000000012434e+00)), true);
-    assert_eq!(call!(oge_f32(-1.00000000000000000000e+00, -1.00000000000000000000e+00)), true);
-    assert_eq!(call!(oge_f32(0.00000000000000000000e+00, -3.14000000000000012434e+00)), true);
-    assert_eq!(call!(oge_f32(0.00000000000000000000e+00, -1.00000000000000000000e+00)), true);
-    assert_eq!(call!(oge_f32(0.00000000000000000000e+00, 0.00000000000000000000e+00)), true);
-    assert_eq!(call!(oge_f32(1.00000000000000000000e+00, -3.14000000000000012434e+00)), true);
-    assert_eq!(call!(oge_f32(1.00000000000000000000e+00, -1.00000000000000000000e+00)), true);
-    assert_eq!(call!(oge_f32(1.00000000000000000000e+00, 0.00000000000000000000e+00)), true);
-    assert_eq!(call!(oge_f32(1.00000000000000000000e+00, 1.00000000000000000000e+00)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_7() {
-    assert_eq!(call!(oge_f32(3.14000000000000012434e+00, -3.14000000000000012434e+00)), true);
-    assert_eq!(call!(oge_f32(3.14000000000000012434e+00, -1.00000000000000000000e+00)), true);
-    assert_eq!(call!(oge_f32(3.14000000000000012434e+00, 0.00000000000000000000e+00)), true);
-    assert_eq!(call!(oge_f32(3.14000000000000012434e+00, 1.00000000000000000000e+00)), true);
-    assert_eq!(call!(oge_f32(3.14000000000000012434e+00, 3.14000000000000012434e+00)), true);
-    assert_eq!(call!(oge_f64(-3.14000000000000012434e+00, -1.00000000000000000000e+00)), false);
-    assert_eq!(call!(oge_f64(-3.14000000000000012434e+00, 0.00000000000000000000e+00)), false);
-    assert_eq!(call!(oge_f64(-3.14000000000000012434e+00, 1.00000000000000000000e+00)), false);
-    assert_eq!(call!(oge_f64(-3.14000000000000012434e+00, 3.14000000000000012434e+00)), false);
-    assert_eq!(call!(oge_f64(-1.00000000000000000000e+00, 0.00000000000000000000e+00)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_8() {
-    assert_eq!(call!(oge_f64(-1.00000000000000000000e+00, 1.00000000000000000000e+00)), false);
-    assert_eq!(call!(oge_f64(-1.00000000000000000000e+00, 3.14000000000000012434e+00)), false);
-    assert_eq!(call!(oge_f64(0.00000000000000000000e+00, 1.00000000000000000000e+00)), false);
-    assert_eq!(call!(oge_f64(0.00000000000000000000e+00, 3.14000000000000012434e+00)), false);
-    assert_eq!(call!(oge_f64(1.00000000000000000000e+00, 3.14000000000000012434e+00)), false);
-    assert_eq!(call!(oge_f64(-3.14000000000000012434e+00, -3.14000000000000012434e+00)), true);
-    assert_eq!(call!(oge_f64(-1.00000000000000000000e+00, -3.14000000000000012434e+00)), true);
-    assert_eq!(call!(oge_f64(-1.00000000000000000000e+00, -1.00000000000000000000e+00)), true);
-    assert_eq!(call!(oge_f64(0.00000000000000000000e+00, -3.14000000000000012434e+00)), true);
-    assert_eq!(call!(oge_f64(0.00000000000000000000e+00, -1.00000000000000000000e+00)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_9() {
-    assert_eq!(call!(oge_f64(0.00000000000000000000e+00, 0.00000000000000000000e+00)), true);
-    assert_eq!(call!(oge_f64(1.00000000000000000000e+00, -3.14000000000000012434e+00)), true);
-    assert_eq!(call!(oge_f64(1.00000000000000000000e+00, -1.00000000000000000000e+00)), true);
-    assert_eq!(call!(oge_f64(1.00000000000000000000e+00, 0.00000000000000000000e+00)), true);
-    assert_eq!(call!(oge_f64(1.00000000000000000000e+00, 1.00000000000000000000e+00)), true);
-    assert_eq!(call!(oge_f64(3.14000000000000012434e+00, -3.14000000000000012434e+00)), true);
-    assert_eq!(call!(oge_f64(3.14000000000000012434e+00, -1.00000000000000000000e+00)), true);
-    assert_eq!(call!(oge_f64(3.14000000000000012434e+00, 0.00000000000000000000e+00)), true);
-    assert_eq!(call!(oge_f64(3.14000000000000012434e+00, 1.00000000000000000000e+00)), true);
-    assert_eq!(call!(oge_f64(3.14000000000000012434e+00, 3.14000000000000012434e+00)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_10() {
-    assert_eq!(call!(ogt_f32(-3.14000000000000012434e+00, -3.14000000000000012434e+00)), false);
-    assert_eq!(call!(ogt_f32(-3.14000000000000012434e+00, -1.00000000000000000000e+00)), false);
-    assert_eq!(call!(ogt_f32(-3.14000000000000012434e+00, 0.00000000000000000000e+00)), false);
-    assert_eq!(call!(ogt_f32(-3.14000000000000012434e+00, 1.00000000000000000000e+00)), false);
-    assert_eq!(call!(ogt_f32(-3.14000000000000012434e+00, 3.14000000000000012434e+00)), false);
-    assert_eq!(call!(ogt_f32(-1.00000000000000000000e+00, -1.00000000000000000000e+00)), false);
-    assert_eq!(call!(ogt_f32(-1.00000000000000000000e+00, 0.00000000000000000000e+00)), false);
-    assert_eq!(call!(ogt_f32(-1.00000000000000000000e+00, 1.00000000000000000000e+00)), false);
-    assert_eq!(call!(ogt_f32(-1.00000000000000000000e+00, 3.14000000000000012434e+00)), false);
-    assert_eq!(call!(ogt_f32(0.00000000000000000000e+00, 0.00000000000000000000e+00)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_11() {
-    assert_eq!(call!(ogt_f32(0.00000000000000000000e+00, 1.00000000000000000000e+00)), false);
-    assert_eq!(call!(ogt_f32(0.00000000000000000000e+00, 3.14000000000000012434e+00)), false);
-    assert_eq!(call!(ogt_f32(1.00000000000000000000e+00, 1.00000000000000000000e+00)), false);
-    assert_eq!(call!(ogt_f32(1.00000000000000000000e+00, 3.14000000000000012434e+00)), false);
-    assert_eq!(call!(ogt_f32(3.14000000000000012434e+00, 3.14000000000000012434e+00)), false);
-    assert_eq!(call!(ogt_f32(-1.00000000000000000000e+00, -3.14000000000000012434e+00)), true);
-    assert_eq!(call!(ogt_f32(0.00000000000000000000e+00, -3.14000000000000012434e+00)), true);
-    assert_eq!(call!(ogt_f32(0.00000000000000000000e+00, -1.00000000000000000000e+00)), true);
-    assert_eq!(call!(ogt_f32(1.00000000000000000000e+00, -3.14000000000000012434e+00)), true);
-    assert_eq!(call!(ogt_f32(1.00000000000000000000e+00, -1.00000000000000000000e+00)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_12() {
-    assert_eq!(call!(ogt_f32(1.00000000000000000000e+00, 0.00000000000000000000e+00)), true);
-    assert_eq!(call!(ogt_f32(3.14000000000000012434e+00, -3.14000000000000012434e+00)), true);
-    assert_eq!(call!(ogt_f32(3.14000000000000012434e+00, -1.00000000000000000000e+00)), true);
-    assert_eq!(call!(ogt_f32(3.14000000000000012434e+00, 0.00000000000000000000e+00)), true);
-    assert_eq!(call!(ogt_f32(3.14000000000000012434e+00, 1.00000000000000000000e+00)), true);
-    assert_eq!(call!(ogt_f64(-3.14000000000000012434e+00, -3.14000000000000012434e+00)), false);
-    assert_eq!(call!(ogt_f64(-3.14000000000000012434e+00, -1.00000000000000000000e+00)), false);
-    assert_eq!(call!(ogt_f64(-3.14000000000000012434e+00, 0.00000000000000000000e+00)), false);
-    assert_eq!(call!(ogt_f64(-3.14000000000000012434e+00, 1.00000000000000000000e+00)), false);
-    assert_eq!(call!(ogt_f64(-3.14000000000000012434e+00, 3.14000000000000012434e+00)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_13() {
-    assert_eq!(call!(ogt_f64(-1.00000000000000000000e+00, -1.00000000000000000000e+00)), false);
-    assert_eq!(call!(ogt_f64(-1.00000000000000000000e+00, 0.00000000000000000000e+00)), false);
-    assert_eq!(call!(ogt_f64(-1.00000000000000000000e+00, 1.00000000000000000000e+00)), false);
-    assert_eq!(call!(ogt_f64(-1.00000000000000000000e+00, 3.14000000000000012434e+00)), false);
-    assert_eq!(call!(ogt_f64(0.00000000000000000000e+00, 0.00000000000000000000e+00)), false);
-    assert_eq!(call!(ogt_f64(0.00000000000000000000e+00, 1.00000000000000000000e+00)), false);
-    assert_eq!(call!(ogt_f64(0.00000000000000000000e+00, 3.14000000000000012434e+00)), false);
-    assert_eq!(call!(ogt_f64(1.00000000000000000000e+00, 1.00000000000000000000e+00)), false);
-    assert_eq!(call!(ogt_f64(1.00000000000000000000e+00, 3.14000000000000012434e+00)), false);
-    assert_eq!(call!(ogt_f64(3.14000000000000012434e+00, 3.14000000000000012434e+00)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_14() {
-    assert_eq!(call!(ogt_f64(-1.00000000000000000000e+00, -3.14000000000000012434e+00)), true);
-    assert_eq!(call!(ogt_f64(0.00000000000000000000e+00, -3.14000000000000012434e+00)), true);
-    assert_eq!(call!(ogt_f64(0.00000000000000000000e+00, -1.00000000000000000000e+00)), true);
-    assert_eq!(call!(ogt_f64(1.00000000000000000000e+00, -3.14000000000000012434e+00)), true);
-    assert_eq!(call!(ogt_f64(1.00000000000000000000e+00, -1.00000000000000000000e+00)), true);
-    assert_eq!(call!(ogt_f64(1.00000000000000000000e+00, 0.00000000000000000000e+00)), true);
-    assert_eq!(call!(ogt_f64(3.14000000000000012434e+00, -3.14000000000000012434e+00)), true);
-    assert_eq!(call!(ogt_f64(3.14000000000000012434e+00, -1.00000000000000000000e+00)), true);
-    assert_eq!(call!(ogt_f64(3.14000000000000012434e+00, 0.00000000000000000000e+00)), true);
-    assert_eq!(call!(ogt_f64(3.14000000000000012434e+00, 1.00000000000000000000e+00)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_15() {
-    assert_eq!(call!(ole_f32(-1.00000000000000000000e+00, -3.14000000000000012434e+00)), false);
-    assert_eq!(call!(ole_f32(0.00000000000000000000e+00, -3.14000000000000012434e+00)), false);
-    assert_eq!(call!(ole_f32(0.00000000000000000000e+00, -1.00000000000000000000e+00)), false);
-    assert_eq!(call!(ole_f32(1.00000000000000000000e+00, -3.14000000000000012434e+00)), false);
-    assert_eq!(call!(ole_f32(1.00000000000000000000e+00, -1.00000000000000000000e+00)), false);
-    assert_eq!(call!(ole_f32(1.00000000000000000000e+00, 0.00000000000000000000e+00)), false);
-    assert_eq!(call!(ole_f32(3.14000000000000012434e+00, -3.14000000000000012434e+00)), false);
-    assert_eq!(call!(ole_f32(3.14000000000000012434e+00, -1.00000000000000000000e+00)), false);
-    assert_eq!(call!(ole_f32(3.14000000000000012434e+00, 0.00000000000000000000e+00)), false);
-    assert_eq!(call!(ole_f32(3.14000000000000012434e+00, 1.00000000000000000000e+00)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_16() {
-    assert_eq!(call!(ole_f32(-3.14000000000000012434e+00, -3.14000000000000012434e+00)), true);
-    assert_eq!(call!(ole_f32(-3.14000000000000012434e+00, -1.00000000000000000000e+00)), true);
-    assert_eq!(call!(ole_f32(-3.14000000000000012434e+00, 0.00000000000000000000e+00)), true);
-    assert_eq!(call!(ole_f32(-3.14000000000000012434e+00, 1.00000000000000000000e+00)), true);
-    assert_eq!(call!(ole_f32(-3.14000000000000012434e+00, 3.14000000000000012434e+00)), true);
-    assert_eq!(call!(ole_f32(-1.00000000000000000000e+00, -1.00000000000000000000e+00)), true);
-    assert_eq!(call!(ole_f32(-1.00000000000000000000e+00, 0.00000000000000000000e+00)), true);
-    assert_eq!(call!(ole_f32(-1.00000000000000000000e+00, 1.00000000000000000000e+00)), true);
-    assert_eq!(call!(ole_f32(-1.00000000000000000000e+00, 3.14000000000000012434e+00)), true);
-    assert_eq!(call!(ole_f32(0.00000000000000000000e+00, 0.00000000000000000000e+00)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_17() {
-    assert_eq!(call!(ole_f32(0.00000000000000000000e+00, 1.00000000000000000000e+00)), true);
-    assert_eq!(call!(ole_f32(0.00000000000000000000e+00, 3.14000000000000012434e+00)), true);
-    assert_eq!(call!(ole_f32(1.00000000000000000000e+00, 1.00000000000000000000e+00)), true);
-    assert_eq!(call!(ole_f32(1.00000000000000000000e+00, 3.14000000000000012434e+00)), true);
-    assert_eq!(call!(ole_f32(3.14000000000000012434e+00, 3.14000000000000012434e+00)), true);
-    assert_eq!(call!(ole_f64(-1.00000000000000000000e+00, -3.14000000000000012434e+00)), false);
-    assert_eq!(call!(ole_f64(0.00000000000000000000e+00, -3.14000000000000012434e+00)), false);
-    assert_eq!(call!(ole_f64(0.00000000000000000000e+00, -1.00000000000000000000e+00)), false);
-    assert_eq!(call!(ole_f64(1.00000000000000000000e+00, -3.14000000000000012434e+00)), false);
-    assert_eq!(call!(ole_f64(1.00000000000000000000e+00, -1.00000000000000000000e+00)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_18() {
-    assert_eq!(call!(ole_f64(1.00000000000000000000e+00, 0.00000000000000000000e+00)), false);
-    assert_eq!(call!(ole_f64(3.14000000000000012434e+00, -3.14000000000000012434e+00)), false);
-    assert_eq!(call!(ole_f64(3.14000000000000012434e+00, -1.00000000000000000000e+00)), false);
-    assert_eq!(call!(ole_f64(3.14000000000000012434e+00, 0.00000000000000000000e+00)), false);
-    assert_eq!(call!(ole_f64(3.14000000000000012434e+00, 1.00000000000000000000e+00)), false);
-    assert_eq!(call!(ole_f64(-3.14000000000000012434e+00, -3.14000000000000012434e+00)), true);
-    assert_eq!(call!(ole_f64(-3.14000000000000012434e+00, -1.00000000000000000000e+00)), true);
-    assert_eq!(call!(ole_f64(-3.14000000000000012434e+00, 0.00000000000000000000e+00)), true);
-    assert_eq!(call!(ole_f64(-3.14000000000000012434e+00, 1.00000000000000000000e+00)), true);
-    assert_eq!(call!(ole_f64(-3.14000000000000012434e+00, 3.14000000000000012434e+00)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_19() {
-    assert_eq!(call!(ole_f64(-1.00000000000000000000e+00, -1.00000000000000000000e+00)), true);
-    assert_eq!(call!(ole_f64(-1.00000000000000000000e+00, 0.00000000000000000000e+00)), true);
-    assert_eq!(call!(ole_f64(-1.00000000000000000000e+00, 1.00000000000000000000e+00)), true);
-    assert_eq!(call!(ole_f64(-1.00000000000000000000e+00, 3.14000000000000012434e+00)), true);
-    assert_eq!(call!(ole_f64(0.00000000000000000000e+00, 0.00000000000000000000e+00)), true);
-    assert_eq!(call!(ole_f64(0.00000000000000000000e+00, 1.00000000000000000000e+00)), true);
-    assert_eq!(call!(ole_f64(0.00000000000000000000e+00, 3.14000000000000012434e+00)), true);
-    assert_eq!(call!(ole_f64(1.00000000000000000000e+00, 1.00000000000000000000e+00)), true);
-    assert_eq!(call!(ole_f64(1.00000000000000000000e+00, 3.14000000000000012434e+00)), true);
-    assert_eq!(call!(ole_f64(3.14000000000000012434e+00, 3.14000000000000012434e+00)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_20() {
-    assert_eq!(call!(olt_f32(-3.14000000000000012434e+00, -3.14000000000000012434e+00)), false);
-    assert_eq!(call!(olt_f32(-1.00000000000000000000e+00, -3.14000000000000012434e+00)), false);
-    assert_eq!(call!(olt_f32(-1.00000000000000000000e+00, -1.00000000000000000000e+00)), false);
-    assert_eq!(call!(olt_f32(0.00000000000000000000e+00, -3.14000000000000012434e+00)), false);
-    assert_eq!(call!(olt_f32(0.00000000000000000000e+00, -1.00000000000000000000e+00)), false);
-    assert_eq!(call!(olt_f32(0.00000000000000000000e+00, 0.00000000000000000000e+00)), false);
-    assert_eq!(call!(olt_f32(1.00000000000000000000e+00, -3.14000000000000012434e+00)), false);
-    assert_eq!(call!(olt_f32(1.00000000000000000000e+00, -1.00000000000000000000e+00)), false);
-    assert_eq!(call!(olt_f32(1.00000000000000000000e+00, 0.00000000000000000000e+00)), false);
-    assert_eq!(call!(olt_f32(1.00000000000000000000e+00, 1.00000000000000000000e+00)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_21() {
-    assert_eq!(call!(olt_f32(3.14000000000000012434e+00, -3.14000000000000012434e+00)), false);
-    assert_eq!(call!(olt_f32(3.14000000000000012434e+00, -1.00000000000000000000e+00)), false);
-    assert_eq!(call!(olt_f32(3.14000000000000012434e+00, 0.00000000000000000000e+00)), false);
-    assert_eq!(call!(olt_f32(3.14000000000000012434e+00, 1.00000000000000000000e+00)), false);
-    assert_eq!(call!(olt_f32(3.14000000000000012434e+00, 3.14000000000000012434e+00)), false);
-    assert_eq!(call!(olt_f32(-3.14000000000000012434e+00, -1.00000000000000000000e+00)), true);
-    assert_eq!(call!(olt_f32(-3.14000000000000012434e+00, 0.00000000000000000000e+00)), true);
-    assert_eq!(call!(olt_f32(-3.14000000000000012434e+00, 1.00000000000000000000e+00)), true);
-    assert_eq!(call!(olt_f32(-3.14000000000000012434e+00, 3.14000000000000012434e+00)), true);
-    assert_eq!(call!(olt_f32(-1.00000000000000000000e+00, 0.00000000000000000000e+00)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_22() {
-    assert_eq!(call!(olt_f32(-1.00000000000000000000e+00, 1.00000000000000000000e+00)), true);
-    assert_eq!(call!(olt_f32(-1.00000000000000000000e+00, 3.14000000000000012434e+00)), true);
-    assert_eq!(call!(olt_f32(0.00000000000000000000e+00, 1.00000000000000000000e+00)), true);
-    assert_eq!(call!(olt_f32(0.00000000000000000000e+00, 3.14000000000000012434e+00)), true);
-    assert_eq!(call!(olt_f32(1.00000000000000000000e+00, 3.14000000000000012434e+00)), true);
-    assert_eq!(call!(olt_f64(-3.14000000000000012434e+00, -3.14000000000000012434e+00)), false);
-    assert_eq!(call!(olt_f64(-1.00000000000000000000e+00, -3.14000000000000012434e+00)), false);
-    assert_eq!(call!(olt_f64(-1.00000000000000000000e+00, -1.00000000000000000000e+00)), false);
-    assert_eq!(call!(olt_f64(0.00000000000000000000e+00, -3.14000000000000012434e+00)), false);
-    assert_eq!(call!(olt_f64(0.00000000000000000000e+00, -1.00000000000000000000e+00)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_23() {
-    assert_eq!(call!(olt_f64(0.00000000000000000000e+00, 0.00000000000000000000e+00)), false);
-    assert_eq!(call!(olt_f64(1.00000000000000000000e+00, -3.14000000000000012434e+00)), false);
-    assert_eq!(call!(olt_f64(1.00000000000000000000e+00, -1.00000000000000000000e+00)), false);
-    assert_eq!(call!(olt_f64(1.00000000000000000000e+00, 0.00000000000000000000e+00)), false);
-    assert_eq!(call!(olt_f64(1.00000000000000000000e+00, 1.00000000000000000000e+00)), false);
-    assert_eq!(call!(olt_f64(3.14000000000000012434e+00, -3.14000000000000012434e+00)), false);
-    assert_eq!(call!(olt_f64(3.14000000000000012434e+00, -1.00000000000000000000e+00)), false);
-    assert_eq!(call!(olt_f64(3.14000000000000012434e+00, 0.00000000000000000000e+00)), false);
-    assert_eq!(call!(olt_f64(3.14000000000000012434e+00, 1.00000000000000000000e+00)), false);
-    assert_eq!(call!(olt_f64(3.14000000000000012434e+00, 3.14000000000000012434e+00)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_24() {
-    assert_eq!(call!(olt_f64(-3.14000000000000012434e+00, -1.00000000000000000000e+00)), true);
-    assert_eq!(call!(olt_f64(-3.14000000000000012434e+00, 0.00000000000000000000e+00)), true);
-    assert_eq!(call!(olt_f64(-3.14000000000000012434e+00, 1.00000000000000000000e+00)), true);
-    assert_eq!(call!(olt_f64(-3.14000000000000012434e+00, 3.14000000000000012434e+00)), true);
-    assert_eq!(call!(olt_f64(-1.00000000000000000000e+00, 0.00000000000000000000e+00)), true);
-    assert_eq!(call!(olt_f64(-1.00000000000000000000e+00, 1.00000000000000000000e+00)), true);
-    assert_eq!(call!(olt_f64(-1.00000000000000000000e+00, 3.14000000000000012434e+00)), true);
-    assert_eq!(call!(olt_f64(0.00000000000000000000e+00, 1.00000000000000000000e+00)), true);
-    assert_eq!(call!(olt_f64(0.00000000000000000000e+00, 3.14000000000000012434e+00)), true);
-    assert_eq!(call!(olt_f64(1.00000000000000000000e+00, 3.14000000000000012434e+00)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_25() {
-    assert_eq!(call!(one_f32(-3.14000000000000012434e+00, -3.14000000000000012434e+00)), false);
-    assert_eq!(call!(one_f32(-1.00000000000000000000e+00, -1.00000000000000000000e+00)), false);
-    assert_eq!(call!(one_f32(0.00000000000000000000e+00, 0.00000000000000000000e+00)), false);
-    assert_eq!(call!(one_f32(1.00000000000000000000e+00, 1.00000000000000000000e+00)), false);
-    assert_eq!(call!(one_f32(3.14000000000000012434e+00, 3.14000000000000012434e+00)), false);
-    assert_eq!(call!(one_f32(-3.14000000000000012434e+00, -1.00000000000000000000e+00)), true);
-    assert_eq!(call!(one_f32(-3.14000000000000012434e+00, 0.00000000000000000000e+00)), true);
-    assert_eq!(call!(one_f32(-3.14000000000000012434e+00, 1.00000000000000000000e+00)), true);
-    assert_eq!(call!(one_f32(-3.14000000000000012434e+00, 3.14000000000000012434e+00)), true);
-    assert_eq!(call!(one_f32(-1.00000000000000000000e+00, -3.14000000000000012434e+00)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_26() {
-    assert_eq!(call!(one_f32(-1.00000000000000000000e+00, 0.00000000000000000000e+00)), true);
-    assert_eq!(call!(one_f32(-1.00000000000000000000e+00, 1.00000000000000000000e+00)), true);
-    assert_eq!(call!(one_f32(-1.00000000000000000000e+00, 3.14000000000000012434e+00)), true);
-    assert_eq!(call!(one_f32(0.00000000000000000000e+00, -3.14000000000000012434e+00)), true);
-    assert_eq!(call!(one_f32(0.00000000000000000000e+00, -1.00000000000000000000e+00)), true);
-    assert_eq!(call!(one_f32(0.00000000000000000000e+00, 1.00000000000000000000e+00)), true);
-    assert_eq!(call!(one_f32(0.00000000000000000000e+00, 3.14000000000000012434e+00)), true);
-    assert_eq!(call!(one_f32(1.00000000000000000000e+00, -3.14000000000000012434e+00)), true);
-    assert_eq!(call!(one_f32(1.00000000000000000000e+00, -1.00000000000000000000e+00)), true);
-    assert_eq!(call!(one_f32(1.00000000000000000000e+00, 0.00000000000000000000e+00)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_27() {
-    assert_eq!(call!(one_f32(1.00000000000000000000e+00, 3.14000000000000012434e+00)), true);
-    assert_eq!(call!(one_f32(3.14000000000000012434e+00, -3.14000000000000012434e+00)), true);
-    assert_eq!(call!(one_f32(3.14000000000000012434e+00, -1.00000000000000000000e+00)), true);
-    assert_eq!(call!(one_f32(3.14000000000000012434e+00, 0.00000000000000000000e+00)), true);
-    assert_eq!(call!(one_f32(3.14000000000000012434e+00, 1.00000000000000000000e+00)), true);
-    assert_eq!(call!(one_f64(-3.14000000000000012434e+00, -3.14000000000000012434e+00)), false);
-    assert_eq!(call!(one_f64(-1.00000000000000000000e+00, -1.00000000000000000000e+00)), false);
-    assert_eq!(call!(one_f64(0.00000000000000000000e+00, 0.00000000000000000000e+00)), false);
-    assert_eq!(call!(one_f64(1.00000000000000000000e+00, 1.00000000000000000000e+00)), false);
-    assert_eq!(call!(one_f64(3.14000000000000012434e+00, 3.14000000000000012434e+00)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_28() {
-    assert_eq!(call!(one_f64(-3.14000000000000012434e+00, -1.00000000000000000000e+00)), true);
-    assert_eq!(call!(one_f64(-3.14000000000000012434e+00, 0.00000000000000000000e+00)), true);
-    assert_eq!(call!(one_f64(-3.14000000000000012434e+00, 1.00000000000000000000e+00)), true);
-    assert_eq!(call!(one_f64(-3.14000000000000012434e+00, 3.14000000000000012434e+00)), true);
-    assert_eq!(call!(one_f64(-1.00000000000000000000e+00, -3.14000000000000012434e+00)), true);
-    assert_eq!(call!(one_f64(-1.00000000000000000000e+00, 0.00000000000000000000e+00)), true);
-    assert_eq!(call!(one_f64(-1.00000000000000000000e+00, 1.00000000000000000000e+00)), true);
-    assert_eq!(call!(one_f64(-1.00000000000000000000e+00, 3.14000000000000012434e+00)), true);
-    assert_eq!(call!(one_f64(0.00000000000000000000e+00, -3.14000000000000012434e+00)), true);
-    assert_eq!(call!(one_f64(0.00000000000000000000e+00, -1.00000000000000000000e+00)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_29() {
-    assert_eq!(call!(one_f64(0.00000000000000000000e+00, 1.00000000000000000000e+00)), true);
-    assert_eq!(call!(one_f64(0.00000000000000000000e+00, 3.14000000000000012434e+00)), true);
-    assert_eq!(call!(one_f64(1.00000000000000000000e+00, -3.14000000000000012434e+00)), true);
-    assert_eq!(call!(one_f64(1.00000000000000000000e+00, -1.00000000000000000000e+00)), true);
-    assert_eq!(call!(one_f64(1.00000000000000000000e+00, 0.00000000000000000000e+00)), true);
-    assert_eq!(call!(one_f64(1.00000000000000000000e+00, 3.14000000000000012434e+00)), true);
-    assert_eq!(call!(one_f64(3.14000000000000012434e+00, -3.14000000000000012434e+00)), true);
-    assert_eq!(call!(one_f64(3.14000000000000012434e+00, -1.00000000000000000000e+00)), true);
-    assert_eq!(call!(one_f64(3.14000000000000012434e+00, 0.00000000000000000000e+00)), true);
-    assert_eq!(call!(one_f64(3.14000000000000012434e+00, 1.00000000000000000000e+00)), true);
-  }
+    #[test]
+    fn test_0() {
+        assert_eq!(
+            oeq_f32(-3.14000000000000012434e+00, -1.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            oeq_f32(-3.14000000000000012434e+00, 0.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            oeq_f32(-3.14000000000000012434e+00, 1.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            oeq_f32(-3.14000000000000012434e+00, 3.14000000000000012434e+00),
+            false
+        );
+        assert_eq!(
+            oeq_f32(-1.00000000000000000000e+00, -3.14000000000000012434e+00),
+            false
+        );
+        assert_eq!(
+            oeq_f32(-1.00000000000000000000e+00, 0.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            oeq_f32(-1.00000000000000000000e+00, 1.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            oeq_f32(-1.00000000000000000000e+00, 3.14000000000000012434e+00),
+            false
+        );
+        assert_eq!(
+            oeq_f32(0.00000000000000000000e+00, -3.14000000000000012434e+00),
+            false
+        );
+        assert_eq!(
+            oeq_f32(0.00000000000000000000e+00, -1.00000000000000000000e+00),
+            false
+        );
+    }
+    #[test]
+    fn test_1() {
+        assert_eq!(
+            oeq_f32(0.00000000000000000000e+00, 1.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            oeq_f32(0.00000000000000000000e+00, 3.14000000000000012434e+00),
+            false
+        );
+        assert_eq!(
+            oeq_f32(1.00000000000000000000e+00, -3.14000000000000012434e+00),
+            false
+        );
+        assert_eq!(
+            oeq_f32(1.00000000000000000000e+00, -1.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            oeq_f32(1.00000000000000000000e+00, 0.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            oeq_f32(1.00000000000000000000e+00, 3.14000000000000012434e+00),
+            false
+        );
+        assert_eq!(
+            oeq_f32(3.14000000000000012434e+00, -3.14000000000000012434e+00),
+            false
+        );
+        assert_eq!(
+            oeq_f32(3.14000000000000012434e+00, -1.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            oeq_f32(3.14000000000000012434e+00, 0.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            oeq_f32(3.14000000000000012434e+00, 1.00000000000000000000e+00),
+            false
+        );
+    }
+    #[test]
+    fn test_2() {
+        assert_eq!(
+            oeq_f32(-3.14000000000000012434e+00, -3.14000000000000012434e+00),
+            true
+        );
+        assert_eq!(
+            oeq_f32(-1.00000000000000000000e+00, -1.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            oeq_f32(0.00000000000000000000e+00, 0.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            oeq_f32(1.00000000000000000000e+00, 1.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            oeq_f32(3.14000000000000012434e+00, 3.14000000000000012434e+00),
+            true
+        );
+        assert_eq!(
+            oeq_f64(-3.14000000000000012434e+00, -1.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            oeq_f64(-3.14000000000000012434e+00, 0.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            oeq_f64(-3.14000000000000012434e+00, 1.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            oeq_f64(-3.14000000000000012434e+00, 3.14000000000000012434e+00),
+            false
+        );
+        assert_eq!(
+            oeq_f64(-1.00000000000000000000e+00, -3.14000000000000012434e+00),
+            false
+        );
+    }
+    #[test]
+    fn test_3() {
+        assert_eq!(
+            oeq_f64(-1.00000000000000000000e+00, 0.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            oeq_f64(-1.00000000000000000000e+00, 1.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            oeq_f64(-1.00000000000000000000e+00, 3.14000000000000012434e+00),
+            false
+        );
+        assert_eq!(
+            oeq_f64(0.00000000000000000000e+00, -3.14000000000000012434e+00),
+            false
+        );
+        assert_eq!(
+            oeq_f64(0.00000000000000000000e+00, -1.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            oeq_f64(0.00000000000000000000e+00, 1.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            oeq_f64(0.00000000000000000000e+00, 3.14000000000000012434e+00),
+            false
+        );
+        assert_eq!(
+            oeq_f64(1.00000000000000000000e+00, -3.14000000000000012434e+00),
+            false
+        );
+        assert_eq!(
+            oeq_f64(1.00000000000000000000e+00, -1.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            oeq_f64(1.00000000000000000000e+00, 0.00000000000000000000e+00),
+            false
+        );
+    }
+    #[test]
+    fn test_4() {
+        assert_eq!(
+            oeq_f64(1.00000000000000000000e+00, 3.14000000000000012434e+00),
+            false
+        );
+        assert_eq!(
+            oeq_f64(3.14000000000000012434e+00, -3.14000000000000012434e+00),
+            false
+        );
+        assert_eq!(
+            oeq_f64(3.14000000000000012434e+00, -1.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            oeq_f64(3.14000000000000012434e+00, 0.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            oeq_f64(3.14000000000000012434e+00, 1.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            oeq_f64(-3.14000000000000012434e+00, -3.14000000000000012434e+00),
+            true
+        );
+        assert_eq!(
+            oeq_f64(-1.00000000000000000000e+00, -1.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            oeq_f64(0.00000000000000000000e+00, 0.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            oeq_f64(1.00000000000000000000e+00, 1.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            oeq_f64(3.14000000000000012434e+00, 3.14000000000000012434e+00),
+            true
+        );
+    }
+    #[test]
+    fn test_5() {
+        assert_eq!(
+            oge_f32(-3.14000000000000012434e+00, -1.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            oge_f32(-3.14000000000000012434e+00, 0.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            oge_f32(-3.14000000000000012434e+00, 1.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            oge_f32(-3.14000000000000012434e+00, 3.14000000000000012434e+00),
+            false
+        );
+        assert_eq!(
+            oge_f32(-1.00000000000000000000e+00, 0.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            oge_f32(-1.00000000000000000000e+00, 1.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            oge_f32(-1.00000000000000000000e+00, 3.14000000000000012434e+00),
+            false
+        );
+        assert_eq!(
+            oge_f32(0.00000000000000000000e+00, 1.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            oge_f32(0.00000000000000000000e+00, 3.14000000000000012434e+00),
+            false
+        );
+        assert_eq!(
+            oge_f32(1.00000000000000000000e+00, 3.14000000000000012434e+00),
+            false
+        );
+    }
+    #[test]
+    fn test_6() {
+        assert_eq!(
+            oge_f32(-3.14000000000000012434e+00, -3.14000000000000012434e+00),
+            true
+        );
+        assert_eq!(
+            oge_f32(-1.00000000000000000000e+00, -3.14000000000000012434e+00),
+            true
+        );
+        assert_eq!(
+            oge_f32(-1.00000000000000000000e+00, -1.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            oge_f32(0.00000000000000000000e+00, -3.14000000000000012434e+00),
+            true
+        );
+        assert_eq!(
+            oge_f32(0.00000000000000000000e+00, -1.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            oge_f32(0.00000000000000000000e+00, 0.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            oge_f32(1.00000000000000000000e+00, -3.14000000000000012434e+00),
+            true
+        );
+        assert_eq!(
+            oge_f32(1.00000000000000000000e+00, -1.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            oge_f32(1.00000000000000000000e+00, 0.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            oge_f32(1.00000000000000000000e+00, 1.00000000000000000000e+00),
+            true
+        );
+    }
+    #[test]
+    fn test_7() {
+        assert_eq!(
+            oge_f32(3.14000000000000012434e+00, -3.14000000000000012434e+00),
+            true
+        );
+        assert_eq!(
+            oge_f32(3.14000000000000012434e+00, -1.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            oge_f32(3.14000000000000012434e+00, 0.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            oge_f32(3.14000000000000012434e+00, 1.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            oge_f32(3.14000000000000012434e+00, 3.14000000000000012434e+00),
+            true
+        );
+        assert_eq!(
+            oge_f64(-3.14000000000000012434e+00, -1.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            oge_f64(-3.14000000000000012434e+00, 0.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            oge_f64(-3.14000000000000012434e+00, 1.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            oge_f64(-3.14000000000000012434e+00, 3.14000000000000012434e+00),
+            false
+        );
+        assert_eq!(
+            oge_f64(-1.00000000000000000000e+00, 0.00000000000000000000e+00),
+            false
+        );
+    }
+    #[test]
+    fn test_8() {
+        assert_eq!(
+            oge_f64(-1.00000000000000000000e+00, 1.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            oge_f64(-1.00000000000000000000e+00, 3.14000000000000012434e+00),
+            false
+        );
+        assert_eq!(
+            oge_f64(0.00000000000000000000e+00, 1.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            oge_f64(0.00000000000000000000e+00, 3.14000000000000012434e+00),
+            false
+        );
+        assert_eq!(
+            oge_f64(1.00000000000000000000e+00, 3.14000000000000012434e+00),
+            false
+        );
+        assert_eq!(
+            oge_f64(-3.14000000000000012434e+00, -3.14000000000000012434e+00),
+            true
+        );
+        assert_eq!(
+            oge_f64(-1.00000000000000000000e+00, -3.14000000000000012434e+00),
+            true
+        );
+        assert_eq!(
+            oge_f64(-1.00000000000000000000e+00, -1.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            oge_f64(0.00000000000000000000e+00, -3.14000000000000012434e+00),
+            true
+        );
+        assert_eq!(
+            oge_f64(0.00000000000000000000e+00, -1.00000000000000000000e+00),
+            true
+        );
+    }
+    #[test]
+    fn test_9() {
+        assert_eq!(
+            oge_f64(0.00000000000000000000e+00, 0.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            oge_f64(1.00000000000000000000e+00, -3.14000000000000012434e+00),
+            true
+        );
+        assert_eq!(
+            oge_f64(1.00000000000000000000e+00, -1.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            oge_f64(1.00000000000000000000e+00, 0.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            oge_f64(1.00000000000000000000e+00, 1.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            oge_f64(3.14000000000000012434e+00, -3.14000000000000012434e+00),
+            true
+        );
+        assert_eq!(
+            oge_f64(3.14000000000000012434e+00, -1.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            oge_f64(3.14000000000000012434e+00, 0.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            oge_f64(3.14000000000000012434e+00, 1.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            oge_f64(3.14000000000000012434e+00, 3.14000000000000012434e+00),
+            true
+        );
+    }
+    #[test]
+    fn test_10() {
+        assert_eq!(
+            ogt_f32(-3.14000000000000012434e+00, -3.14000000000000012434e+00),
+            false
+        );
+        assert_eq!(
+            ogt_f32(-3.14000000000000012434e+00, -1.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            ogt_f32(-3.14000000000000012434e+00, 0.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            ogt_f32(-3.14000000000000012434e+00, 1.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            ogt_f32(-3.14000000000000012434e+00, 3.14000000000000012434e+00),
+            false
+        );
+        assert_eq!(
+            ogt_f32(-1.00000000000000000000e+00, -1.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            ogt_f32(-1.00000000000000000000e+00, 0.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            ogt_f32(-1.00000000000000000000e+00, 1.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            ogt_f32(-1.00000000000000000000e+00, 3.14000000000000012434e+00),
+            false
+        );
+        assert_eq!(
+            ogt_f32(0.00000000000000000000e+00, 0.00000000000000000000e+00),
+            false
+        );
+    }
+    #[test]
+    fn test_11() {
+        assert_eq!(
+            ogt_f32(0.00000000000000000000e+00, 1.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            ogt_f32(0.00000000000000000000e+00, 3.14000000000000012434e+00),
+            false
+        );
+        assert_eq!(
+            ogt_f32(1.00000000000000000000e+00, 1.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            ogt_f32(1.00000000000000000000e+00, 3.14000000000000012434e+00),
+            false
+        );
+        assert_eq!(
+            ogt_f32(3.14000000000000012434e+00, 3.14000000000000012434e+00),
+            false
+        );
+        assert_eq!(
+            ogt_f32(-1.00000000000000000000e+00, -3.14000000000000012434e+00),
+            true
+        );
+        assert_eq!(
+            ogt_f32(0.00000000000000000000e+00, -3.14000000000000012434e+00),
+            true
+        );
+        assert_eq!(
+            ogt_f32(0.00000000000000000000e+00, -1.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            ogt_f32(1.00000000000000000000e+00, -3.14000000000000012434e+00),
+            true
+        );
+        assert_eq!(
+            ogt_f32(1.00000000000000000000e+00, -1.00000000000000000000e+00),
+            true
+        );
+    }
+    #[test]
+    fn test_12() {
+        assert_eq!(
+            ogt_f32(1.00000000000000000000e+00, 0.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            ogt_f32(3.14000000000000012434e+00, -3.14000000000000012434e+00),
+            true
+        );
+        assert_eq!(
+            ogt_f32(3.14000000000000012434e+00, -1.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            ogt_f32(3.14000000000000012434e+00, 0.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            ogt_f32(3.14000000000000012434e+00, 1.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            ogt_f64(-3.14000000000000012434e+00, -3.14000000000000012434e+00),
+            false
+        );
+        assert_eq!(
+            ogt_f64(-3.14000000000000012434e+00, -1.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            ogt_f64(-3.14000000000000012434e+00, 0.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            ogt_f64(-3.14000000000000012434e+00, 1.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            ogt_f64(-3.14000000000000012434e+00, 3.14000000000000012434e+00),
+            false
+        );
+    }
+    #[test]
+    fn test_13() {
+        assert_eq!(
+            ogt_f64(-1.00000000000000000000e+00, -1.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            ogt_f64(-1.00000000000000000000e+00, 0.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            ogt_f64(-1.00000000000000000000e+00, 1.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            ogt_f64(-1.00000000000000000000e+00, 3.14000000000000012434e+00),
+            false
+        );
+        assert_eq!(
+            ogt_f64(0.00000000000000000000e+00, 0.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            ogt_f64(0.00000000000000000000e+00, 1.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            ogt_f64(0.00000000000000000000e+00, 3.14000000000000012434e+00),
+            false
+        );
+        assert_eq!(
+            ogt_f64(1.00000000000000000000e+00, 1.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            ogt_f64(1.00000000000000000000e+00, 3.14000000000000012434e+00),
+            false
+        );
+        assert_eq!(
+            ogt_f64(3.14000000000000012434e+00, 3.14000000000000012434e+00),
+            false
+        );
+    }
+    #[test]
+    fn test_14() {
+        assert_eq!(
+            ogt_f64(-1.00000000000000000000e+00, -3.14000000000000012434e+00),
+            true
+        );
+        assert_eq!(
+            ogt_f64(0.00000000000000000000e+00, -3.14000000000000012434e+00),
+            true
+        );
+        assert_eq!(
+            ogt_f64(0.00000000000000000000e+00, -1.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            ogt_f64(1.00000000000000000000e+00, -3.14000000000000012434e+00),
+            true
+        );
+        assert_eq!(
+            ogt_f64(1.00000000000000000000e+00, -1.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            ogt_f64(1.00000000000000000000e+00, 0.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            ogt_f64(3.14000000000000012434e+00, -3.14000000000000012434e+00),
+            true
+        );
+        assert_eq!(
+            ogt_f64(3.14000000000000012434e+00, -1.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            ogt_f64(3.14000000000000012434e+00, 0.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            ogt_f64(3.14000000000000012434e+00, 1.00000000000000000000e+00),
+            true
+        );
+    }
+    #[test]
+    fn test_15() {
+        assert_eq!(
+            ole_f32(-1.00000000000000000000e+00, -3.14000000000000012434e+00),
+            false
+        );
+        assert_eq!(
+            ole_f32(0.00000000000000000000e+00, -3.14000000000000012434e+00),
+            false
+        );
+        assert_eq!(
+            ole_f32(0.00000000000000000000e+00, -1.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            ole_f32(1.00000000000000000000e+00, -3.14000000000000012434e+00),
+            false
+        );
+        assert_eq!(
+            ole_f32(1.00000000000000000000e+00, -1.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            ole_f32(1.00000000000000000000e+00, 0.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            ole_f32(3.14000000000000012434e+00, -3.14000000000000012434e+00),
+            false
+        );
+        assert_eq!(
+            ole_f32(3.14000000000000012434e+00, -1.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            ole_f32(3.14000000000000012434e+00, 0.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            ole_f32(3.14000000000000012434e+00, 1.00000000000000000000e+00),
+            false
+        );
+    }
+    #[test]
+    fn test_16() {
+        assert_eq!(
+            ole_f32(-3.14000000000000012434e+00, -3.14000000000000012434e+00),
+            true
+        );
+        assert_eq!(
+            ole_f32(-3.14000000000000012434e+00, -1.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            ole_f32(-3.14000000000000012434e+00, 0.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            ole_f32(-3.14000000000000012434e+00, 1.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            ole_f32(-3.14000000000000012434e+00, 3.14000000000000012434e+00),
+            true
+        );
+        assert_eq!(
+            ole_f32(-1.00000000000000000000e+00, -1.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            ole_f32(-1.00000000000000000000e+00, 0.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            ole_f32(-1.00000000000000000000e+00, 1.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            ole_f32(-1.00000000000000000000e+00, 3.14000000000000012434e+00),
+            true
+        );
+        assert_eq!(
+            ole_f32(0.00000000000000000000e+00, 0.00000000000000000000e+00),
+            true
+        );
+    }
+    #[test]
+    fn test_17() {
+        assert_eq!(
+            ole_f32(0.00000000000000000000e+00, 1.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            ole_f32(0.00000000000000000000e+00, 3.14000000000000012434e+00),
+            true
+        );
+        assert_eq!(
+            ole_f32(1.00000000000000000000e+00, 1.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            ole_f32(1.00000000000000000000e+00, 3.14000000000000012434e+00),
+            true
+        );
+        assert_eq!(
+            ole_f32(3.14000000000000012434e+00, 3.14000000000000012434e+00),
+            true
+        );
+        assert_eq!(
+            ole_f64(-1.00000000000000000000e+00, -3.14000000000000012434e+00),
+            false
+        );
+        assert_eq!(
+            ole_f64(0.00000000000000000000e+00, -3.14000000000000012434e+00),
+            false
+        );
+        assert_eq!(
+            ole_f64(0.00000000000000000000e+00, -1.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            ole_f64(1.00000000000000000000e+00, -3.14000000000000012434e+00),
+            false
+        );
+        assert_eq!(
+            ole_f64(1.00000000000000000000e+00, -1.00000000000000000000e+00),
+            false
+        );
+    }
+    #[test]
+    fn test_18() {
+        assert_eq!(
+            ole_f64(1.00000000000000000000e+00, 0.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            ole_f64(3.14000000000000012434e+00, -3.14000000000000012434e+00),
+            false
+        );
+        assert_eq!(
+            ole_f64(3.14000000000000012434e+00, -1.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            ole_f64(3.14000000000000012434e+00, 0.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            ole_f64(3.14000000000000012434e+00, 1.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            ole_f64(-3.14000000000000012434e+00, -3.14000000000000012434e+00),
+            true
+        );
+        assert_eq!(
+            ole_f64(-3.14000000000000012434e+00, -1.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            ole_f64(-3.14000000000000012434e+00, 0.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            ole_f64(-3.14000000000000012434e+00, 1.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            ole_f64(-3.14000000000000012434e+00, 3.14000000000000012434e+00),
+            true
+        );
+    }
+    #[test]
+    fn test_19() {
+        assert_eq!(
+            ole_f64(-1.00000000000000000000e+00, -1.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            ole_f64(-1.00000000000000000000e+00, 0.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            ole_f64(-1.00000000000000000000e+00, 1.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            ole_f64(-1.00000000000000000000e+00, 3.14000000000000012434e+00),
+            true
+        );
+        assert_eq!(
+            ole_f64(0.00000000000000000000e+00, 0.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            ole_f64(0.00000000000000000000e+00, 1.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            ole_f64(0.00000000000000000000e+00, 3.14000000000000012434e+00),
+            true
+        );
+        assert_eq!(
+            ole_f64(1.00000000000000000000e+00, 1.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            ole_f64(1.00000000000000000000e+00, 3.14000000000000012434e+00),
+            true
+        );
+        assert_eq!(
+            ole_f64(3.14000000000000012434e+00, 3.14000000000000012434e+00),
+            true
+        );
+    }
+    #[test]
+    fn test_20() {
+        assert_eq!(
+            olt_f32(-3.14000000000000012434e+00, -3.14000000000000012434e+00),
+            false
+        );
+        assert_eq!(
+            olt_f32(-1.00000000000000000000e+00, -3.14000000000000012434e+00),
+            false
+        );
+        assert_eq!(
+            olt_f32(-1.00000000000000000000e+00, -1.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            olt_f32(0.00000000000000000000e+00, -3.14000000000000012434e+00),
+            false
+        );
+        assert_eq!(
+            olt_f32(0.00000000000000000000e+00, -1.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            olt_f32(0.00000000000000000000e+00, 0.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            olt_f32(1.00000000000000000000e+00, -3.14000000000000012434e+00),
+            false
+        );
+        assert_eq!(
+            olt_f32(1.00000000000000000000e+00, -1.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            olt_f32(1.00000000000000000000e+00, 0.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            olt_f32(1.00000000000000000000e+00, 1.00000000000000000000e+00),
+            false
+        );
+    }
+    #[test]
+    fn test_21() {
+        assert_eq!(
+            olt_f32(3.14000000000000012434e+00, -3.14000000000000012434e+00),
+            false
+        );
+        assert_eq!(
+            olt_f32(3.14000000000000012434e+00, -1.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            olt_f32(3.14000000000000012434e+00, 0.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            olt_f32(3.14000000000000012434e+00, 1.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            olt_f32(3.14000000000000012434e+00, 3.14000000000000012434e+00),
+            false
+        );
+        assert_eq!(
+            olt_f32(-3.14000000000000012434e+00, -1.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            olt_f32(-3.14000000000000012434e+00, 0.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            olt_f32(-3.14000000000000012434e+00, 1.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            olt_f32(-3.14000000000000012434e+00, 3.14000000000000012434e+00),
+            true
+        );
+        assert_eq!(
+            olt_f32(-1.00000000000000000000e+00, 0.00000000000000000000e+00),
+            true
+        );
+    }
+    #[test]
+    fn test_22() {
+        assert_eq!(
+            olt_f32(-1.00000000000000000000e+00, 1.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            olt_f32(-1.00000000000000000000e+00, 3.14000000000000012434e+00),
+            true
+        );
+        assert_eq!(
+            olt_f32(0.00000000000000000000e+00, 1.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            olt_f32(0.00000000000000000000e+00, 3.14000000000000012434e+00),
+            true
+        );
+        assert_eq!(
+            olt_f32(1.00000000000000000000e+00, 3.14000000000000012434e+00),
+            true
+        );
+        assert_eq!(
+            olt_f64(-3.14000000000000012434e+00, -3.14000000000000012434e+00),
+            false
+        );
+        assert_eq!(
+            olt_f64(-1.00000000000000000000e+00, -3.14000000000000012434e+00),
+            false
+        );
+        assert_eq!(
+            olt_f64(-1.00000000000000000000e+00, -1.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            olt_f64(0.00000000000000000000e+00, -3.14000000000000012434e+00),
+            false
+        );
+        assert_eq!(
+            olt_f64(0.00000000000000000000e+00, -1.00000000000000000000e+00),
+            false
+        );
+    }
+    #[test]
+    fn test_23() {
+        assert_eq!(
+            olt_f64(0.00000000000000000000e+00, 0.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            olt_f64(1.00000000000000000000e+00, -3.14000000000000012434e+00),
+            false
+        );
+        assert_eq!(
+            olt_f64(1.00000000000000000000e+00, -1.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            olt_f64(1.00000000000000000000e+00, 0.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            olt_f64(1.00000000000000000000e+00, 1.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            olt_f64(3.14000000000000012434e+00, -3.14000000000000012434e+00),
+            false
+        );
+        assert_eq!(
+            olt_f64(3.14000000000000012434e+00, -1.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            olt_f64(3.14000000000000012434e+00, 0.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            olt_f64(3.14000000000000012434e+00, 1.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            olt_f64(3.14000000000000012434e+00, 3.14000000000000012434e+00),
+            false
+        );
+    }
+    #[test]
+    fn test_24() {
+        assert_eq!(
+            olt_f64(-3.14000000000000012434e+00, -1.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            olt_f64(-3.14000000000000012434e+00, 0.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            olt_f64(-3.14000000000000012434e+00, 1.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            olt_f64(-3.14000000000000012434e+00, 3.14000000000000012434e+00),
+            true
+        );
+        assert_eq!(
+            olt_f64(-1.00000000000000000000e+00, 0.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            olt_f64(-1.00000000000000000000e+00, 1.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            olt_f64(-1.00000000000000000000e+00, 3.14000000000000012434e+00),
+            true
+        );
+        assert_eq!(
+            olt_f64(0.00000000000000000000e+00, 1.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            olt_f64(0.00000000000000000000e+00, 3.14000000000000012434e+00),
+            true
+        );
+        assert_eq!(
+            olt_f64(1.00000000000000000000e+00, 3.14000000000000012434e+00),
+            true
+        );
+    }
+    #[test]
+    fn test_25() {
+        assert_eq!(
+            one_f32(-3.14000000000000012434e+00, -3.14000000000000012434e+00),
+            false
+        );
+        assert_eq!(
+            one_f32(-1.00000000000000000000e+00, -1.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            one_f32(0.00000000000000000000e+00, 0.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            one_f32(1.00000000000000000000e+00, 1.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            one_f32(3.14000000000000012434e+00, 3.14000000000000012434e+00),
+            false
+        );
+        assert_eq!(
+            one_f32(-3.14000000000000012434e+00, -1.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            one_f32(-3.14000000000000012434e+00, 0.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            one_f32(-3.14000000000000012434e+00, 1.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            one_f32(-3.14000000000000012434e+00, 3.14000000000000012434e+00),
+            true
+        );
+        assert_eq!(
+            one_f32(-1.00000000000000000000e+00, -3.14000000000000012434e+00),
+            true
+        );
+    }
+    #[test]
+    fn test_26() {
+        assert_eq!(
+            one_f32(-1.00000000000000000000e+00, 0.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            one_f32(-1.00000000000000000000e+00, 1.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            one_f32(-1.00000000000000000000e+00, 3.14000000000000012434e+00),
+            true
+        );
+        assert_eq!(
+            one_f32(0.00000000000000000000e+00, -3.14000000000000012434e+00),
+            true
+        );
+        assert_eq!(
+            one_f32(0.00000000000000000000e+00, -1.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            one_f32(0.00000000000000000000e+00, 1.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            one_f32(0.00000000000000000000e+00, 3.14000000000000012434e+00),
+            true
+        );
+        assert_eq!(
+            one_f32(1.00000000000000000000e+00, -3.14000000000000012434e+00),
+            true
+        );
+        assert_eq!(
+            one_f32(1.00000000000000000000e+00, -1.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            one_f32(1.00000000000000000000e+00, 0.00000000000000000000e+00),
+            true
+        );
+    }
+    #[test]
+    fn test_27() {
+        assert_eq!(
+            one_f32(1.00000000000000000000e+00, 3.14000000000000012434e+00),
+            true
+        );
+        assert_eq!(
+            one_f32(3.14000000000000012434e+00, -3.14000000000000012434e+00),
+            true
+        );
+        assert_eq!(
+            one_f32(3.14000000000000012434e+00, -1.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            one_f32(3.14000000000000012434e+00, 0.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            one_f32(3.14000000000000012434e+00, 1.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            one_f64(-3.14000000000000012434e+00, -3.14000000000000012434e+00),
+            false
+        );
+        assert_eq!(
+            one_f64(-1.00000000000000000000e+00, -1.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            one_f64(0.00000000000000000000e+00, 0.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            one_f64(1.00000000000000000000e+00, 1.00000000000000000000e+00),
+            false
+        );
+        assert_eq!(
+            one_f64(3.14000000000000012434e+00, 3.14000000000000012434e+00),
+            false
+        );
+    }
+    #[test]
+    fn test_28() {
+        assert_eq!(
+            one_f64(-3.14000000000000012434e+00, -1.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            one_f64(-3.14000000000000012434e+00, 0.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            one_f64(-3.14000000000000012434e+00, 1.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            one_f64(-3.14000000000000012434e+00, 3.14000000000000012434e+00),
+            true
+        );
+        assert_eq!(
+            one_f64(-1.00000000000000000000e+00, -3.14000000000000012434e+00),
+            true
+        );
+        assert_eq!(
+            one_f64(-1.00000000000000000000e+00, 0.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            one_f64(-1.00000000000000000000e+00, 1.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            one_f64(-1.00000000000000000000e+00, 3.14000000000000012434e+00),
+            true
+        );
+        assert_eq!(
+            one_f64(0.00000000000000000000e+00, -3.14000000000000012434e+00),
+            true
+        );
+        assert_eq!(
+            one_f64(0.00000000000000000000e+00, -1.00000000000000000000e+00),
+            true
+        );
+    }
+    #[test]
+    fn test_29() {
+        assert_eq!(
+            one_f64(0.00000000000000000000e+00, 1.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            one_f64(0.00000000000000000000e+00, 3.14000000000000012434e+00),
+            true
+        );
+        assert_eq!(
+            one_f64(1.00000000000000000000e+00, -3.14000000000000012434e+00),
+            true
+        );
+        assert_eq!(
+            one_f64(1.00000000000000000000e+00, -1.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            one_f64(1.00000000000000000000e+00, 0.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            one_f64(1.00000000000000000000e+00, 3.14000000000000012434e+00),
+            true
+        );
+        assert_eq!(
+            one_f64(3.14000000000000012434e+00, -3.14000000000000012434e+00),
+            true
+        );
+        assert_eq!(
+            one_f64(3.14000000000000012434e+00, -1.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            one_f64(3.14000000000000012434e+00, 0.00000000000000000000e+00),
+            true
+        );
+        assert_eq!(
+            one_f64(3.14000000000000012434e+00, 1.00000000000000000000e+00),
+            true
+        );
+    }
 }
diff --git a/arc-mlir/src/tests/arc-to-rust/arc-cmpi.mlir b/arc-mlir/src/tests/arc-to-rust/arc-cmpi.mlir
index 7f1c640c7..27b672c86 100644
--- a/arc-mlir/src/tests/arc-to-rust/arc-cmpi.mlir
+++ b/arc-mlir/src/tests/arc-to-rust/arc-cmpi.mlir
@@ -2,244 +2,243 @@
 // RUN: arc-mlir-rust-test %t-roundtrip-scf %s -rustinclude %s.rust-tests -canonicalize -remove-scf -canonicalize -to-scf -canonicalize
 
 module @arctorustcmpi {
-func.func @eq_ui8(%a : ui8, %b : ui8) -> i1 {
-  %r = arc.cmpi "eq", %a, %b : ui8
-  return %r : i1
-}
-
-func.func @ne_ui8(%a : ui8, %b : ui8) -> i1 {
-  %r = arc.cmpi "ne", %a, %b : ui8
-  return %r : i1
-}
-
-func.func @lt_ui8(%a : ui8, %b : ui8) -> i1 {
-  %r = arc.cmpi "lt", %a, %b : ui8
-  return %r : i1
-}
-
-func.func @le_ui8(%a : ui8, %b : ui8) -> i1 {
-  %r = arc.cmpi "le", %a, %b : ui8
-  return %r : i1
-}
-
-func.func @gt_ui8(%a : ui8, %b : ui8) -> i1 {
-  %r = arc.cmpi "gt", %a, %b : ui8
-  return %r : i1
-}
-
-func.func @ge_ui8(%a : ui8, %b : ui8) -> i1 {
-  %r = arc.cmpi "ge", %a, %b : ui8
-  return %r : i1
-}
-
-func.func @eq_ui16(%a : ui16, %b : ui16) -> i1 {
-  %r = arc.cmpi "eq", %a, %b : ui16
-  return %r : i1
-}
-
-func.func @ne_ui16(%a : ui16, %b : ui16) -> i1 {
-  %r = arc.cmpi "ne", %a, %b : ui16
-  return %r : i1
-}
-
-func.func @lt_ui16(%a : ui16, %b : ui16) -> i1 {
-  %r = arc.cmpi "lt", %a, %b : ui16
-  return %r : i1
-}
-
-func.func @le_ui16(%a : ui16, %b : ui16) -> i1 {
-  %r = arc.cmpi "le", %a, %b : ui16
-  return %r : i1
-}
-
-func.func @gt_ui16(%a : ui16, %b : ui16) -> i1 {
-  %r = arc.cmpi "gt", %a, %b : ui16
-  return %r : i1
-}
-
-func.func @ge_ui16(%a : ui16, %b : ui16) -> i1 {
-  %r = arc.cmpi "ge", %a, %b : ui16
-  return %r : i1
-}
-
-func.func @eq_ui32(%a : ui32, %b : ui32) -> i1 {
-  %r = arc.cmpi "eq", %a, %b : ui32
-  return %r : i1
-}
-
-func.func @ne_ui32(%a : ui32, %b : ui32) -> i1 {
-  %r = arc.cmpi "ne", %a, %b : ui32
-  return %r : i1
-}
-
-func.func @lt_ui32(%a : ui32, %b : ui32) -> i1 {
-  %r = arc.cmpi "lt", %a, %b : ui32
-  return %r : i1
-}
-
-func.func @le_ui32(%a : ui32, %b : ui32) -> i1 {
-  %r = arc.cmpi "le", %a, %b : ui32
-  return %r : i1
-}
-
-func.func @gt_ui32(%a : ui32, %b : ui32) -> i1 {
-  %r = arc.cmpi "gt", %a, %b : ui32
-  return %r : i1
-}
-
-func.func @ge_ui32(%a : ui32, %b : ui32) -> i1 {
-  %r = arc.cmpi "ge", %a, %b : ui32
-  return %r : i1
-}
-
-func.func @eq_ui64(%a : ui64, %b : ui64) -> i1 {
-  %r = arc.cmpi "eq", %a, %b : ui64
-  return %r : i1
-}
-
-func.func @ne_ui64(%a : ui64, %b : ui64) -> i1 {
-  %r = arc.cmpi "ne", %a, %b : ui64
-  return %r : i1
-}
-
-func.func @lt_ui64(%a : ui64, %b : ui64) -> i1 {
-  %r = arc.cmpi "lt", %a, %b : ui64
-  return %r : i1
-}
-
-func.func @le_ui64(%a : ui64, %b : ui64) -> i1 {
-  %r = arc.cmpi "le", %a, %b : ui64
-  return %r : i1
-}
-
-func.func @gt_ui64(%a : ui64, %b : ui64) -> i1 {
-  %r = arc.cmpi "gt", %a, %b : ui64
-  return %r : i1
-}
-
-func.func @ge_ui64(%a : ui64, %b : ui64) -> i1 {
-  %r = arc.cmpi "ge", %a, %b : ui64
-  return %r : i1
-}
-
-func.func @eq_si8(%a : si8, %b : si8) -> i1 {
-  %r = arc.cmpi "eq", %a, %b : si8
-  return %r : i1
-}
-
-func.func @ne_si8(%a : si8, %b : si8) -> i1 {
-  %r = arc.cmpi "ne", %a, %b : si8
-  return %r : i1
-}
-
-func.func @lt_si8(%a : si8, %b : si8) -> i1 {
-  %r = arc.cmpi "lt", %a, %b : si8
-  return %r : i1
-}
-
-func.func @le_si8(%a : si8, %b : si8) -> i1 {
-  %r = arc.cmpi "le", %a, %b : si8
-  return %r : i1
-}
-
-func.func @gt_si8(%a : si8, %b : si8) -> i1 {
-  %r = arc.cmpi "gt", %a, %b : si8
-  return %r : i1
-}
-
-func.func @ge_si8(%a : si8, %b : si8) -> i1 {
-  %r = arc.cmpi "ge", %a, %b : si8
-  return %r : i1
-}
-
-func.func @eq_si16(%a : si16, %b : si16) -> i1 {
-  %r = arc.cmpi "eq", %a, %b : si16
-  return %r : i1
-}
-
-func.func @ne_si16(%a : si16, %b : si16) -> i1 {
-  %r = arc.cmpi "ne", %a, %b : si16
-  return %r : i1
-}
-
-func.func @lt_si16(%a : si16, %b : si16) -> i1 {
-  %r = arc.cmpi "lt", %a, %b : si16
-  return %r : i1
-}
-
-func.func @le_si16(%a : si16, %b : si16) -> i1 {
-  %r = arc.cmpi "le", %a, %b : si16
-  return %r : i1
-}
-
-func.func @gt_si16(%a : si16, %b : si16) -> i1 {
-  %r = arc.cmpi "gt", %a, %b : si16
-  return %r : i1
-}
-
-func.func @ge_si16(%a : si16, %b : si16) -> i1 {
-  %r = arc.cmpi "ge", %a, %b : si16
-  return %r : i1
-}
-
-func.func @eq_si32(%a : si32, %b : si32) -> i1 {
-  %r = arc.cmpi "eq", %a, %b : si32
-  return %r : i1
-}
-
-func.func @ne_si32(%a : si32, %b : si32) -> i1 {
-  %r = arc.cmpi "ne", %a, %b : si32
-  return %r : i1
-}
-
-func.func @lt_si32(%a : si32, %b : si32) -> i1 {
-  %r = arc.cmpi "lt", %a, %b : si32
-  return %r : i1
-}
-
-func.func @le_si32(%a : si32, %b : si32) -> i1 {
-  %r = arc.cmpi "le", %a, %b : si32
-  return %r : i1
-}
-
-func.func @gt_si32(%a : si32, %b : si32) -> i1 {
-  %r = arc.cmpi "gt", %a, %b : si32
-  return %r : i1
-}
-
-func.func @ge_si32(%a : si32, %b : si32) -> i1 {
-  %r = arc.cmpi "ge", %a, %b : si32
-  return %r : i1
-}
-
-func.func @eq_si64(%a : si64, %b : si64) -> i1 {
-  %r = arc.cmpi "eq", %a, %b : si64
-  return %r : i1
-}
-
-func.func @ne_si64(%a : si64, %b : si64) -> i1 {
-  %r = arc.cmpi "ne", %a, %b : si64
-  return %r : i1
-}
-
-func.func @lt_si64(%a : si64, %b : si64) -> i1 {
-  %r = arc.cmpi "lt", %a, %b : si64
-  return %r : i1
-}
-
-func.func @le_si64(%a : si64, %b : si64) -> i1 {
-  %r = arc.cmpi "le", %a, %b : si64
-  return %r : i1
-}
-
-func.func @gt_si64(%a : si64, %b : si64) -> i1 {
-  %r = arc.cmpi "gt", %a, %b : si64
-  return %r : i1
-}
-
-func.func @ge_si64(%a : si64, %b : si64) -> i1 {
-  %r = arc.cmpi "ge", %a, %b : si64
-  return %r : i1
-}
-
+  func.func @eq_ui8(%a : ui8, %b : ui8) -> i1 {
+    %r = arc.cmpi "eq", %a, %b : ui8
+    return %r : i1
+  }
+
+  func.func @ne_ui8(%a : ui8, %b : ui8) -> i1 {
+    %r = arc.cmpi "ne", %a, %b : ui8
+    return %r : i1
+  }
+
+  func.func @lt_ui8(%a : ui8, %b : ui8) -> i1 {
+    %r = arc.cmpi "lt", %a, %b : ui8
+    return %r : i1
+  }
+
+  func.func @le_ui8(%a : ui8, %b : ui8) -> i1 {
+    %r = arc.cmpi "le", %a, %b : ui8
+    return %r : i1
+  }
+
+  func.func @gt_ui8(%a : ui8, %b : ui8) -> i1 {
+    %r = arc.cmpi "gt", %a, %b : ui8
+    return %r : i1
+  }
+
+  func.func @ge_ui8(%a : ui8, %b : ui8) -> i1 {
+    %r = arc.cmpi "ge", %a, %b : ui8
+    return %r : i1
+  }
+
+  func.func @eq_ui16(%a : ui16, %b : ui16) -> i1 {
+    %r = arc.cmpi "eq", %a, %b : ui16
+    return %r : i1
+  }
+
+  func.func @ne_ui16(%a : ui16, %b : ui16) -> i1 {
+    %r = arc.cmpi "ne", %a, %b : ui16
+    return %r : i1
+  }
+
+  func.func @lt_ui16(%a : ui16, %b : ui16) -> i1 {
+    %r = arc.cmpi "lt", %a, %b : ui16
+    return %r : i1
+  }
+
+  func.func @le_ui16(%a : ui16, %b : ui16) -> i1 {
+    %r = arc.cmpi "le", %a, %b : ui16
+    return %r : i1
+  }
+
+  func.func @gt_ui16(%a : ui16, %b : ui16) -> i1 {
+    %r = arc.cmpi "gt", %a, %b : ui16
+    return %r : i1
+  }
+
+  func.func @ge_ui16(%a : ui16, %b : ui16) -> i1 {
+    %r = arc.cmpi "ge", %a, %b : ui16
+    return %r : i1
+  }
+
+  func.func @eq_ui32(%a : ui32, %b : ui32) -> i1 {
+    %r = arc.cmpi "eq", %a, %b : ui32
+    return %r : i1
+  }
+
+  func.func @ne_ui32(%a : ui32, %b : ui32) -> i1 {
+    %r = arc.cmpi "ne", %a, %b : ui32
+    return %r : i1
+  }
+
+  func.func @lt_ui32(%a : ui32, %b : ui32) -> i1 {
+    %r = arc.cmpi "lt", %a, %b : ui32
+    return %r : i1
+  }
+
+  func.func @le_ui32(%a : ui32, %b : ui32) -> i1 {
+    %r = arc.cmpi "le", %a, %b : ui32
+    return %r : i1
+  }
+
+  func.func @gt_ui32(%a : ui32, %b : ui32) -> i1 {
+    %r = arc.cmpi "gt", %a, %b : ui32
+    return %r : i1
+  }
+
+  func.func @ge_ui32(%a : ui32, %b : ui32) -> i1 {
+    %r = arc.cmpi "ge", %a, %b : ui32
+    return %r : i1
+  }
+
+  func.func @eq_ui64(%a : ui64, %b : ui64) -> i1 {
+    %r = arc.cmpi "eq", %a, %b : ui64
+    return %r : i1
+  }
+
+  func.func @ne_ui64(%a : ui64, %b : ui64) -> i1 {
+    %r = arc.cmpi "ne", %a, %b : ui64
+    return %r : i1
+  }
+
+  func.func @lt_ui64(%a : ui64, %b : ui64) -> i1 {
+    %r = arc.cmpi "lt", %a, %b : ui64
+    return %r : i1
+  }
+
+  func.func @le_ui64(%a : ui64, %b : ui64) -> i1 {
+    %r = arc.cmpi "le", %a, %b : ui64
+    return %r : i1
+  }
+
+  func.func @gt_ui64(%a : ui64, %b : ui64) -> i1 {
+    %r = arc.cmpi "gt", %a, %b : ui64
+    return %r : i1
+  }
+
+  func.func @ge_ui64(%a : ui64, %b : ui64) -> i1 {
+    %r = arc.cmpi "ge", %a, %b : ui64
+    return %r : i1
+  }
+
+  func.func @eq_si8(%a : si8, %b : si8) -> i1 {
+    %r = arc.cmpi "eq", %a, %b : si8
+    return %r : i1
+  }
+
+  func.func @ne_si8(%a : si8, %b : si8) -> i1 {
+    %r = arc.cmpi "ne", %a, %b : si8
+    return %r : i1
+  }
+
+  func.func @lt_si8(%a : si8, %b : si8) -> i1 {
+    %r = arc.cmpi "lt", %a, %b : si8
+    return %r : i1
+  }
+
+  func.func @le_si8(%a : si8, %b : si8) -> i1 {
+    %r = arc.cmpi "le", %a, %b : si8
+    return %r : i1
+  }
+
+  func.func @gt_si8(%a : si8, %b : si8) -> i1 {
+    %r = arc.cmpi "gt", %a, %b : si8
+    return %r : i1
+  }
+
+  func.func @ge_si8(%a : si8, %b : si8) -> i1 {
+    %r = arc.cmpi "ge", %a, %b : si8
+    return %r : i1
+  }
+
+  func.func @eq_si16(%a : si16, %b : si16) -> i1 {
+    %r = arc.cmpi "eq", %a, %b : si16
+    return %r : i1
+  }
+
+  func.func @ne_si16(%a : si16, %b : si16) -> i1 {
+    %r = arc.cmpi "ne", %a, %b : si16
+    return %r : i1
+  }
+
+  func.func @lt_si16(%a : si16, %b : si16) -> i1 {
+    %r = arc.cmpi "lt", %a, %b : si16
+    return %r : i1
+  }
+
+  func.func @le_si16(%a : si16, %b : si16) -> i1 {
+    %r = arc.cmpi "le", %a, %b : si16
+    return %r : i1
+  }
+
+  func.func @gt_si16(%a : si16, %b : si16) -> i1 {
+    %r = arc.cmpi "gt", %a, %b : si16
+    return %r : i1
+  }
+
+  func.func @ge_si16(%a : si16, %b : si16) -> i1 {
+    %r = arc.cmpi "ge", %a, %b : si16
+    return %r : i1
+  }
+
+  func.func @eq_si32(%a : si32, %b : si32) -> i1 {
+    %r = arc.cmpi "eq", %a, %b : si32
+    return %r : i1
+  }
+
+  func.func @ne_si32(%a : si32, %b : si32) -> i1 {
+    %r = arc.cmpi "ne", %a, %b : si32
+    return %r : i1
+  }
+
+  func.func @lt_si32(%a : si32, %b : si32) -> i1 {
+    %r = arc.cmpi "lt", %a, %b : si32
+    return %r : i1
+  }
+
+  func.func @le_si32(%a : si32, %b : si32) -> i1 {
+    %r = arc.cmpi "le", %a, %b : si32
+    return %r : i1
+  }
+
+  func.func @gt_si32(%a : si32, %b : si32) -> i1 {
+    %r = arc.cmpi "gt", %a, %b : si32
+    return %r : i1
+  }
+
+  func.func @ge_si32(%a : si32, %b : si32) -> i1 {
+    %r = arc.cmpi "ge", %a, %b : si32
+    return %r : i1
+  }
+
+  func.func @eq_si64(%a : si64, %b : si64) -> i1 {
+    %r = arc.cmpi "eq", %a, %b : si64
+    return %r : i1
+  }
+
+  func.func @ne_si64(%a : si64, %b : si64) -> i1 {
+    %r = arc.cmpi "ne", %a, %b : si64
+    return %r : i1
+  }
+
+  func.func @lt_si64(%a : si64, %b : si64) -> i1 {
+    %r = arc.cmpi "lt", %a, %b : si64
+    return %r : i1
+  }
+
+  func.func @le_si64(%a : si64, %b : si64) -> i1 {
+    %r = arc.cmpi "le", %a, %b : si64
+    return %r : i1
+  }
+
+  func.func @gt_si64(%a : si64, %b : si64) -> i1 {
+    %r = arc.cmpi "gt", %a, %b : si64
+    return %r : i1
+  }
+
+  func.func @ge_si64(%a : si64, %b : si64) -> i1 {
+    %r = arc.cmpi "ge", %a, %b : si64
+    return %r : i1
+  }
 }
diff --git a/arc-mlir/src/tests/arc-to-rust/arc-cmpi.mlir.rust-tests b/arc-mlir/src/tests/arc-to-rust/arc-cmpi.mlir.rust-tests
index e43e83358..6b073f8c6 100644
--- a/arc-mlir/src/tests/arc-to-rust/arc-cmpi.mlir.rust-tests
+++ b/arc-mlir/src/tests/arc-to-rust/arc-cmpi.mlir.rust-tests
@@ -1,7836 +1,7276 @@
 #[cfg(test)]
 mod tests {
-  use crate::arctorustcmpi::*;
-  #[rewrite(main)]
-  #[test]
-  fn test_0() {
-    assert_eq!(call!(eq_si16(-32768, -32767)), false);
-    assert_eq!(call!(eq_si16(-32768, -32547)), false);
-    assert_eq!(call!(eq_si16(-32768, 0)), false);
-    assert_eq!(call!(eq_si16(-32768, 1)), false);
-    assert_eq!(call!(eq_si16(-32768, 2)), false);
-    assert_eq!(call!(eq_si16(-32768, 3)), false);
-    assert_eq!(call!(eq_si16(-32768, 4)), false);
-    assert_eq!(call!(eq_si16(-32768, 10486)), false);
-    assert_eq!(call!(eq_si16(-32768, 16514)), false);
-    assert_eq!(call!(eq_si16(-32768, 32766)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_1() {
-    assert_eq!(call!(eq_si16(-32768, 32767)), false);
-    assert_eq!(call!(eq_si16(-32767, -32768)), false);
-    assert_eq!(call!(eq_si16(-32767, -32547)), false);
-    assert_eq!(call!(eq_si16(-32767, 0)), false);
-    assert_eq!(call!(eq_si16(-32767, 1)), false);
-    assert_eq!(call!(eq_si16(-32767, 2)), false);
-    assert_eq!(call!(eq_si16(-32767, 3)), false);
-    assert_eq!(call!(eq_si16(-32767, 4)), false);
-    assert_eq!(call!(eq_si16(-32767, 10486)), false);
-    assert_eq!(call!(eq_si16(-32767, 16514)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_2() {
-    assert_eq!(call!(eq_si16(-32767, 32766)), false);
-    assert_eq!(call!(eq_si16(-32767, 32767)), false);
-    assert_eq!(call!(eq_si16(-32547, -32768)), false);
-    assert_eq!(call!(eq_si16(-32547, -32767)), false);
-    assert_eq!(call!(eq_si16(-32547, 0)), false);
-    assert_eq!(call!(eq_si16(-32547, 1)), false);
-    assert_eq!(call!(eq_si16(-32547, 2)), false);
-    assert_eq!(call!(eq_si16(-32547, 3)), false);
-    assert_eq!(call!(eq_si16(-32547, 4)), false);
-    assert_eq!(call!(eq_si16(-32547, 10486)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_3() {
-    assert_eq!(call!(eq_si16(-32547, 16514)), false);
-    assert_eq!(call!(eq_si16(-32547, 32766)), false);
-    assert_eq!(call!(eq_si16(-32547, 32767)), false);
-    assert_eq!(call!(eq_si16(0, -32768)), false);
-    assert_eq!(call!(eq_si16(0, -32767)), false);
-    assert_eq!(call!(eq_si16(0, -32547)), false);
-    assert_eq!(call!(eq_si16(0, 1)), false);
-    assert_eq!(call!(eq_si16(0, 2)), false);
-    assert_eq!(call!(eq_si16(0, 3)), false);
-    assert_eq!(call!(eq_si16(0, 4)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_4() {
-    assert_eq!(call!(eq_si16(0, 10486)), false);
-    assert_eq!(call!(eq_si16(0, 16514)), false);
-    assert_eq!(call!(eq_si16(0, 32766)), false);
-    assert_eq!(call!(eq_si16(0, 32767)), false);
-    assert_eq!(call!(eq_si16(1, -32768)), false);
-    assert_eq!(call!(eq_si16(1, -32767)), false);
-    assert_eq!(call!(eq_si16(1, -32547)), false);
-    assert_eq!(call!(eq_si16(1, 0)), false);
-    assert_eq!(call!(eq_si16(1, 2)), false);
-    assert_eq!(call!(eq_si16(1, 3)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_5() {
-    assert_eq!(call!(eq_si16(1, 4)), false);
-    assert_eq!(call!(eq_si16(1, 10486)), false);
-    assert_eq!(call!(eq_si16(1, 16514)), false);
-    assert_eq!(call!(eq_si16(1, 32766)), false);
-    assert_eq!(call!(eq_si16(1, 32767)), false);
-    assert_eq!(call!(eq_si16(2, -32768)), false);
-    assert_eq!(call!(eq_si16(2, -32767)), false);
-    assert_eq!(call!(eq_si16(2, -32547)), false);
-    assert_eq!(call!(eq_si16(2, 0)), false);
-    assert_eq!(call!(eq_si16(2, 1)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_6() {
-    assert_eq!(call!(eq_si16(2, 3)), false);
-    assert_eq!(call!(eq_si16(2, 4)), false);
-    assert_eq!(call!(eq_si16(2, 10486)), false);
-    assert_eq!(call!(eq_si16(2, 16514)), false);
-    assert_eq!(call!(eq_si16(2, 32766)), false);
-    assert_eq!(call!(eq_si16(2, 32767)), false);
-    assert_eq!(call!(eq_si16(3, -32768)), false);
-    assert_eq!(call!(eq_si16(3, -32767)), false);
-    assert_eq!(call!(eq_si16(3, -32547)), false);
-    assert_eq!(call!(eq_si16(3, 0)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_7() {
-    assert_eq!(call!(eq_si16(3, 1)), false);
-    assert_eq!(call!(eq_si16(3, 2)), false);
-    assert_eq!(call!(eq_si16(3, 4)), false);
-    assert_eq!(call!(eq_si16(3, 10486)), false);
-    assert_eq!(call!(eq_si16(3, 16514)), false);
-    assert_eq!(call!(eq_si16(3, 32766)), false);
-    assert_eq!(call!(eq_si16(3, 32767)), false);
-    assert_eq!(call!(eq_si16(4, -32768)), false);
-    assert_eq!(call!(eq_si16(4, -32767)), false);
-    assert_eq!(call!(eq_si16(4, -32547)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_8() {
-    assert_eq!(call!(eq_si16(4, 0)), false);
-    assert_eq!(call!(eq_si16(4, 1)), false);
-    assert_eq!(call!(eq_si16(4, 2)), false);
-    assert_eq!(call!(eq_si16(4, 3)), false);
-    assert_eq!(call!(eq_si16(4, 10486)), false);
-    assert_eq!(call!(eq_si16(4, 16514)), false);
-    assert_eq!(call!(eq_si16(4, 32766)), false);
-    assert_eq!(call!(eq_si16(4, 32767)), false);
-    assert_eq!(call!(eq_si16(10486, -32768)), false);
-    assert_eq!(call!(eq_si16(10486, -32767)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_9() {
-    assert_eq!(call!(eq_si16(10486, -32547)), false);
-    assert_eq!(call!(eq_si16(10486, 0)), false);
-    assert_eq!(call!(eq_si16(10486, 1)), false);
-    assert_eq!(call!(eq_si16(10486, 2)), false);
-    assert_eq!(call!(eq_si16(10486, 3)), false);
-    assert_eq!(call!(eq_si16(10486, 4)), false);
-    assert_eq!(call!(eq_si16(10486, 16514)), false);
-    assert_eq!(call!(eq_si16(10486, 32766)), false);
-    assert_eq!(call!(eq_si16(10486, 32767)), false);
-    assert_eq!(call!(eq_si16(16514, -32768)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_10() {
-    assert_eq!(call!(eq_si16(16514, -32767)), false);
-    assert_eq!(call!(eq_si16(16514, -32547)), false);
-    assert_eq!(call!(eq_si16(16514, 0)), false);
-    assert_eq!(call!(eq_si16(16514, 1)), false);
-    assert_eq!(call!(eq_si16(16514, 2)), false);
-    assert_eq!(call!(eq_si16(16514, 3)), false);
-    assert_eq!(call!(eq_si16(16514, 4)), false);
-    assert_eq!(call!(eq_si16(16514, 10486)), false);
-    assert_eq!(call!(eq_si16(16514, 32766)), false);
-    assert_eq!(call!(eq_si16(16514, 32767)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_11() {
-    assert_eq!(call!(eq_si16(32766, -32768)), false);
-    assert_eq!(call!(eq_si16(32766, -32767)), false);
-    assert_eq!(call!(eq_si16(32766, -32547)), false);
-    assert_eq!(call!(eq_si16(32766, 0)), false);
-    assert_eq!(call!(eq_si16(32766, 1)), false);
-    assert_eq!(call!(eq_si16(32766, 2)), false);
-    assert_eq!(call!(eq_si16(32766, 3)), false);
-    assert_eq!(call!(eq_si16(32766, 4)), false);
-    assert_eq!(call!(eq_si16(32766, 10486)), false);
-    assert_eq!(call!(eq_si16(32766, 16514)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_12() {
-    assert_eq!(call!(eq_si16(32766, 32767)), false);
-    assert_eq!(call!(eq_si16(32767, -32768)), false);
-    assert_eq!(call!(eq_si16(32767, -32767)), false);
-    assert_eq!(call!(eq_si16(32767, -32547)), false);
-    assert_eq!(call!(eq_si16(32767, 0)), false);
-    assert_eq!(call!(eq_si16(32767, 1)), false);
-    assert_eq!(call!(eq_si16(32767, 2)), false);
-    assert_eq!(call!(eq_si16(32767, 3)), false);
-    assert_eq!(call!(eq_si16(32767, 4)), false);
-    assert_eq!(call!(eq_si16(32767, 10486)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_13() {
-    assert_eq!(call!(eq_si16(32767, 16514)), false);
-    assert_eq!(call!(eq_si16(32767, 32766)), false);
-    assert_eq!(call!(eq_si16(-32768, -32768)), true);
-    assert_eq!(call!(eq_si16(-32767, -32767)), true);
-    assert_eq!(call!(eq_si16(-32547, -32547)), true);
-    assert_eq!(call!(eq_si16(0, 0)), true);
-    assert_eq!(call!(eq_si16(1, 1)), true);
-    assert_eq!(call!(eq_si16(2, 2)), true);
-    assert_eq!(call!(eq_si16(3, 3)), true);
-    assert_eq!(call!(eq_si16(4, 4)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_14() {
-    assert_eq!(call!(eq_si16(10486, 10486)), true);
-    assert_eq!(call!(eq_si16(16514, 16514)), true);
-    assert_eq!(call!(eq_si16(32766, 32766)), true);
-    assert_eq!(call!(eq_si16(32767, 32767)), true);
-    assert_eq!(call!(eq_si32(-2147483648, -2147483647)), false);
-    assert_eq!(call!(eq_si32(-2147483648, -1713183800)), false);
-    assert_eq!(call!(eq_si32(-2147483648, -1252582164)), false);
-    assert_eq!(call!(eq_si32(-2147483648, -1035405763)), false);
-    assert_eq!(call!(eq_si32(-2147483648, 0)), false);
-    assert_eq!(call!(eq_si32(-2147483648, 1)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_15() {
-    assert_eq!(call!(eq_si32(-2147483648, 2)), false);
-    assert_eq!(call!(eq_si32(-2147483648, 3)), false);
-    assert_eq!(call!(eq_si32(-2147483648, 4)), false);
-    assert_eq!(call!(eq_si32(-2147483648, 2147483646)), false);
-    assert_eq!(call!(eq_si32(-2147483648, 2147483647)), false);
-    assert_eq!(call!(eq_si32(-2147483647, -2147483648)), false);
-    assert_eq!(call!(eq_si32(-2147483647, -1713183800)), false);
-    assert_eq!(call!(eq_si32(-2147483647, -1252582164)), false);
-    assert_eq!(call!(eq_si32(-2147483647, -1035405763)), false);
-    assert_eq!(call!(eq_si32(-2147483647, 0)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_16() {
-    assert_eq!(call!(eq_si32(-2147483647, 1)), false);
-    assert_eq!(call!(eq_si32(-2147483647, 2)), false);
-    assert_eq!(call!(eq_si32(-2147483647, 3)), false);
-    assert_eq!(call!(eq_si32(-2147483647, 4)), false);
-    assert_eq!(call!(eq_si32(-2147483647, 2147483646)), false);
-    assert_eq!(call!(eq_si32(-2147483647, 2147483647)), false);
-    assert_eq!(call!(eq_si32(-1713183800, -2147483648)), false);
-    assert_eq!(call!(eq_si32(-1713183800, -2147483647)), false);
-    assert_eq!(call!(eq_si32(-1713183800, -1252582164)), false);
-    assert_eq!(call!(eq_si32(-1713183800, -1035405763)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_17() {
-    assert_eq!(call!(eq_si32(-1713183800, 0)), false);
-    assert_eq!(call!(eq_si32(-1713183800, 1)), false);
-    assert_eq!(call!(eq_si32(-1713183800, 2)), false);
-    assert_eq!(call!(eq_si32(-1713183800, 3)), false);
-    assert_eq!(call!(eq_si32(-1713183800, 4)), false);
-    assert_eq!(call!(eq_si32(-1713183800, 2147483646)), false);
-    assert_eq!(call!(eq_si32(-1713183800, 2147483647)), false);
-    assert_eq!(call!(eq_si32(-1252582164, -2147483648)), false);
-    assert_eq!(call!(eq_si32(-1252582164, -2147483647)), false);
-    assert_eq!(call!(eq_si32(-1252582164, -1713183800)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_18() {
-    assert_eq!(call!(eq_si32(-1252582164, -1035405763)), false);
-    assert_eq!(call!(eq_si32(-1252582164, 0)), false);
-    assert_eq!(call!(eq_si32(-1252582164, 1)), false);
-    assert_eq!(call!(eq_si32(-1252582164, 2)), false);
-    assert_eq!(call!(eq_si32(-1252582164, 3)), false);
-    assert_eq!(call!(eq_si32(-1252582164, 4)), false);
-    assert_eq!(call!(eq_si32(-1252582164, 2147483646)), false);
-    assert_eq!(call!(eq_si32(-1252582164, 2147483647)), false);
-    assert_eq!(call!(eq_si32(-1035405763, -2147483648)), false);
-    assert_eq!(call!(eq_si32(-1035405763, -2147483647)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_19() {
-    assert_eq!(call!(eq_si32(-1035405763, -1713183800)), false);
-    assert_eq!(call!(eq_si32(-1035405763, -1252582164)), false);
-    assert_eq!(call!(eq_si32(-1035405763, 0)), false);
-    assert_eq!(call!(eq_si32(-1035405763, 1)), false);
-    assert_eq!(call!(eq_si32(-1035405763, 2)), false);
-    assert_eq!(call!(eq_si32(-1035405763, 3)), false);
-    assert_eq!(call!(eq_si32(-1035405763, 4)), false);
-    assert_eq!(call!(eq_si32(-1035405763, 2147483646)), false);
-    assert_eq!(call!(eq_si32(-1035405763, 2147483647)), false);
-    assert_eq!(call!(eq_si32(0, -2147483648)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_20() {
-    assert_eq!(call!(eq_si32(0, -2147483647)), false);
-    assert_eq!(call!(eq_si32(0, -1713183800)), false);
-    assert_eq!(call!(eq_si32(0, -1252582164)), false);
-    assert_eq!(call!(eq_si32(0, -1035405763)), false);
-    assert_eq!(call!(eq_si32(0, 1)), false);
-    assert_eq!(call!(eq_si32(0, 2)), false);
-    assert_eq!(call!(eq_si32(0, 3)), false);
-    assert_eq!(call!(eq_si32(0, 4)), false);
-    assert_eq!(call!(eq_si32(0, 2147483646)), false);
-    assert_eq!(call!(eq_si32(0, 2147483647)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_21() {
-    assert_eq!(call!(eq_si32(1, -2147483648)), false);
-    assert_eq!(call!(eq_si32(1, -2147483647)), false);
-    assert_eq!(call!(eq_si32(1, -1713183800)), false);
-    assert_eq!(call!(eq_si32(1, -1252582164)), false);
-    assert_eq!(call!(eq_si32(1, -1035405763)), false);
-    assert_eq!(call!(eq_si32(1, 0)), false);
-    assert_eq!(call!(eq_si32(1, 2)), false);
-    assert_eq!(call!(eq_si32(1, 3)), false);
-    assert_eq!(call!(eq_si32(1, 4)), false);
-    assert_eq!(call!(eq_si32(1, 2147483646)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_22() {
-    assert_eq!(call!(eq_si32(1, 2147483647)), false);
-    assert_eq!(call!(eq_si32(2, -2147483648)), false);
-    assert_eq!(call!(eq_si32(2, -2147483647)), false);
-    assert_eq!(call!(eq_si32(2, -1713183800)), false);
-    assert_eq!(call!(eq_si32(2, -1252582164)), false);
-    assert_eq!(call!(eq_si32(2, -1035405763)), false);
-    assert_eq!(call!(eq_si32(2, 0)), false);
-    assert_eq!(call!(eq_si32(2, 1)), false);
-    assert_eq!(call!(eq_si32(2, 3)), false);
-    assert_eq!(call!(eq_si32(2, 4)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_23() {
-    assert_eq!(call!(eq_si32(2, 2147483646)), false);
-    assert_eq!(call!(eq_si32(2, 2147483647)), false);
-    assert_eq!(call!(eq_si32(3, -2147483648)), false);
-    assert_eq!(call!(eq_si32(3, -2147483647)), false);
-    assert_eq!(call!(eq_si32(3, -1713183800)), false);
-    assert_eq!(call!(eq_si32(3, -1252582164)), false);
-    assert_eq!(call!(eq_si32(3, -1035405763)), false);
-    assert_eq!(call!(eq_si32(3, 0)), false);
-    assert_eq!(call!(eq_si32(3, 1)), false);
-    assert_eq!(call!(eq_si32(3, 2)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_24() {
-    assert_eq!(call!(eq_si32(3, 4)), false);
-    assert_eq!(call!(eq_si32(3, 2147483646)), false);
-    assert_eq!(call!(eq_si32(3, 2147483647)), false);
-    assert_eq!(call!(eq_si32(4, -2147483648)), false);
-    assert_eq!(call!(eq_si32(4, -2147483647)), false);
-    assert_eq!(call!(eq_si32(4, -1713183800)), false);
-    assert_eq!(call!(eq_si32(4, -1252582164)), false);
-    assert_eq!(call!(eq_si32(4, -1035405763)), false);
-    assert_eq!(call!(eq_si32(4, 0)), false);
-    assert_eq!(call!(eq_si32(4, 1)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_25() {
-    assert_eq!(call!(eq_si32(4, 2)), false);
-    assert_eq!(call!(eq_si32(4, 3)), false);
-    assert_eq!(call!(eq_si32(4, 2147483646)), false);
-    assert_eq!(call!(eq_si32(4, 2147483647)), false);
-    assert_eq!(call!(eq_si32(2147483646, -2147483648)), false);
-    assert_eq!(call!(eq_si32(2147483646, -2147483647)), false);
-    assert_eq!(call!(eq_si32(2147483646, -1713183800)), false);
-    assert_eq!(call!(eq_si32(2147483646, -1252582164)), false);
-    assert_eq!(call!(eq_si32(2147483646, -1035405763)), false);
-    assert_eq!(call!(eq_si32(2147483646, 0)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_26() {
-    assert_eq!(call!(eq_si32(2147483646, 1)), false);
-    assert_eq!(call!(eq_si32(2147483646, 2)), false);
-    assert_eq!(call!(eq_si32(2147483646, 3)), false);
-    assert_eq!(call!(eq_si32(2147483646, 4)), false);
-    assert_eq!(call!(eq_si32(2147483646, 2147483647)), false);
-    assert_eq!(call!(eq_si32(2147483647, -2147483648)), false);
-    assert_eq!(call!(eq_si32(2147483647, -2147483647)), false);
-    assert_eq!(call!(eq_si32(2147483647, -1713183800)), false);
-    assert_eq!(call!(eq_si32(2147483647, -1252582164)), false);
-    assert_eq!(call!(eq_si32(2147483647, -1035405763)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_27() {
-    assert_eq!(call!(eq_si32(2147483647, 0)), false);
-    assert_eq!(call!(eq_si32(2147483647, 1)), false);
-    assert_eq!(call!(eq_si32(2147483647, 2)), false);
-    assert_eq!(call!(eq_si32(2147483647, 3)), false);
-    assert_eq!(call!(eq_si32(2147483647, 4)), false);
-    assert_eq!(call!(eq_si32(2147483647, 2147483646)), false);
-    assert_eq!(call!(eq_si32(-2147483648, -2147483648)), true);
-    assert_eq!(call!(eq_si32(-2147483647, -2147483647)), true);
-    assert_eq!(call!(eq_si32(-1713183800, -1713183800)), true);
-    assert_eq!(call!(eq_si32(-1252582164, -1252582164)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_28() {
-    assert_eq!(call!(eq_si32(-1035405763, -1035405763)), true);
-    assert_eq!(call!(eq_si32(0, 0)), true);
-    assert_eq!(call!(eq_si32(1, 1)), true);
-    assert_eq!(call!(eq_si32(2, 2)), true);
-    assert_eq!(call!(eq_si32(3, 3)), true);
-    assert_eq!(call!(eq_si32(4, 4)), true);
-    assert_eq!(call!(eq_si32(2147483646, 2147483646)), true);
-    assert_eq!(call!(eq_si32(2147483647, 2147483647)), true);
-    assert_eq!(call!(eq_si64(-9223372036854775808, -9223372036854775807)), false);
-    assert_eq!(call!(eq_si64(-9223372036854775808, -1741927215160008704)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_29() {
-    assert_eq!(call!(eq_si64(-9223372036854775808, -1328271339354574848)), false);
-    assert_eq!(call!(eq_si64(-9223372036854775808, 0)), false);
-    assert_eq!(call!(eq_si64(-9223372036854775808, 1)), false);
-    assert_eq!(call!(eq_si64(-9223372036854775808, 2)), false);
-    assert_eq!(call!(eq_si64(-9223372036854775808, 3)), false);
-    assert_eq!(call!(eq_si64(-9223372036854775808, 4)), false);
-    assert_eq!(call!(eq_si64(-9223372036854775808, 5577148965131116544)), false);
-    assert_eq!(call!(eq_si64(-9223372036854775808, 9223372036854775806)), false);
-    assert_eq!(call!(eq_si64(-9223372036854775808, 9223372036854775807)), false);
-    assert_eq!(call!(eq_si64(-9223372036854775807, -9223372036854775808)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_30() {
-    assert_eq!(call!(eq_si64(-9223372036854775807, -1741927215160008704)), false);
-    assert_eq!(call!(eq_si64(-9223372036854775807, -1328271339354574848)), false);
-    assert_eq!(call!(eq_si64(-9223372036854775807, 0)), false);
-    assert_eq!(call!(eq_si64(-9223372036854775807, 1)), false);
-    assert_eq!(call!(eq_si64(-9223372036854775807, 2)), false);
-    assert_eq!(call!(eq_si64(-9223372036854775807, 3)), false);
-    assert_eq!(call!(eq_si64(-9223372036854775807, 4)), false);
-    assert_eq!(call!(eq_si64(-9223372036854775807, 5577148965131116544)), false);
-    assert_eq!(call!(eq_si64(-9223372036854775807, 9223372036854775806)), false);
-    assert_eq!(call!(eq_si64(-9223372036854775807, 9223372036854775807)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_31() {
-    assert_eq!(call!(eq_si64(-1741927215160008704, -9223372036854775808)), false);
-    assert_eq!(call!(eq_si64(-1741927215160008704, -9223372036854775807)), false);
-    assert_eq!(call!(eq_si64(-1741927215160008704, -1328271339354574848)), false);
-    assert_eq!(call!(eq_si64(-1741927215160008704, 0)), false);
-    assert_eq!(call!(eq_si64(-1741927215160008704, 1)), false);
-    assert_eq!(call!(eq_si64(-1741927215160008704, 2)), false);
-    assert_eq!(call!(eq_si64(-1741927215160008704, 3)), false);
-    assert_eq!(call!(eq_si64(-1741927215160008704, 4)), false);
-    assert_eq!(call!(eq_si64(-1741927215160008704, 5577148965131116544)), false);
-    assert_eq!(call!(eq_si64(-1741927215160008704, 9223372036854775806)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_32() {
-    assert_eq!(call!(eq_si64(-1741927215160008704, 9223372036854775807)), false);
-    assert_eq!(call!(eq_si64(-1328271339354574848, -9223372036854775808)), false);
-    assert_eq!(call!(eq_si64(-1328271339354574848, -9223372036854775807)), false);
-    assert_eq!(call!(eq_si64(-1328271339354574848, -1741927215160008704)), false);
-    assert_eq!(call!(eq_si64(-1328271339354574848, 0)), false);
-    assert_eq!(call!(eq_si64(-1328271339354574848, 1)), false);
-    assert_eq!(call!(eq_si64(-1328271339354574848, 2)), false);
-    assert_eq!(call!(eq_si64(-1328271339354574848, 3)), false);
-    assert_eq!(call!(eq_si64(-1328271339354574848, 4)), false);
-    assert_eq!(call!(eq_si64(-1328271339354574848, 5577148965131116544)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_33() {
-    assert_eq!(call!(eq_si64(-1328271339354574848, 9223372036854775806)), false);
-    assert_eq!(call!(eq_si64(-1328271339354574848, 9223372036854775807)), false);
-    assert_eq!(call!(eq_si64(0, -9223372036854775808)), false);
-    assert_eq!(call!(eq_si64(0, -9223372036854775807)), false);
-    assert_eq!(call!(eq_si64(0, -1741927215160008704)), false);
-    assert_eq!(call!(eq_si64(0, -1328271339354574848)), false);
-    assert_eq!(call!(eq_si64(0, 1)), false);
-    assert_eq!(call!(eq_si64(0, 2)), false);
-    assert_eq!(call!(eq_si64(0, 3)), false);
-    assert_eq!(call!(eq_si64(0, 4)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_34() {
-    assert_eq!(call!(eq_si64(0, 5577148965131116544)), false);
-    assert_eq!(call!(eq_si64(0, 9223372036854775806)), false);
-    assert_eq!(call!(eq_si64(0, 9223372036854775807)), false);
-    assert_eq!(call!(eq_si64(1, -9223372036854775808)), false);
-    assert_eq!(call!(eq_si64(1, -9223372036854775807)), false);
-    assert_eq!(call!(eq_si64(1, -1741927215160008704)), false);
-    assert_eq!(call!(eq_si64(1, -1328271339354574848)), false);
-    assert_eq!(call!(eq_si64(1, 0)), false);
-    assert_eq!(call!(eq_si64(1, 2)), false);
-    assert_eq!(call!(eq_si64(1, 3)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_35() {
-    assert_eq!(call!(eq_si64(1, 4)), false);
-    assert_eq!(call!(eq_si64(1, 5577148965131116544)), false);
-    assert_eq!(call!(eq_si64(1, 9223372036854775806)), false);
-    assert_eq!(call!(eq_si64(1, 9223372036854775807)), false);
-    assert_eq!(call!(eq_si64(2, -9223372036854775808)), false);
-    assert_eq!(call!(eq_si64(2, -9223372036854775807)), false);
-    assert_eq!(call!(eq_si64(2, -1741927215160008704)), false);
-    assert_eq!(call!(eq_si64(2, -1328271339354574848)), false);
-    assert_eq!(call!(eq_si64(2, 0)), false);
-    assert_eq!(call!(eq_si64(2, 1)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_36() {
-    assert_eq!(call!(eq_si64(2, 3)), false);
-    assert_eq!(call!(eq_si64(2, 4)), false);
-    assert_eq!(call!(eq_si64(2, 5577148965131116544)), false);
-    assert_eq!(call!(eq_si64(2, 9223372036854775806)), false);
-    assert_eq!(call!(eq_si64(2, 9223372036854775807)), false);
-    assert_eq!(call!(eq_si64(3, -9223372036854775808)), false);
-    assert_eq!(call!(eq_si64(3, -9223372036854775807)), false);
-    assert_eq!(call!(eq_si64(3, -1741927215160008704)), false);
-    assert_eq!(call!(eq_si64(3, -1328271339354574848)), false);
-    assert_eq!(call!(eq_si64(3, 0)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_37() {
-    assert_eq!(call!(eq_si64(3, 1)), false);
-    assert_eq!(call!(eq_si64(3, 2)), false);
-    assert_eq!(call!(eq_si64(3, 4)), false);
-    assert_eq!(call!(eq_si64(3, 5577148965131116544)), false);
-    assert_eq!(call!(eq_si64(3, 9223372036854775806)), false);
-    assert_eq!(call!(eq_si64(3, 9223372036854775807)), false);
-    assert_eq!(call!(eq_si64(4, -9223372036854775808)), false);
-    assert_eq!(call!(eq_si64(4, -9223372036854775807)), false);
-    assert_eq!(call!(eq_si64(4, -1741927215160008704)), false);
-    assert_eq!(call!(eq_si64(4, -1328271339354574848)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_38() {
-    assert_eq!(call!(eq_si64(4, 0)), false);
-    assert_eq!(call!(eq_si64(4, 1)), false);
-    assert_eq!(call!(eq_si64(4, 2)), false);
-    assert_eq!(call!(eq_si64(4, 3)), false);
-    assert_eq!(call!(eq_si64(4, 5577148965131116544)), false);
-    assert_eq!(call!(eq_si64(4, 9223372036854775806)), false);
-    assert_eq!(call!(eq_si64(4, 9223372036854775807)), false);
-    assert_eq!(call!(eq_si64(5577148965131116544, -9223372036854775808)), false);
-    assert_eq!(call!(eq_si64(5577148965131116544, -9223372036854775807)), false);
-    assert_eq!(call!(eq_si64(5577148965131116544, -1741927215160008704)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_39() {
-    assert_eq!(call!(eq_si64(5577148965131116544, -1328271339354574848)), false);
-    assert_eq!(call!(eq_si64(5577148965131116544, 0)), false);
-    assert_eq!(call!(eq_si64(5577148965131116544, 1)), false);
-    assert_eq!(call!(eq_si64(5577148965131116544, 2)), false);
-    assert_eq!(call!(eq_si64(5577148965131116544, 3)), false);
-    assert_eq!(call!(eq_si64(5577148965131116544, 4)), false);
-    assert_eq!(call!(eq_si64(5577148965131116544, 9223372036854775806)), false);
-    assert_eq!(call!(eq_si64(5577148965131116544, 9223372036854775807)), false);
-    assert_eq!(call!(eq_si64(9223372036854775806, -9223372036854775808)), false);
-    assert_eq!(call!(eq_si64(9223372036854775806, -9223372036854775807)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_40() {
-    assert_eq!(call!(eq_si64(9223372036854775806, -1741927215160008704)), false);
-    assert_eq!(call!(eq_si64(9223372036854775806, -1328271339354574848)), false);
-    assert_eq!(call!(eq_si64(9223372036854775806, 0)), false);
-    assert_eq!(call!(eq_si64(9223372036854775806, 1)), false);
-    assert_eq!(call!(eq_si64(9223372036854775806, 2)), false);
-    assert_eq!(call!(eq_si64(9223372036854775806, 3)), false);
-    assert_eq!(call!(eq_si64(9223372036854775806, 4)), false);
-    assert_eq!(call!(eq_si64(9223372036854775806, 5577148965131116544)), false);
-    assert_eq!(call!(eq_si64(9223372036854775806, 9223372036854775807)), false);
-    assert_eq!(call!(eq_si64(9223372036854775807, -9223372036854775808)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_41() {
-    assert_eq!(call!(eq_si64(9223372036854775807, -9223372036854775807)), false);
-    assert_eq!(call!(eq_si64(9223372036854775807, -1741927215160008704)), false);
-    assert_eq!(call!(eq_si64(9223372036854775807, -1328271339354574848)), false);
-    assert_eq!(call!(eq_si64(9223372036854775807, 0)), false);
-    assert_eq!(call!(eq_si64(9223372036854775807, 1)), false);
-    assert_eq!(call!(eq_si64(9223372036854775807, 2)), false);
-    assert_eq!(call!(eq_si64(9223372036854775807, 3)), false);
-    assert_eq!(call!(eq_si64(9223372036854775807, 4)), false);
-    assert_eq!(call!(eq_si64(9223372036854775807, 5577148965131116544)), false);
-    assert_eq!(call!(eq_si64(9223372036854775807, 9223372036854775806)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_42() {
-    assert_eq!(call!(eq_si64(-9223372036854775808, -9223372036854775808)), true);
-    assert_eq!(call!(eq_si64(-9223372036854775807, -9223372036854775807)), true);
-    assert_eq!(call!(eq_si64(-1741927215160008704, -1741927215160008704)), true);
-    assert_eq!(call!(eq_si64(-1328271339354574848, -1328271339354574848)), true);
-    assert_eq!(call!(eq_si64(0, 0)), true);
-    assert_eq!(call!(eq_si64(1, 1)), true);
-    assert_eq!(call!(eq_si64(2, 2)), true);
-    assert_eq!(call!(eq_si64(3, 3)), true);
-    assert_eq!(call!(eq_si64(4, 4)), true);
-    assert_eq!(call!(eq_si64(5577148965131116544, 5577148965131116544)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_43() {
-    assert_eq!(call!(eq_si64(9223372036854775806, 9223372036854775806)), true);
-    assert_eq!(call!(eq_si64(9223372036854775807, 9223372036854775807)), true);
-    assert_eq!(call!(eq_si8(-128, -127)), false);
-    assert_eq!(call!(eq_si8(-128, 0)), false);
-    assert_eq!(call!(eq_si8(-128, 1)), false);
-    assert_eq!(call!(eq_si8(-128, 2)), false);
-    assert_eq!(call!(eq_si8(-128, 3)), false);
-    assert_eq!(call!(eq_si8(-128, 4)), false);
-    assert_eq!(call!(eq_si8(-128, 16)), false);
-    assert_eq!(call!(eq_si8(-128, 126)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_44() {
-    assert_eq!(call!(eq_si8(-128, 127)), false);
-    assert_eq!(call!(eq_si8(-127, -128)), false);
-    assert_eq!(call!(eq_si8(-127, 0)), false);
-    assert_eq!(call!(eq_si8(-127, 1)), false);
-    assert_eq!(call!(eq_si8(-127, 2)), false);
-    assert_eq!(call!(eq_si8(-127, 3)), false);
-    assert_eq!(call!(eq_si8(-127, 4)), false);
-    assert_eq!(call!(eq_si8(-127, 16)), false);
-    assert_eq!(call!(eq_si8(-127, 126)), false);
-    assert_eq!(call!(eq_si8(-127, 127)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_45() {
-    assert_eq!(call!(eq_si8(0, -128)), false);
-    assert_eq!(call!(eq_si8(0, -127)), false);
-    assert_eq!(call!(eq_si8(0, 1)), false);
-    assert_eq!(call!(eq_si8(0, 2)), false);
-    assert_eq!(call!(eq_si8(0, 3)), false);
-    assert_eq!(call!(eq_si8(0, 4)), false);
-    assert_eq!(call!(eq_si8(0, 16)), false);
-    assert_eq!(call!(eq_si8(0, 126)), false);
-    assert_eq!(call!(eq_si8(0, 127)), false);
-    assert_eq!(call!(eq_si8(1, -128)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_46() {
-    assert_eq!(call!(eq_si8(1, -127)), false);
-    assert_eq!(call!(eq_si8(1, 0)), false);
-    assert_eq!(call!(eq_si8(1, 2)), false);
-    assert_eq!(call!(eq_si8(1, 3)), false);
-    assert_eq!(call!(eq_si8(1, 4)), false);
-    assert_eq!(call!(eq_si8(1, 16)), false);
-    assert_eq!(call!(eq_si8(1, 126)), false);
-    assert_eq!(call!(eq_si8(1, 127)), false);
-    assert_eq!(call!(eq_si8(2, -128)), false);
-    assert_eq!(call!(eq_si8(2, -127)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_47() {
-    assert_eq!(call!(eq_si8(2, 0)), false);
-    assert_eq!(call!(eq_si8(2, 1)), false);
-    assert_eq!(call!(eq_si8(2, 3)), false);
-    assert_eq!(call!(eq_si8(2, 4)), false);
-    assert_eq!(call!(eq_si8(2, 16)), false);
-    assert_eq!(call!(eq_si8(2, 126)), false);
-    assert_eq!(call!(eq_si8(2, 127)), false);
-    assert_eq!(call!(eq_si8(3, -128)), false);
-    assert_eq!(call!(eq_si8(3, -127)), false);
-    assert_eq!(call!(eq_si8(3, 0)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_48() {
-    assert_eq!(call!(eq_si8(3, 1)), false);
-    assert_eq!(call!(eq_si8(3, 2)), false);
-    assert_eq!(call!(eq_si8(3, 4)), false);
-    assert_eq!(call!(eq_si8(3, 16)), false);
-    assert_eq!(call!(eq_si8(3, 126)), false);
-    assert_eq!(call!(eq_si8(3, 127)), false);
-    assert_eq!(call!(eq_si8(4, -128)), false);
-    assert_eq!(call!(eq_si8(4, -127)), false);
-    assert_eq!(call!(eq_si8(4, 0)), false);
-    assert_eq!(call!(eq_si8(4, 1)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_49() {
-    assert_eq!(call!(eq_si8(4, 2)), false);
-    assert_eq!(call!(eq_si8(4, 3)), false);
-    assert_eq!(call!(eq_si8(4, 16)), false);
-    assert_eq!(call!(eq_si8(4, 126)), false);
-    assert_eq!(call!(eq_si8(4, 127)), false);
-    assert_eq!(call!(eq_si8(16, -128)), false);
-    assert_eq!(call!(eq_si8(16, -127)), false);
-    assert_eq!(call!(eq_si8(16, 0)), false);
-    assert_eq!(call!(eq_si8(16, 1)), false);
-    assert_eq!(call!(eq_si8(16, 2)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_50() {
-    assert_eq!(call!(eq_si8(16, 3)), false);
-    assert_eq!(call!(eq_si8(16, 4)), false);
-    assert_eq!(call!(eq_si8(16, 126)), false);
-    assert_eq!(call!(eq_si8(16, 127)), false);
-    assert_eq!(call!(eq_si8(126, -128)), false);
-    assert_eq!(call!(eq_si8(126, -127)), false);
-    assert_eq!(call!(eq_si8(126, 0)), false);
-    assert_eq!(call!(eq_si8(126, 1)), false);
-    assert_eq!(call!(eq_si8(126, 2)), false);
-    assert_eq!(call!(eq_si8(126, 3)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_51() {
-    assert_eq!(call!(eq_si8(126, 4)), false);
-    assert_eq!(call!(eq_si8(126, 16)), false);
-    assert_eq!(call!(eq_si8(126, 127)), false);
-    assert_eq!(call!(eq_si8(127, -128)), false);
-    assert_eq!(call!(eq_si8(127, -127)), false);
-    assert_eq!(call!(eq_si8(127, 0)), false);
-    assert_eq!(call!(eq_si8(127, 1)), false);
-    assert_eq!(call!(eq_si8(127, 2)), false);
-    assert_eq!(call!(eq_si8(127, 3)), false);
-    assert_eq!(call!(eq_si8(127, 4)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_52() {
-    assert_eq!(call!(eq_si8(127, 16)), false);
-    assert_eq!(call!(eq_si8(127, 126)), false);
-    assert_eq!(call!(eq_si8(-128, -128)), true);
-    assert_eq!(call!(eq_si8(-127, -127)), true);
-    assert_eq!(call!(eq_si8(0, 0)), true);
-    assert_eq!(call!(eq_si8(1, 1)), true);
-    assert_eq!(call!(eq_si8(2, 2)), true);
-    assert_eq!(call!(eq_si8(3, 3)), true);
-    assert_eq!(call!(eq_si8(4, 4)), true);
-    assert_eq!(call!(eq_si8(16, 16)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_53() {
-    assert_eq!(call!(eq_si8(126, 126)), true);
-    assert_eq!(call!(eq_si8(127, 127)), true);
-    assert_eq!(call!(eq_ui16(0, 1)), false);
-    assert_eq!(call!(eq_ui16(0, 2)), false);
-    assert_eq!(call!(eq_ui16(0, 3)), false);
-    assert_eq!(call!(eq_ui16(0, 4)), false);
-    assert_eq!(call!(eq_ui16(0, 1717)), false);
-    assert_eq!(call!(eq_ui16(0, 17988)), false);
-    assert_eq!(call!(eq_ui16(0, 65096)), false);
-    assert_eq!(call!(eq_ui16(0, 65534)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_54() {
-    assert_eq!(call!(eq_ui16(0, 65535)), false);
-    assert_eq!(call!(eq_ui16(1, 0)), false);
-    assert_eq!(call!(eq_ui16(1, 2)), false);
-    assert_eq!(call!(eq_ui16(1, 3)), false);
-    assert_eq!(call!(eq_ui16(1, 4)), false);
-    assert_eq!(call!(eq_ui16(1, 1717)), false);
-    assert_eq!(call!(eq_ui16(1, 17988)), false);
-    assert_eq!(call!(eq_ui16(1, 65096)), false);
-    assert_eq!(call!(eq_ui16(1, 65534)), false);
-    assert_eq!(call!(eq_ui16(1, 65535)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_55() {
-    assert_eq!(call!(eq_ui16(2, 0)), false);
-    assert_eq!(call!(eq_ui16(2, 1)), false);
-    assert_eq!(call!(eq_ui16(2, 3)), false);
-    assert_eq!(call!(eq_ui16(2, 4)), false);
-    assert_eq!(call!(eq_ui16(2, 1717)), false);
-    assert_eq!(call!(eq_ui16(2, 17988)), false);
-    assert_eq!(call!(eq_ui16(2, 65096)), false);
-    assert_eq!(call!(eq_ui16(2, 65534)), false);
-    assert_eq!(call!(eq_ui16(2, 65535)), false);
-    assert_eq!(call!(eq_ui16(3, 0)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_56() {
-    assert_eq!(call!(eq_ui16(3, 1)), false);
-    assert_eq!(call!(eq_ui16(3, 2)), false);
-    assert_eq!(call!(eq_ui16(3, 4)), false);
-    assert_eq!(call!(eq_ui16(3, 1717)), false);
-    assert_eq!(call!(eq_ui16(3, 17988)), false);
-    assert_eq!(call!(eq_ui16(3, 65096)), false);
-    assert_eq!(call!(eq_ui16(3, 65534)), false);
-    assert_eq!(call!(eq_ui16(3, 65535)), false);
-    assert_eq!(call!(eq_ui16(4, 0)), false);
-    assert_eq!(call!(eq_ui16(4, 1)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_57() {
-    assert_eq!(call!(eq_ui16(4, 2)), false);
-    assert_eq!(call!(eq_ui16(4, 3)), false);
-    assert_eq!(call!(eq_ui16(4, 1717)), false);
-    assert_eq!(call!(eq_ui16(4, 17988)), false);
-    assert_eq!(call!(eq_ui16(4, 65096)), false);
-    assert_eq!(call!(eq_ui16(4, 65534)), false);
-    assert_eq!(call!(eq_ui16(4, 65535)), false);
-    assert_eq!(call!(eq_ui16(1717, 0)), false);
-    assert_eq!(call!(eq_ui16(1717, 1)), false);
-    assert_eq!(call!(eq_ui16(1717, 2)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_58() {
-    assert_eq!(call!(eq_ui16(1717, 3)), false);
-    assert_eq!(call!(eq_ui16(1717, 4)), false);
-    assert_eq!(call!(eq_ui16(1717, 17988)), false);
-    assert_eq!(call!(eq_ui16(1717, 65096)), false);
-    assert_eq!(call!(eq_ui16(1717, 65534)), false);
-    assert_eq!(call!(eq_ui16(1717, 65535)), false);
-    assert_eq!(call!(eq_ui16(17988, 0)), false);
-    assert_eq!(call!(eq_ui16(17988, 1)), false);
-    assert_eq!(call!(eq_ui16(17988, 2)), false);
-    assert_eq!(call!(eq_ui16(17988, 3)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_59() {
-    assert_eq!(call!(eq_ui16(17988, 4)), false);
-    assert_eq!(call!(eq_ui16(17988, 1717)), false);
-    assert_eq!(call!(eq_ui16(17988, 65096)), false);
-    assert_eq!(call!(eq_ui16(17988, 65534)), false);
-    assert_eq!(call!(eq_ui16(17988, 65535)), false);
-    assert_eq!(call!(eq_ui16(65096, 0)), false);
-    assert_eq!(call!(eq_ui16(65096, 1)), false);
-    assert_eq!(call!(eq_ui16(65096, 2)), false);
-    assert_eq!(call!(eq_ui16(65096, 3)), false);
-    assert_eq!(call!(eq_ui16(65096, 4)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_60() {
-    assert_eq!(call!(eq_ui16(65096, 1717)), false);
-    assert_eq!(call!(eq_ui16(65096, 17988)), false);
-    assert_eq!(call!(eq_ui16(65096, 65534)), false);
-    assert_eq!(call!(eq_ui16(65096, 65535)), false);
-    assert_eq!(call!(eq_ui16(65534, 0)), false);
-    assert_eq!(call!(eq_ui16(65534, 1)), false);
-    assert_eq!(call!(eq_ui16(65534, 2)), false);
-    assert_eq!(call!(eq_ui16(65534, 3)), false);
-    assert_eq!(call!(eq_ui16(65534, 4)), false);
-    assert_eq!(call!(eq_ui16(65534, 1717)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_61() {
-    assert_eq!(call!(eq_ui16(65534, 17988)), false);
-    assert_eq!(call!(eq_ui16(65534, 65096)), false);
-    assert_eq!(call!(eq_ui16(65534, 65535)), false);
-    assert_eq!(call!(eq_ui16(65535, 0)), false);
-    assert_eq!(call!(eq_ui16(65535, 1)), false);
-    assert_eq!(call!(eq_ui16(65535, 2)), false);
-    assert_eq!(call!(eq_ui16(65535, 3)), false);
-    assert_eq!(call!(eq_ui16(65535, 4)), false);
-    assert_eq!(call!(eq_ui16(65535, 1717)), false);
-    assert_eq!(call!(eq_ui16(65535, 17988)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_62() {
-    assert_eq!(call!(eq_ui16(65535, 65096)), false);
-    assert_eq!(call!(eq_ui16(65535, 65534)), false);
-    assert_eq!(call!(eq_ui16(0, 0)), true);
-    assert_eq!(call!(eq_ui16(1, 1)), true);
-    assert_eq!(call!(eq_ui16(2, 2)), true);
-    assert_eq!(call!(eq_ui16(3, 3)), true);
-    assert_eq!(call!(eq_ui16(4, 4)), true);
-    assert_eq!(call!(eq_ui16(1717, 1717)), true);
-    assert_eq!(call!(eq_ui16(17988, 17988)), true);
-    assert_eq!(call!(eq_ui16(65096, 65096)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_63() {
-    assert_eq!(call!(eq_ui16(65534, 65534)), true);
-    assert_eq!(call!(eq_ui16(65535, 65535)), true);
-    assert_eq!(call!(eq_ui32(0, 1)), false);
-    assert_eq!(call!(eq_ui32(0, 2)), false);
-    assert_eq!(call!(eq_ui32(0, 3)), false);
-    assert_eq!(call!(eq_ui32(0, 4)), false);
-    assert_eq!(call!(eq_ui32(0, 2119154652)), false);
-    assert_eq!(call!(eq_ui32(0, 3002788344)), false);
-    assert_eq!(call!(eq_ui32(0, 3482297128)), false);
-    assert_eq!(call!(eq_ui32(0, 4294967294)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_64() {
-    assert_eq!(call!(eq_ui32(0, 4294967295)), false);
-    assert_eq!(call!(eq_ui32(1, 0)), false);
-    assert_eq!(call!(eq_ui32(1, 2)), false);
-    assert_eq!(call!(eq_ui32(1, 3)), false);
-    assert_eq!(call!(eq_ui32(1, 4)), false);
-    assert_eq!(call!(eq_ui32(1, 2119154652)), false);
-    assert_eq!(call!(eq_ui32(1, 3002788344)), false);
-    assert_eq!(call!(eq_ui32(1, 3482297128)), false);
-    assert_eq!(call!(eq_ui32(1, 4294967294)), false);
-    assert_eq!(call!(eq_ui32(1, 4294967295)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_65() {
-    assert_eq!(call!(eq_ui32(2, 0)), false);
-    assert_eq!(call!(eq_ui32(2, 1)), false);
-    assert_eq!(call!(eq_ui32(2, 3)), false);
-    assert_eq!(call!(eq_ui32(2, 4)), false);
-    assert_eq!(call!(eq_ui32(2, 2119154652)), false);
-    assert_eq!(call!(eq_ui32(2, 3002788344)), false);
-    assert_eq!(call!(eq_ui32(2, 3482297128)), false);
-    assert_eq!(call!(eq_ui32(2, 4294967294)), false);
-    assert_eq!(call!(eq_ui32(2, 4294967295)), false);
-    assert_eq!(call!(eq_ui32(3, 0)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_66() {
-    assert_eq!(call!(eq_ui32(3, 1)), false);
-    assert_eq!(call!(eq_ui32(3, 2)), false);
-    assert_eq!(call!(eq_ui32(3, 4)), false);
-    assert_eq!(call!(eq_ui32(3, 2119154652)), false);
-    assert_eq!(call!(eq_ui32(3, 3002788344)), false);
-    assert_eq!(call!(eq_ui32(3, 3482297128)), false);
-    assert_eq!(call!(eq_ui32(3, 4294967294)), false);
-    assert_eq!(call!(eq_ui32(3, 4294967295)), false);
-    assert_eq!(call!(eq_ui32(4, 0)), false);
-    assert_eq!(call!(eq_ui32(4, 1)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_67() {
-    assert_eq!(call!(eq_ui32(4, 2)), false);
-    assert_eq!(call!(eq_ui32(4, 3)), false);
-    assert_eq!(call!(eq_ui32(4, 2119154652)), false);
-    assert_eq!(call!(eq_ui32(4, 3002788344)), false);
-    assert_eq!(call!(eq_ui32(4, 3482297128)), false);
-    assert_eq!(call!(eq_ui32(4, 4294967294)), false);
-    assert_eq!(call!(eq_ui32(4, 4294967295)), false);
-    assert_eq!(call!(eq_ui32(2119154652, 0)), false);
-    assert_eq!(call!(eq_ui32(2119154652, 1)), false);
-    assert_eq!(call!(eq_ui32(2119154652, 2)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_68() {
-    assert_eq!(call!(eq_ui32(2119154652, 3)), false);
-    assert_eq!(call!(eq_ui32(2119154652, 4)), false);
-    assert_eq!(call!(eq_ui32(2119154652, 3002788344)), false);
-    assert_eq!(call!(eq_ui32(2119154652, 3482297128)), false);
-    assert_eq!(call!(eq_ui32(2119154652, 4294967294)), false);
-    assert_eq!(call!(eq_ui32(2119154652, 4294967295)), false);
-    assert_eq!(call!(eq_ui32(3002788344, 0)), false);
-    assert_eq!(call!(eq_ui32(3002788344, 1)), false);
-    assert_eq!(call!(eq_ui32(3002788344, 2)), false);
-    assert_eq!(call!(eq_ui32(3002788344, 3)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_69() {
-    assert_eq!(call!(eq_ui32(3002788344, 4)), false);
-    assert_eq!(call!(eq_ui32(3002788344, 2119154652)), false);
-    assert_eq!(call!(eq_ui32(3002788344, 3482297128)), false);
-    assert_eq!(call!(eq_ui32(3002788344, 4294967294)), false);
-    assert_eq!(call!(eq_ui32(3002788344, 4294967295)), false);
-    assert_eq!(call!(eq_ui32(3482297128, 0)), false);
-    assert_eq!(call!(eq_ui32(3482297128, 1)), false);
-    assert_eq!(call!(eq_ui32(3482297128, 2)), false);
-    assert_eq!(call!(eq_ui32(3482297128, 3)), false);
-    assert_eq!(call!(eq_ui32(3482297128, 4)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_70() {
-    assert_eq!(call!(eq_ui32(3482297128, 2119154652)), false);
-    assert_eq!(call!(eq_ui32(3482297128, 3002788344)), false);
-    assert_eq!(call!(eq_ui32(3482297128, 4294967294)), false);
-    assert_eq!(call!(eq_ui32(3482297128, 4294967295)), false);
-    assert_eq!(call!(eq_ui32(4294967294, 0)), false);
-    assert_eq!(call!(eq_ui32(4294967294, 1)), false);
-    assert_eq!(call!(eq_ui32(4294967294, 2)), false);
-    assert_eq!(call!(eq_ui32(4294967294, 3)), false);
-    assert_eq!(call!(eq_ui32(4294967294, 4)), false);
-    assert_eq!(call!(eq_ui32(4294967294, 2119154652)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_71() {
-    assert_eq!(call!(eq_ui32(4294967294, 3002788344)), false);
-    assert_eq!(call!(eq_ui32(4294967294, 3482297128)), false);
-    assert_eq!(call!(eq_ui32(4294967294, 4294967295)), false);
-    assert_eq!(call!(eq_ui32(4294967295, 0)), false);
-    assert_eq!(call!(eq_ui32(4294967295, 1)), false);
-    assert_eq!(call!(eq_ui32(4294967295, 2)), false);
-    assert_eq!(call!(eq_ui32(4294967295, 3)), false);
-    assert_eq!(call!(eq_ui32(4294967295, 4)), false);
-    assert_eq!(call!(eq_ui32(4294967295, 2119154652)), false);
-    assert_eq!(call!(eq_ui32(4294967295, 3002788344)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_72() {
-    assert_eq!(call!(eq_ui32(4294967295, 3482297128)), false);
-    assert_eq!(call!(eq_ui32(4294967295, 4294967294)), false);
-    assert_eq!(call!(eq_ui32(0, 0)), true);
-    assert_eq!(call!(eq_ui32(1, 1)), true);
-    assert_eq!(call!(eq_ui32(2, 2)), true);
-    assert_eq!(call!(eq_ui32(3, 3)), true);
-    assert_eq!(call!(eq_ui32(4, 4)), true);
-    assert_eq!(call!(eq_ui32(2119154652, 2119154652)), true);
-    assert_eq!(call!(eq_ui32(3002788344, 3002788344)), true);
-    assert_eq!(call!(eq_ui32(3482297128, 3482297128)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_73() {
-    assert_eq!(call!(eq_ui32(4294967294, 4294967294)), true);
-    assert_eq!(call!(eq_ui32(4294967295, 4294967295)), true);
-    assert_eq!(call!(eq_ui64(0, 1)), false);
-    assert_eq!(call!(eq_ui64(0, 2)), false);
-    assert_eq!(call!(eq_ui64(0, 3)), false);
-    assert_eq!(call!(eq_ui64(0, 4)), false);
-    assert_eq!(call!(eq_ui64(0, 191084152064409600)), false);
-    assert_eq!(call!(eq_ui64(0, 11015955194427482112)), false);
-    assert_eq!(call!(eq_ui64(0, 16990600415051759616)), false);
-    assert_eq!(call!(eq_ui64(0, 18446744073709551614)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_74() {
-    assert_eq!(call!(eq_ui64(0, 18446744073709551615)), false);
-    assert_eq!(call!(eq_ui64(1, 0)), false);
-    assert_eq!(call!(eq_ui64(1, 2)), false);
-    assert_eq!(call!(eq_ui64(1, 3)), false);
-    assert_eq!(call!(eq_ui64(1, 4)), false);
-    assert_eq!(call!(eq_ui64(1, 191084152064409600)), false);
-    assert_eq!(call!(eq_ui64(1, 11015955194427482112)), false);
-    assert_eq!(call!(eq_ui64(1, 16990600415051759616)), false);
-    assert_eq!(call!(eq_ui64(1, 18446744073709551614)), false);
-    assert_eq!(call!(eq_ui64(1, 18446744073709551615)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_75() {
-    assert_eq!(call!(eq_ui64(2, 0)), false);
-    assert_eq!(call!(eq_ui64(2, 1)), false);
-    assert_eq!(call!(eq_ui64(2, 3)), false);
-    assert_eq!(call!(eq_ui64(2, 4)), false);
-    assert_eq!(call!(eq_ui64(2, 191084152064409600)), false);
-    assert_eq!(call!(eq_ui64(2, 11015955194427482112)), false);
-    assert_eq!(call!(eq_ui64(2, 16990600415051759616)), false);
-    assert_eq!(call!(eq_ui64(2, 18446744073709551614)), false);
-    assert_eq!(call!(eq_ui64(2, 18446744073709551615)), false);
-    assert_eq!(call!(eq_ui64(3, 0)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_76() {
-    assert_eq!(call!(eq_ui64(3, 1)), false);
-    assert_eq!(call!(eq_ui64(3, 2)), false);
-    assert_eq!(call!(eq_ui64(3, 4)), false);
-    assert_eq!(call!(eq_ui64(3, 191084152064409600)), false);
-    assert_eq!(call!(eq_ui64(3, 11015955194427482112)), false);
-    assert_eq!(call!(eq_ui64(3, 16990600415051759616)), false);
-    assert_eq!(call!(eq_ui64(3, 18446744073709551614)), false);
-    assert_eq!(call!(eq_ui64(3, 18446744073709551615)), false);
-    assert_eq!(call!(eq_ui64(4, 0)), false);
-    assert_eq!(call!(eq_ui64(4, 1)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_77() {
-    assert_eq!(call!(eq_ui64(4, 2)), false);
-    assert_eq!(call!(eq_ui64(4, 3)), false);
-    assert_eq!(call!(eq_ui64(4, 191084152064409600)), false);
-    assert_eq!(call!(eq_ui64(4, 11015955194427482112)), false);
-    assert_eq!(call!(eq_ui64(4, 16990600415051759616)), false);
-    assert_eq!(call!(eq_ui64(4, 18446744073709551614)), false);
-    assert_eq!(call!(eq_ui64(4, 18446744073709551615)), false);
-    assert_eq!(call!(eq_ui64(191084152064409600, 0)), false);
-    assert_eq!(call!(eq_ui64(191084152064409600, 1)), false);
-    assert_eq!(call!(eq_ui64(191084152064409600, 2)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_78() {
-    assert_eq!(call!(eq_ui64(191084152064409600, 3)), false);
-    assert_eq!(call!(eq_ui64(191084152064409600, 4)), false);
-    assert_eq!(call!(eq_ui64(191084152064409600, 11015955194427482112)), false);
-    assert_eq!(call!(eq_ui64(191084152064409600, 16990600415051759616)), false);
-    assert_eq!(call!(eq_ui64(191084152064409600, 18446744073709551614)), false);
-    assert_eq!(call!(eq_ui64(191084152064409600, 18446744073709551615)), false);
-    assert_eq!(call!(eq_ui64(11015955194427482112, 0)), false);
-    assert_eq!(call!(eq_ui64(11015955194427482112, 1)), false);
-    assert_eq!(call!(eq_ui64(11015955194427482112, 2)), false);
-    assert_eq!(call!(eq_ui64(11015955194427482112, 3)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_79() {
-    assert_eq!(call!(eq_ui64(11015955194427482112, 4)), false);
-    assert_eq!(call!(eq_ui64(11015955194427482112, 191084152064409600)), false);
-    assert_eq!(call!(eq_ui64(11015955194427482112, 16990600415051759616)), false);
-    assert_eq!(call!(eq_ui64(11015955194427482112, 18446744073709551614)), false);
-    assert_eq!(call!(eq_ui64(11015955194427482112, 18446744073709551615)), false);
-    assert_eq!(call!(eq_ui64(16990600415051759616, 0)), false);
-    assert_eq!(call!(eq_ui64(16990600415051759616, 1)), false);
-    assert_eq!(call!(eq_ui64(16990600415051759616, 2)), false);
-    assert_eq!(call!(eq_ui64(16990600415051759616, 3)), false);
-    assert_eq!(call!(eq_ui64(16990600415051759616, 4)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_80() {
-    assert_eq!(call!(eq_ui64(16990600415051759616, 191084152064409600)), false);
-    assert_eq!(call!(eq_ui64(16990600415051759616, 11015955194427482112)), false);
-    assert_eq!(call!(eq_ui64(16990600415051759616, 18446744073709551614)), false);
-    assert_eq!(call!(eq_ui64(16990600415051759616, 18446744073709551615)), false);
-    assert_eq!(call!(eq_ui64(18446744073709551614, 0)), false);
-    assert_eq!(call!(eq_ui64(18446744073709551614, 1)), false);
-    assert_eq!(call!(eq_ui64(18446744073709551614, 2)), false);
-    assert_eq!(call!(eq_ui64(18446744073709551614, 3)), false);
-    assert_eq!(call!(eq_ui64(18446744073709551614, 4)), false);
-    assert_eq!(call!(eq_ui64(18446744073709551614, 191084152064409600)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_81() {
-    assert_eq!(call!(eq_ui64(18446744073709551614, 11015955194427482112)), false);
-    assert_eq!(call!(eq_ui64(18446744073709551614, 16990600415051759616)), false);
-    assert_eq!(call!(eq_ui64(18446744073709551614, 18446744073709551615)), false);
-    assert_eq!(call!(eq_ui64(18446744073709551615, 0)), false);
-    assert_eq!(call!(eq_ui64(18446744073709551615, 1)), false);
-    assert_eq!(call!(eq_ui64(18446744073709551615, 2)), false);
-    assert_eq!(call!(eq_ui64(18446744073709551615, 3)), false);
-    assert_eq!(call!(eq_ui64(18446744073709551615, 4)), false);
-    assert_eq!(call!(eq_ui64(18446744073709551615, 191084152064409600)), false);
-    assert_eq!(call!(eq_ui64(18446744073709551615, 11015955194427482112)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_82() {
-    assert_eq!(call!(eq_ui64(18446744073709551615, 16990600415051759616)), false);
-    assert_eq!(call!(eq_ui64(18446744073709551615, 18446744073709551614)), false);
-    assert_eq!(call!(eq_ui64(0, 0)), true);
-    assert_eq!(call!(eq_ui64(1, 1)), true);
-    assert_eq!(call!(eq_ui64(2, 2)), true);
-    assert_eq!(call!(eq_ui64(3, 3)), true);
-    assert_eq!(call!(eq_ui64(4, 4)), true);
-    assert_eq!(call!(eq_ui64(191084152064409600, 191084152064409600)), true);
-    assert_eq!(call!(eq_ui64(11015955194427482112, 11015955194427482112)), true);
-    assert_eq!(call!(eq_ui64(16990600415051759616, 16990600415051759616)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_83() {
-    assert_eq!(call!(eq_ui64(18446744073709551614, 18446744073709551614)), true);
-    assert_eq!(call!(eq_ui64(18446744073709551615, 18446744073709551615)), true);
-    assert_eq!(call!(eq_ui8(0, 1)), false);
-    assert_eq!(call!(eq_ui8(0, 2)), false);
-    assert_eq!(call!(eq_ui8(0, 3)), false);
-    assert_eq!(call!(eq_ui8(0, 4)), false);
-    assert_eq!(call!(eq_ui8(0, 72)), false);
-    assert_eq!(call!(eq_ui8(0, 100)), false);
-    assert_eq!(call!(eq_ui8(0, 162)), false);
-    assert_eq!(call!(eq_ui8(0, 254)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_84() {
-    assert_eq!(call!(eq_ui8(0, 255)), false);
-    assert_eq!(call!(eq_ui8(1, 0)), false);
-    assert_eq!(call!(eq_ui8(1, 2)), false);
-    assert_eq!(call!(eq_ui8(1, 3)), false);
-    assert_eq!(call!(eq_ui8(1, 4)), false);
-    assert_eq!(call!(eq_ui8(1, 72)), false);
-    assert_eq!(call!(eq_ui8(1, 100)), false);
-    assert_eq!(call!(eq_ui8(1, 162)), false);
-    assert_eq!(call!(eq_ui8(1, 254)), false);
-    assert_eq!(call!(eq_ui8(1, 255)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_85() {
-    assert_eq!(call!(eq_ui8(2, 0)), false);
-    assert_eq!(call!(eq_ui8(2, 1)), false);
-    assert_eq!(call!(eq_ui8(2, 3)), false);
-    assert_eq!(call!(eq_ui8(2, 4)), false);
-    assert_eq!(call!(eq_ui8(2, 72)), false);
-    assert_eq!(call!(eq_ui8(2, 100)), false);
-    assert_eq!(call!(eq_ui8(2, 162)), false);
-    assert_eq!(call!(eq_ui8(2, 254)), false);
-    assert_eq!(call!(eq_ui8(2, 255)), false);
-    assert_eq!(call!(eq_ui8(3, 0)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_86() {
-    assert_eq!(call!(eq_ui8(3, 1)), false);
-    assert_eq!(call!(eq_ui8(3, 2)), false);
-    assert_eq!(call!(eq_ui8(3, 4)), false);
-    assert_eq!(call!(eq_ui8(3, 72)), false);
-    assert_eq!(call!(eq_ui8(3, 100)), false);
-    assert_eq!(call!(eq_ui8(3, 162)), false);
-    assert_eq!(call!(eq_ui8(3, 254)), false);
-    assert_eq!(call!(eq_ui8(3, 255)), false);
-    assert_eq!(call!(eq_ui8(4, 0)), false);
-    assert_eq!(call!(eq_ui8(4, 1)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_87() {
-    assert_eq!(call!(eq_ui8(4, 2)), false);
-    assert_eq!(call!(eq_ui8(4, 3)), false);
-    assert_eq!(call!(eq_ui8(4, 72)), false);
-    assert_eq!(call!(eq_ui8(4, 100)), false);
-    assert_eq!(call!(eq_ui8(4, 162)), false);
-    assert_eq!(call!(eq_ui8(4, 254)), false);
-    assert_eq!(call!(eq_ui8(4, 255)), false);
-    assert_eq!(call!(eq_ui8(72, 0)), false);
-    assert_eq!(call!(eq_ui8(72, 1)), false);
-    assert_eq!(call!(eq_ui8(72, 2)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_88() {
-    assert_eq!(call!(eq_ui8(72, 3)), false);
-    assert_eq!(call!(eq_ui8(72, 4)), false);
-    assert_eq!(call!(eq_ui8(72, 100)), false);
-    assert_eq!(call!(eq_ui8(72, 162)), false);
-    assert_eq!(call!(eq_ui8(72, 254)), false);
-    assert_eq!(call!(eq_ui8(72, 255)), false);
-    assert_eq!(call!(eq_ui8(100, 0)), false);
-    assert_eq!(call!(eq_ui8(100, 1)), false);
-    assert_eq!(call!(eq_ui8(100, 2)), false);
-    assert_eq!(call!(eq_ui8(100, 3)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_89() {
-    assert_eq!(call!(eq_ui8(100, 4)), false);
-    assert_eq!(call!(eq_ui8(100, 72)), false);
-    assert_eq!(call!(eq_ui8(100, 162)), false);
-    assert_eq!(call!(eq_ui8(100, 254)), false);
-    assert_eq!(call!(eq_ui8(100, 255)), false);
-    assert_eq!(call!(eq_ui8(162, 0)), false);
-    assert_eq!(call!(eq_ui8(162, 1)), false);
-    assert_eq!(call!(eq_ui8(162, 2)), false);
-    assert_eq!(call!(eq_ui8(162, 3)), false);
-    assert_eq!(call!(eq_ui8(162, 4)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_90() {
-    assert_eq!(call!(eq_ui8(162, 72)), false);
-    assert_eq!(call!(eq_ui8(162, 100)), false);
-    assert_eq!(call!(eq_ui8(162, 254)), false);
-    assert_eq!(call!(eq_ui8(162, 255)), false);
-    assert_eq!(call!(eq_ui8(254, 0)), false);
-    assert_eq!(call!(eq_ui8(254, 1)), false);
-    assert_eq!(call!(eq_ui8(254, 2)), false);
-    assert_eq!(call!(eq_ui8(254, 3)), false);
-    assert_eq!(call!(eq_ui8(254, 4)), false);
-    assert_eq!(call!(eq_ui8(254, 72)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_91() {
-    assert_eq!(call!(eq_ui8(254, 100)), false);
-    assert_eq!(call!(eq_ui8(254, 162)), false);
-    assert_eq!(call!(eq_ui8(254, 255)), false);
-    assert_eq!(call!(eq_ui8(255, 0)), false);
-    assert_eq!(call!(eq_ui8(255, 1)), false);
-    assert_eq!(call!(eq_ui8(255, 2)), false);
-    assert_eq!(call!(eq_ui8(255, 3)), false);
-    assert_eq!(call!(eq_ui8(255, 4)), false);
-    assert_eq!(call!(eq_ui8(255, 72)), false);
-    assert_eq!(call!(eq_ui8(255, 100)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_92() {
-    assert_eq!(call!(eq_ui8(255, 162)), false);
-    assert_eq!(call!(eq_ui8(255, 254)), false);
-    assert_eq!(call!(eq_ui8(0, 0)), true);
-    assert_eq!(call!(eq_ui8(1, 1)), true);
-    assert_eq!(call!(eq_ui8(2, 2)), true);
-    assert_eq!(call!(eq_ui8(3, 3)), true);
-    assert_eq!(call!(eq_ui8(4, 4)), true);
-    assert_eq!(call!(eq_ui8(72, 72)), true);
-    assert_eq!(call!(eq_ui8(100, 100)), true);
-    assert_eq!(call!(eq_ui8(162, 162)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_93() {
-    assert_eq!(call!(eq_ui8(254, 254)), true);
-    assert_eq!(call!(eq_ui8(255, 255)), true);
-    assert_eq!(call!(ge_si16(-32768, -32767)), false);
-    assert_eq!(call!(ge_si16(-32768, -32547)), false);
-    assert_eq!(call!(ge_si16(-32768, 0)), false);
-    assert_eq!(call!(ge_si16(-32768, 1)), false);
-    assert_eq!(call!(ge_si16(-32768, 2)), false);
-    assert_eq!(call!(ge_si16(-32768, 3)), false);
-    assert_eq!(call!(ge_si16(-32768, 4)), false);
-    assert_eq!(call!(ge_si16(-32768, 10486)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_94() {
-    assert_eq!(call!(ge_si16(-32768, 16514)), false);
-    assert_eq!(call!(ge_si16(-32768, 32766)), false);
-    assert_eq!(call!(ge_si16(-32768, 32767)), false);
-    assert_eq!(call!(ge_si16(-32767, -32547)), false);
-    assert_eq!(call!(ge_si16(-32767, 0)), false);
-    assert_eq!(call!(ge_si16(-32767, 1)), false);
-    assert_eq!(call!(ge_si16(-32767, 2)), false);
-    assert_eq!(call!(ge_si16(-32767, 3)), false);
-    assert_eq!(call!(ge_si16(-32767, 4)), false);
-    assert_eq!(call!(ge_si16(-32767, 10486)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_95() {
-    assert_eq!(call!(ge_si16(-32767, 16514)), false);
-    assert_eq!(call!(ge_si16(-32767, 32766)), false);
-    assert_eq!(call!(ge_si16(-32767, 32767)), false);
-    assert_eq!(call!(ge_si16(-32547, 0)), false);
-    assert_eq!(call!(ge_si16(-32547, 1)), false);
-    assert_eq!(call!(ge_si16(-32547, 2)), false);
-    assert_eq!(call!(ge_si16(-32547, 3)), false);
-    assert_eq!(call!(ge_si16(-32547, 4)), false);
-    assert_eq!(call!(ge_si16(-32547, 10486)), false);
-    assert_eq!(call!(ge_si16(-32547, 16514)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_96() {
-    assert_eq!(call!(ge_si16(-32547, 32766)), false);
-    assert_eq!(call!(ge_si16(-32547, 32767)), false);
-    assert_eq!(call!(ge_si16(0, 1)), false);
-    assert_eq!(call!(ge_si16(0, 2)), false);
-    assert_eq!(call!(ge_si16(0, 3)), false);
-    assert_eq!(call!(ge_si16(0, 4)), false);
-    assert_eq!(call!(ge_si16(0, 10486)), false);
-    assert_eq!(call!(ge_si16(0, 16514)), false);
-    assert_eq!(call!(ge_si16(0, 32766)), false);
-    assert_eq!(call!(ge_si16(0, 32767)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_97() {
-    assert_eq!(call!(ge_si16(1, 2)), false);
-    assert_eq!(call!(ge_si16(1, 3)), false);
-    assert_eq!(call!(ge_si16(1, 4)), false);
-    assert_eq!(call!(ge_si16(1, 10486)), false);
-    assert_eq!(call!(ge_si16(1, 16514)), false);
-    assert_eq!(call!(ge_si16(1, 32766)), false);
-    assert_eq!(call!(ge_si16(1, 32767)), false);
-    assert_eq!(call!(ge_si16(2, 3)), false);
-    assert_eq!(call!(ge_si16(2, 4)), false);
-    assert_eq!(call!(ge_si16(2, 10486)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_98() {
-    assert_eq!(call!(ge_si16(2, 16514)), false);
-    assert_eq!(call!(ge_si16(2, 32766)), false);
-    assert_eq!(call!(ge_si16(2, 32767)), false);
-    assert_eq!(call!(ge_si16(3, 4)), false);
-    assert_eq!(call!(ge_si16(3, 10486)), false);
-    assert_eq!(call!(ge_si16(3, 16514)), false);
-    assert_eq!(call!(ge_si16(3, 32766)), false);
-    assert_eq!(call!(ge_si16(3, 32767)), false);
-    assert_eq!(call!(ge_si16(4, 10486)), false);
-    assert_eq!(call!(ge_si16(4, 16514)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_99() {
-    assert_eq!(call!(ge_si16(4, 32766)), false);
-    assert_eq!(call!(ge_si16(4, 32767)), false);
-    assert_eq!(call!(ge_si16(10486, 16514)), false);
-    assert_eq!(call!(ge_si16(10486, 32766)), false);
-    assert_eq!(call!(ge_si16(10486, 32767)), false);
-    assert_eq!(call!(ge_si16(16514, 32766)), false);
-    assert_eq!(call!(ge_si16(16514, 32767)), false);
-    assert_eq!(call!(ge_si16(32766, 32767)), false);
-    assert_eq!(call!(ge_si16(-32768, -32768)), true);
-    assert_eq!(call!(ge_si16(-32767, -32768)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_100() {
-    assert_eq!(call!(ge_si16(-32767, -32767)), true);
-    assert_eq!(call!(ge_si16(-32547, -32768)), true);
-    assert_eq!(call!(ge_si16(-32547, -32767)), true);
-    assert_eq!(call!(ge_si16(-32547, -32547)), true);
-    assert_eq!(call!(ge_si16(0, -32768)), true);
-    assert_eq!(call!(ge_si16(0, -32767)), true);
-    assert_eq!(call!(ge_si16(0, -32547)), true);
-    assert_eq!(call!(ge_si16(0, 0)), true);
-    assert_eq!(call!(ge_si16(1, -32768)), true);
-    assert_eq!(call!(ge_si16(1, -32767)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_101() {
-    assert_eq!(call!(ge_si16(1, -32547)), true);
-    assert_eq!(call!(ge_si16(1, 0)), true);
-    assert_eq!(call!(ge_si16(1, 1)), true);
-    assert_eq!(call!(ge_si16(2, -32768)), true);
-    assert_eq!(call!(ge_si16(2, -32767)), true);
-    assert_eq!(call!(ge_si16(2, -32547)), true);
-    assert_eq!(call!(ge_si16(2, 0)), true);
-    assert_eq!(call!(ge_si16(2, 1)), true);
-    assert_eq!(call!(ge_si16(2, 2)), true);
-    assert_eq!(call!(ge_si16(3, -32768)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_102() {
-    assert_eq!(call!(ge_si16(3, -32767)), true);
-    assert_eq!(call!(ge_si16(3, -32547)), true);
-    assert_eq!(call!(ge_si16(3, 0)), true);
-    assert_eq!(call!(ge_si16(3, 1)), true);
-    assert_eq!(call!(ge_si16(3, 2)), true);
-    assert_eq!(call!(ge_si16(3, 3)), true);
-    assert_eq!(call!(ge_si16(4, -32768)), true);
-    assert_eq!(call!(ge_si16(4, -32767)), true);
-    assert_eq!(call!(ge_si16(4, -32547)), true);
-    assert_eq!(call!(ge_si16(4, 0)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_103() {
-    assert_eq!(call!(ge_si16(4, 1)), true);
-    assert_eq!(call!(ge_si16(4, 2)), true);
-    assert_eq!(call!(ge_si16(4, 3)), true);
-    assert_eq!(call!(ge_si16(4, 4)), true);
-    assert_eq!(call!(ge_si16(10486, -32768)), true);
-    assert_eq!(call!(ge_si16(10486, -32767)), true);
-    assert_eq!(call!(ge_si16(10486, -32547)), true);
-    assert_eq!(call!(ge_si16(10486, 0)), true);
-    assert_eq!(call!(ge_si16(10486, 1)), true);
-    assert_eq!(call!(ge_si16(10486, 2)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_104() {
-    assert_eq!(call!(ge_si16(10486, 3)), true);
-    assert_eq!(call!(ge_si16(10486, 4)), true);
-    assert_eq!(call!(ge_si16(10486, 10486)), true);
-    assert_eq!(call!(ge_si16(16514, -32768)), true);
-    assert_eq!(call!(ge_si16(16514, -32767)), true);
-    assert_eq!(call!(ge_si16(16514, -32547)), true);
-    assert_eq!(call!(ge_si16(16514, 0)), true);
-    assert_eq!(call!(ge_si16(16514, 1)), true);
-    assert_eq!(call!(ge_si16(16514, 2)), true);
-    assert_eq!(call!(ge_si16(16514, 3)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_105() {
-    assert_eq!(call!(ge_si16(16514, 4)), true);
-    assert_eq!(call!(ge_si16(16514, 10486)), true);
-    assert_eq!(call!(ge_si16(16514, 16514)), true);
-    assert_eq!(call!(ge_si16(32766, -32768)), true);
-    assert_eq!(call!(ge_si16(32766, -32767)), true);
-    assert_eq!(call!(ge_si16(32766, -32547)), true);
-    assert_eq!(call!(ge_si16(32766, 0)), true);
-    assert_eq!(call!(ge_si16(32766, 1)), true);
-    assert_eq!(call!(ge_si16(32766, 2)), true);
-    assert_eq!(call!(ge_si16(32766, 3)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_106() {
-    assert_eq!(call!(ge_si16(32766, 4)), true);
-    assert_eq!(call!(ge_si16(32766, 10486)), true);
-    assert_eq!(call!(ge_si16(32766, 16514)), true);
-    assert_eq!(call!(ge_si16(32766, 32766)), true);
-    assert_eq!(call!(ge_si16(32767, -32768)), true);
-    assert_eq!(call!(ge_si16(32767, -32767)), true);
-    assert_eq!(call!(ge_si16(32767, -32547)), true);
-    assert_eq!(call!(ge_si16(32767, 0)), true);
-    assert_eq!(call!(ge_si16(32767, 1)), true);
-    assert_eq!(call!(ge_si16(32767, 2)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_107() {
-    assert_eq!(call!(ge_si16(32767, 3)), true);
-    assert_eq!(call!(ge_si16(32767, 4)), true);
-    assert_eq!(call!(ge_si16(32767, 10486)), true);
-    assert_eq!(call!(ge_si16(32767, 16514)), true);
-    assert_eq!(call!(ge_si16(32767, 32766)), true);
-    assert_eq!(call!(ge_si16(32767, 32767)), true);
-    assert_eq!(call!(ge_si32(-2147483648, -2147483647)), false);
-    assert_eq!(call!(ge_si32(-2147483648, -1713183800)), false);
-    assert_eq!(call!(ge_si32(-2147483648, -1252582164)), false);
-    assert_eq!(call!(ge_si32(-2147483648, -1035405763)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_108() {
-    assert_eq!(call!(ge_si32(-2147483648, 0)), false);
-    assert_eq!(call!(ge_si32(-2147483648, 1)), false);
-    assert_eq!(call!(ge_si32(-2147483648, 2)), false);
-    assert_eq!(call!(ge_si32(-2147483648, 3)), false);
-    assert_eq!(call!(ge_si32(-2147483648, 4)), false);
-    assert_eq!(call!(ge_si32(-2147483648, 2147483646)), false);
-    assert_eq!(call!(ge_si32(-2147483648, 2147483647)), false);
-    assert_eq!(call!(ge_si32(-2147483647, -1713183800)), false);
-    assert_eq!(call!(ge_si32(-2147483647, -1252582164)), false);
-    assert_eq!(call!(ge_si32(-2147483647, -1035405763)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_109() {
-    assert_eq!(call!(ge_si32(-2147483647, 0)), false);
-    assert_eq!(call!(ge_si32(-2147483647, 1)), false);
-    assert_eq!(call!(ge_si32(-2147483647, 2)), false);
-    assert_eq!(call!(ge_si32(-2147483647, 3)), false);
-    assert_eq!(call!(ge_si32(-2147483647, 4)), false);
-    assert_eq!(call!(ge_si32(-2147483647, 2147483646)), false);
-    assert_eq!(call!(ge_si32(-2147483647, 2147483647)), false);
-    assert_eq!(call!(ge_si32(-1713183800, -1252582164)), false);
-    assert_eq!(call!(ge_si32(-1713183800, -1035405763)), false);
-    assert_eq!(call!(ge_si32(-1713183800, 0)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_110() {
-    assert_eq!(call!(ge_si32(-1713183800, 1)), false);
-    assert_eq!(call!(ge_si32(-1713183800, 2)), false);
-    assert_eq!(call!(ge_si32(-1713183800, 3)), false);
-    assert_eq!(call!(ge_si32(-1713183800, 4)), false);
-    assert_eq!(call!(ge_si32(-1713183800, 2147483646)), false);
-    assert_eq!(call!(ge_si32(-1713183800, 2147483647)), false);
-    assert_eq!(call!(ge_si32(-1252582164, -1035405763)), false);
-    assert_eq!(call!(ge_si32(-1252582164, 0)), false);
-    assert_eq!(call!(ge_si32(-1252582164, 1)), false);
-    assert_eq!(call!(ge_si32(-1252582164, 2)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_111() {
-    assert_eq!(call!(ge_si32(-1252582164, 3)), false);
-    assert_eq!(call!(ge_si32(-1252582164, 4)), false);
-    assert_eq!(call!(ge_si32(-1252582164, 2147483646)), false);
-    assert_eq!(call!(ge_si32(-1252582164, 2147483647)), false);
-    assert_eq!(call!(ge_si32(-1035405763, 0)), false);
-    assert_eq!(call!(ge_si32(-1035405763, 1)), false);
-    assert_eq!(call!(ge_si32(-1035405763, 2)), false);
-    assert_eq!(call!(ge_si32(-1035405763, 3)), false);
-    assert_eq!(call!(ge_si32(-1035405763, 4)), false);
-    assert_eq!(call!(ge_si32(-1035405763, 2147483646)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_112() {
-    assert_eq!(call!(ge_si32(-1035405763, 2147483647)), false);
-    assert_eq!(call!(ge_si32(0, 1)), false);
-    assert_eq!(call!(ge_si32(0, 2)), false);
-    assert_eq!(call!(ge_si32(0, 3)), false);
-    assert_eq!(call!(ge_si32(0, 4)), false);
-    assert_eq!(call!(ge_si32(0, 2147483646)), false);
-    assert_eq!(call!(ge_si32(0, 2147483647)), false);
-    assert_eq!(call!(ge_si32(1, 2)), false);
-    assert_eq!(call!(ge_si32(1, 3)), false);
-    assert_eq!(call!(ge_si32(1, 4)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_113() {
-    assert_eq!(call!(ge_si32(1, 2147483646)), false);
-    assert_eq!(call!(ge_si32(1, 2147483647)), false);
-    assert_eq!(call!(ge_si32(2, 3)), false);
-    assert_eq!(call!(ge_si32(2, 4)), false);
-    assert_eq!(call!(ge_si32(2, 2147483646)), false);
-    assert_eq!(call!(ge_si32(2, 2147483647)), false);
-    assert_eq!(call!(ge_si32(3, 4)), false);
-    assert_eq!(call!(ge_si32(3, 2147483646)), false);
-    assert_eq!(call!(ge_si32(3, 2147483647)), false);
-    assert_eq!(call!(ge_si32(4, 2147483646)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_114() {
-    assert_eq!(call!(ge_si32(4, 2147483647)), false);
-    assert_eq!(call!(ge_si32(2147483646, 2147483647)), false);
-    assert_eq!(call!(ge_si32(-2147483648, -2147483648)), true);
-    assert_eq!(call!(ge_si32(-2147483647, -2147483648)), true);
-    assert_eq!(call!(ge_si32(-2147483647, -2147483647)), true);
-    assert_eq!(call!(ge_si32(-1713183800, -2147483648)), true);
-    assert_eq!(call!(ge_si32(-1713183800, -2147483647)), true);
-    assert_eq!(call!(ge_si32(-1713183800, -1713183800)), true);
-    assert_eq!(call!(ge_si32(-1252582164, -2147483648)), true);
-    assert_eq!(call!(ge_si32(-1252582164, -2147483647)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_115() {
-    assert_eq!(call!(ge_si32(-1252582164, -1713183800)), true);
-    assert_eq!(call!(ge_si32(-1252582164, -1252582164)), true);
-    assert_eq!(call!(ge_si32(-1035405763, -2147483648)), true);
-    assert_eq!(call!(ge_si32(-1035405763, -2147483647)), true);
-    assert_eq!(call!(ge_si32(-1035405763, -1713183800)), true);
-    assert_eq!(call!(ge_si32(-1035405763, -1252582164)), true);
-    assert_eq!(call!(ge_si32(-1035405763, -1035405763)), true);
-    assert_eq!(call!(ge_si32(0, -2147483648)), true);
-    assert_eq!(call!(ge_si32(0, -2147483647)), true);
-    assert_eq!(call!(ge_si32(0, -1713183800)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_116() {
-    assert_eq!(call!(ge_si32(0, -1252582164)), true);
-    assert_eq!(call!(ge_si32(0, -1035405763)), true);
-    assert_eq!(call!(ge_si32(0, 0)), true);
-    assert_eq!(call!(ge_si32(1, -2147483648)), true);
-    assert_eq!(call!(ge_si32(1, -2147483647)), true);
-    assert_eq!(call!(ge_si32(1, -1713183800)), true);
-    assert_eq!(call!(ge_si32(1, -1252582164)), true);
-    assert_eq!(call!(ge_si32(1, -1035405763)), true);
-    assert_eq!(call!(ge_si32(1, 0)), true);
-    assert_eq!(call!(ge_si32(1, 1)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_117() {
-    assert_eq!(call!(ge_si32(2, -2147483648)), true);
-    assert_eq!(call!(ge_si32(2, -2147483647)), true);
-    assert_eq!(call!(ge_si32(2, -1713183800)), true);
-    assert_eq!(call!(ge_si32(2, -1252582164)), true);
-    assert_eq!(call!(ge_si32(2, -1035405763)), true);
-    assert_eq!(call!(ge_si32(2, 0)), true);
-    assert_eq!(call!(ge_si32(2, 1)), true);
-    assert_eq!(call!(ge_si32(2, 2)), true);
-    assert_eq!(call!(ge_si32(3, -2147483648)), true);
-    assert_eq!(call!(ge_si32(3, -2147483647)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_118() {
-    assert_eq!(call!(ge_si32(3, -1713183800)), true);
-    assert_eq!(call!(ge_si32(3, -1252582164)), true);
-    assert_eq!(call!(ge_si32(3, -1035405763)), true);
-    assert_eq!(call!(ge_si32(3, 0)), true);
-    assert_eq!(call!(ge_si32(3, 1)), true);
-    assert_eq!(call!(ge_si32(3, 2)), true);
-    assert_eq!(call!(ge_si32(3, 3)), true);
-    assert_eq!(call!(ge_si32(4, -2147483648)), true);
-    assert_eq!(call!(ge_si32(4, -2147483647)), true);
-    assert_eq!(call!(ge_si32(4, -1713183800)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_119() {
-    assert_eq!(call!(ge_si32(4, -1252582164)), true);
-    assert_eq!(call!(ge_si32(4, -1035405763)), true);
-    assert_eq!(call!(ge_si32(4, 0)), true);
-    assert_eq!(call!(ge_si32(4, 1)), true);
-    assert_eq!(call!(ge_si32(4, 2)), true);
-    assert_eq!(call!(ge_si32(4, 3)), true);
-    assert_eq!(call!(ge_si32(4, 4)), true);
-    assert_eq!(call!(ge_si32(2147483646, -2147483648)), true);
-    assert_eq!(call!(ge_si32(2147483646, -2147483647)), true);
-    assert_eq!(call!(ge_si32(2147483646, -1713183800)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_120() {
-    assert_eq!(call!(ge_si32(2147483646, -1252582164)), true);
-    assert_eq!(call!(ge_si32(2147483646, -1035405763)), true);
-    assert_eq!(call!(ge_si32(2147483646, 0)), true);
-    assert_eq!(call!(ge_si32(2147483646, 1)), true);
-    assert_eq!(call!(ge_si32(2147483646, 2)), true);
-    assert_eq!(call!(ge_si32(2147483646, 3)), true);
-    assert_eq!(call!(ge_si32(2147483646, 4)), true);
-    assert_eq!(call!(ge_si32(2147483646, 2147483646)), true);
-    assert_eq!(call!(ge_si32(2147483647, -2147483648)), true);
-    assert_eq!(call!(ge_si32(2147483647, -2147483647)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_121() {
-    assert_eq!(call!(ge_si32(2147483647, -1713183800)), true);
-    assert_eq!(call!(ge_si32(2147483647, -1252582164)), true);
-    assert_eq!(call!(ge_si32(2147483647, -1035405763)), true);
-    assert_eq!(call!(ge_si32(2147483647, 0)), true);
-    assert_eq!(call!(ge_si32(2147483647, 1)), true);
-    assert_eq!(call!(ge_si32(2147483647, 2)), true);
-    assert_eq!(call!(ge_si32(2147483647, 3)), true);
-    assert_eq!(call!(ge_si32(2147483647, 4)), true);
-    assert_eq!(call!(ge_si32(2147483647, 2147483646)), true);
-    assert_eq!(call!(ge_si32(2147483647, 2147483647)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_122() {
-    assert_eq!(call!(ge_si64(-9223372036854775808, -9223372036854775807)), false);
-    assert_eq!(call!(ge_si64(-9223372036854775808, -1741927215160008704)), false);
-    assert_eq!(call!(ge_si64(-9223372036854775808, -1328271339354574848)), false);
-    assert_eq!(call!(ge_si64(-9223372036854775808, 0)), false);
-    assert_eq!(call!(ge_si64(-9223372036854775808, 1)), false);
-    assert_eq!(call!(ge_si64(-9223372036854775808, 2)), false);
-    assert_eq!(call!(ge_si64(-9223372036854775808, 3)), false);
-    assert_eq!(call!(ge_si64(-9223372036854775808, 4)), false);
-    assert_eq!(call!(ge_si64(-9223372036854775808, 5577148965131116544)), false);
-    assert_eq!(call!(ge_si64(-9223372036854775808, 9223372036854775806)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_123() {
-    assert_eq!(call!(ge_si64(-9223372036854775808, 9223372036854775807)), false);
-    assert_eq!(call!(ge_si64(-9223372036854775807, -1741927215160008704)), false);
-    assert_eq!(call!(ge_si64(-9223372036854775807, -1328271339354574848)), false);
-    assert_eq!(call!(ge_si64(-9223372036854775807, 0)), false);
-    assert_eq!(call!(ge_si64(-9223372036854775807, 1)), false);
-    assert_eq!(call!(ge_si64(-9223372036854775807, 2)), false);
-    assert_eq!(call!(ge_si64(-9223372036854775807, 3)), false);
-    assert_eq!(call!(ge_si64(-9223372036854775807, 4)), false);
-    assert_eq!(call!(ge_si64(-9223372036854775807, 5577148965131116544)), false);
-    assert_eq!(call!(ge_si64(-9223372036854775807, 9223372036854775806)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_124() {
-    assert_eq!(call!(ge_si64(-9223372036854775807, 9223372036854775807)), false);
-    assert_eq!(call!(ge_si64(-1741927215160008704, -1328271339354574848)), false);
-    assert_eq!(call!(ge_si64(-1741927215160008704, 0)), false);
-    assert_eq!(call!(ge_si64(-1741927215160008704, 1)), false);
-    assert_eq!(call!(ge_si64(-1741927215160008704, 2)), false);
-    assert_eq!(call!(ge_si64(-1741927215160008704, 3)), false);
-    assert_eq!(call!(ge_si64(-1741927215160008704, 4)), false);
-    assert_eq!(call!(ge_si64(-1741927215160008704, 5577148965131116544)), false);
-    assert_eq!(call!(ge_si64(-1741927215160008704, 9223372036854775806)), false);
-    assert_eq!(call!(ge_si64(-1741927215160008704, 9223372036854775807)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_125() {
-    assert_eq!(call!(ge_si64(-1328271339354574848, 0)), false);
-    assert_eq!(call!(ge_si64(-1328271339354574848, 1)), false);
-    assert_eq!(call!(ge_si64(-1328271339354574848, 2)), false);
-    assert_eq!(call!(ge_si64(-1328271339354574848, 3)), false);
-    assert_eq!(call!(ge_si64(-1328271339354574848, 4)), false);
-    assert_eq!(call!(ge_si64(-1328271339354574848, 5577148965131116544)), false);
-    assert_eq!(call!(ge_si64(-1328271339354574848, 9223372036854775806)), false);
-    assert_eq!(call!(ge_si64(-1328271339354574848, 9223372036854775807)), false);
-    assert_eq!(call!(ge_si64(0, 1)), false);
-    assert_eq!(call!(ge_si64(0, 2)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_126() {
-    assert_eq!(call!(ge_si64(0, 3)), false);
-    assert_eq!(call!(ge_si64(0, 4)), false);
-    assert_eq!(call!(ge_si64(0, 5577148965131116544)), false);
-    assert_eq!(call!(ge_si64(0, 9223372036854775806)), false);
-    assert_eq!(call!(ge_si64(0, 9223372036854775807)), false);
-    assert_eq!(call!(ge_si64(1, 2)), false);
-    assert_eq!(call!(ge_si64(1, 3)), false);
-    assert_eq!(call!(ge_si64(1, 4)), false);
-    assert_eq!(call!(ge_si64(1, 5577148965131116544)), false);
-    assert_eq!(call!(ge_si64(1, 9223372036854775806)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_127() {
-    assert_eq!(call!(ge_si64(1, 9223372036854775807)), false);
-    assert_eq!(call!(ge_si64(2, 3)), false);
-    assert_eq!(call!(ge_si64(2, 4)), false);
-    assert_eq!(call!(ge_si64(2, 5577148965131116544)), false);
-    assert_eq!(call!(ge_si64(2, 9223372036854775806)), false);
-    assert_eq!(call!(ge_si64(2, 9223372036854775807)), false);
-    assert_eq!(call!(ge_si64(3, 4)), false);
-    assert_eq!(call!(ge_si64(3, 5577148965131116544)), false);
-    assert_eq!(call!(ge_si64(3, 9223372036854775806)), false);
-    assert_eq!(call!(ge_si64(3, 9223372036854775807)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_128() {
-    assert_eq!(call!(ge_si64(4, 5577148965131116544)), false);
-    assert_eq!(call!(ge_si64(4, 9223372036854775806)), false);
-    assert_eq!(call!(ge_si64(4, 9223372036854775807)), false);
-    assert_eq!(call!(ge_si64(5577148965131116544, 9223372036854775806)), false);
-    assert_eq!(call!(ge_si64(5577148965131116544, 9223372036854775807)), false);
-    assert_eq!(call!(ge_si64(9223372036854775806, 9223372036854775807)), false);
-    assert_eq!(call!(ge_si64(-9223372036854775808, -9223372036854775808)), true);
-    assert_eq!(call!(ge_si64(-9223372036854775807, -9223372036854775808)), true);
-    assert_eq!(call!(ge_si64(-9223372036854775807, -9223372036854775807)), true);
-    assert_eq!(call!(ge_si64(-1741927215160008704, -9223372036854775808)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_129() {
-    assert_eq!(call!(ge_si64(-1741927215160008704, -9223372036854775807)), true);
-    assert_eq!(call!(ge_si64(-1741927215160008704, -1741927215160008704)), true);
-    assert_eq!(call!(ge_si64(-1328271339354574848, -9223372036854775808)), true);
-    assert_eq!(call!(ge_si64(-1328271339354574848, -9223372036854775807)), true);
-    assert_eq!(call!(ge_si64(-1328271339354574848, -1741927215160008704)), true);
-    assert_eq!(call!(ge_si64(-1328271339354574848, -1328271339354574848)), true);
-    assert_eq!(call!(ge_si64(0, -9223372036854775808)), true);
-    assert_eq!(call!(ge_si64(0, -9223372036854775807)), true);
-    assert_eq!(call!(ge_si64(0, -1741927215160008704)), true);
-    assert_eq!(call!(ge_si64(0, -1328271339354574848)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_130() {
-    assert_eq!(call!(ge_si64(0, 0)), true);
-    assert_eq!(call!(ge_si64(1, -9223372036854775808)), true);
-    assert_eq!(call!(ge_si64(1, -9223372036854775807)), true);
-    assert_eq!(call!(ge_si64(1, -1741927215160008704)), true);
-    assert_eq!(call!(ge_si64(1, -1328271339354574848)), true);
-    assert_eq!(call!(ge_si64(1, 0)), true);
-    assert_eq!(call!(ge_si64(1, 1)), true);
-    assert_eq!(call!(ge_si64(2, -9223372036854775808)), true);
-    assert_eq!(call!(ge_si64(2, -9223372036854775807)), true);
-    assert_eq!(call!(ge_si64(2, -1741927215160008704)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_131() {
-    assert_eq!(call!(ge_si64(2, -1328271339354574848)), true);
-    assert_eq!(call!(ge_si64(2, 0)), true);
-    assert_eq!(call!(ge_si64(2, 1)), true);
-    assert_eq!(call!(ge_si64(2, 2)), true);
-    assert_eq!(call!(ge_si64(3, -9223372036854775808)), true);
-    assert_eq!(call!(ge_si64(3, -9223372036854775807)), true);
-    assert_eq!(call!(ge_si64(3, -1741927215160008704)), true);
-    assert_eq!(call!(ge_si64(3, -1328271339354574848)), true);
-    assert_eq!(call!(ge_si64(3, 0)), true);
-    assert_eq!(call!(ge_si64(3, 1)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_132() {
-    assert_eq!(call!(ge_si64(3, 2)), true);
-    assert_eq!(call!(ge_si64(3, 3)), true);
-    assert_eq!(call!(ge_si64(4, -9223372036854775808)), true);
-    assert_eq!(call!(ge_si64(4, -9223372036854775807)), true);
-    assert_eq!(call!(ge_si64(4, -1741927215160008704)), true);
-    assert_eq!(call!(ge_si64(4, -1328271339354574848)), true);
-    assert_eq!(call!(ge_si64(4, 0)), true);
-    assert_eq!(call!(ge_si64(4, 1)), true);
-    assert_eq!(call!(ge_si64(4, 2)), true);
-    assert_eq!(call!(ge_si64(4, 3)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_133() {
-    assert_eq!(call!(ge_si64(4, 4)), true);
-    assert_eq!(call!(ge_si64(5577148965131116544, -9223372036854775808)), true);
-    assert_eq!(call!(ge_si64(5577148965131116544, -9223372036854775807)), true);
-    assert_eq!(call!(ge_si64(5577148965131116544, -1741927215160008704)), true);
-    assert_eq!(call!(ge_si64(5577148965131116544, -1328271339354574848)), true);
-    assert_eq!(call!(ge_si64(5577148965131116544, 0)), true);
-    assert_eq!(call!(ge_si64(5577148965131116544, 1)), true);
-    assert_eq!(call!(ge_si64(5577148965131116544, 2)), true);
-    assert_eq!(call!(ge_si64(5577148965131116544, 3)), true);
-    assert_eq!(call!(ge_si64(5577148965131116544, 4)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_134() {
-    assert_eq!(call!(ge_si64(5577148965131116544, 5577148965131116544)), true);
-    assert_eq!(call!(ge_si64(9223372036854775806, -9223372036854775808)), true);
-    assert_eq!(call!(ge_si64(9223372036854775806, -9223372036854775807)), true);
-    assert_eq!(call!(ge_si64(9223372036854775806, -1741927215160008704)), true);
-    assert_eq!(call!(ge_si64(9223372036854775806, -1328271339354574848)), true);
-    assert_eq!(call!(ge_si64(9223372036854775806, 0)), true);
-    assert_eq!(call!(ge_si64(9223372036854775806, 1)), true);
-    assert_eq!(call!(ge_si64(9223372036854775806, 2)), true);
-    assert_eq!(call!(ge_si64(9223372036854775806, 3)), true);
-    assert_eq!(call!(ge_si64(9223372036854775806, 4)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_135() {
-    assert_eq!(call!(ge_si64(9223372036854775806, 5577148965131116544)), true);
-    assert_eq!(call!(ge_si64(9223372036854775806, 9223372036854775806)), true);
-    assert_eq!(call!(ge_si64(9223372036854775807, -9223372036854775808)), true);
-    assert_eq!(call!(ge_si64(9223372036854775807, -9223372036854775807)), true);
-    assert_eq!(call!(ge_si64(9223372036854775807, -1741927215160008704)), true);
-    assert_eq!(call!(ge_si64(9223372036854775807, -1328271339354574848)), true);
-    assert_eq!(call!(ge_si64(9223372036854775807, 0)), true);
-    assert_eq!(call!(ge_si64(9223372036854775807, 1)), true);
-    assert_eq!(call!(ge_si64(9223372036854775807, 2)), true);
-    assert_eq!(call!(ge_si64(9223372036854775807, 3)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_136() {
-    assert_eq!(call!(ge_si64(9223372036854775807, 4)), true);
-    assert_eq!(call!(ge_si64(9223372036854775807, 5577148965131116544)), true);
-    assert_eq!(call!(ge_si64(9223372036854775807, 9223372036854775806)), true);
-    assert_eq!(call!(ge_si64(9223372036854775807, 9223372036854775807)), true);
-    assert_eq!(call!(ge_si8(-128, -127)), false);
-    assert_eq!(call!(ge_si8(-128, 0)), false);
-    assert_eq!(call!(ge_si8(-128, 1)), false);
-    assert_eq!(call!(ge_si8(-128, 2)), false);
-    assert_eq!(call!(ge_si8(-128, 3)), false);
-    assert_eq!(call!(ge_si8(-128, 4)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_137() {
-    assert_eq!(call!(ge_si8(-128, 16)), false);
-    assert_eq!(call!(ge_si8(-128, 126)), false);
-    assert_eq!(call!(ge_si8(-128, 127)), false);
-    assert_eq!(call!(ge_si8(-127, 0)), false);
-    assert_eq!(call!(ge_si8(-127, 1)), false);
-    assert_eq!(call!(ge_si8(-127, 2)), false);
-    assert_eq!(call!(ge_si8(-127, 3)), false);
-    assert_eq!(call!(ge_si8(-127, 4)), false);
-    assert_eq!(call!(ge_si8(-127, 16)), false);
-    assert_eq!(call!(ge_si8(-127, 126)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_138() {
-    assert_eq!(call!(ge_si8(-127, 127)), false);
-    assert_eq!(call!(ge_si8(0, 1)), false);
-    assert_eq!(call!(ge_si8(0, 2)), false);
-    assert_eq!(call!(ge_si8(0, 3)), false);
-    assert_eq!(call!(ge_si8(0, 4)), false);
-    assert_eq!(call!(ge_si8(0, 16)), false);
-    assert_eq!(call!(ge_si8(0, 126)), false);
-    assert_eq!(call!(ge_si8(0, 127)), false);
-    assert_eq!(call!(ge_si8(1, 2)), false);
-    assert_eq!(call!(ge_si8(1, 3)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_139() {
-    assert_eq!(call!(ge_si8(1, 4)), false);
-    assert_eq!(call!(ge_si8(1, 16)), false);
-    assert_eq!(call!(ge_si8(1, 126)), false);
-    assert_eq!(call!(ge_si8(1, 127)), false);
-    assert_eq!(call!(ge_si8(2, 3)), false);
-    assert_eq!(call!(ge_si8(2, 4)), false);
-    assert_eq!(call!(ge_si8(2, 16)), false);
-    assert_eq!(call!(ge_si8(2, 126)), false);
-    assert_eq!(call!(ge_si8(2, 127)), false);
-    assert_eq!(call!(ge_si8(3, 4)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_140() {
-    assert_eq!(call!(ge_si8(3, 16)), false);
-    assert_eq!(call!(ge_si8(3, 126)), false);
-    assert_eq!(call!(ge_si8(3, 127)), false);
-    assert_eq!(call!(ge_si8(4, 16)), false);
-    assert_eq!(call!(ge_si8(4, 126)), false);
-    assert_eq!(call!(ge_si8(4, 127)), false);
-    assert_eq!(call!(ge_si8(16, 126)), false);
-    assert_eq!(call!(ge_si8(16, 127)), false);
-    assert_eq!(call!(ge_si8(126, 127)), false);
-    assert_eq!(call!(ge_si8(-128, -128)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_141() {
-    assert_eq!(call!(ge_si8(-127, -128)), true);
-    assert_eq!(call!(ge_si8(-127, -127)), true);
-    assert_eq!(call!(ge_si8(0, -128)), true);
-    assert_eq!(call!(ge_si8(0, -127)), true);
-    assert_eq!(call!(ge_si8(0, 0)), true);
-    assert_eq!(call!(ge_si8(1, -128)), true);
-    assert_eq!(call!(ge_si8(1, -127)), true);
-    assert_eq!(call!(ge_si8(1, 0)), true);
-    assert_eq!(call!(ge_si8(1, 1)), true);
-    assert_eq!(call!(ge_si8(2, -128)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_142() {
-    assert_eq!(call!(ge_si8(2, -127)), true);
-    assert_eq!(call!(ge_si8(2, 0)), true);
-    assert_eq!(call!(ge_si8(2, 1)), true);
-    assert_eq!(call!(ge_si8(2, 2)), true);
-    assert_eq!(call!(ge_si8(3, -128)), true);
-    assert_eq!(call!(ge_si8(3, -127)), true);
-    assert_eq!(call!(ge_si8(3, 0)), true);
-    assert_eq!(call!(ge_si8(3, 1)), true);
-    assert_eq!(call!(ge_si8(3, 2)), true);
-    assert_eq!(call!(ge_si8(3, 3)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_143() {
-    assert_eq!(call!(ge_si8(4, -128)), true);
-    assert_eq!(call!(ge_si8(4, -127)), true);
-    assert_eq!(call!(ge_si8(4, 0)), true);
-    assert_eq!(call!(ge_si8(4, 1)), true);
-    assert_eq!(call!(ge_si8(4, 2)), true);
-    assert_eq!(call!(ge_si8(4, 3)), true);
-    assert_eq!(call!(ge_si8(4, 4)), true);
-    assert_eq!(call!(ge_si8(16, -128)), true);
-    assert_eq!(call!(ge_si8(16, -127)), true);
-    assert_eq!(call!(ge_si8(16, 0)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_144() {
-    assert_eq!(call!(ge_si8(16, 1)), true);
-    assert_eq!(call!(ge_si8(16, 2)), true);
-    assert_eq!(call!(ge_si8(16, 3)), true);
-    assert_eq!(call!(ge_si8(16, 4)), true);
-    assert_eq!(call!(ge_si8(16, 16)), true);
-    assert_eq!(call!(ge_si8(126, -128)), true);
-    assert_eq!(call!(ge_si8(126, -127)), true);
-    assert_eq!(call!(ge_si8(126, 0)), true);
-    assert_eq!(call!(ge_si8(126, 1)), true);
-    assert_eq!(call!(ge_si8(126, 2)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_145() {
-    assert_eq!(call!(ge_si8(126, 3)), true);
-    assert_eq!(call!(ge_si8(126, 4)), true);
-    assert_eq!(call!(ge_si8(126, 16)), true);
-    assert_eq!(call!(ge_si8(126, 126)), true);
-    assert_eq!(call!(ge_si8(127, -128)), true);
-    assert_eq!(call!(ge_si8(127, -127)), true);
-    assert_eq!(call!(ge_si8(127, 0)), true);
-    assert_eq!(call!(ge_si8(127, 1)), true);
-    assert_eq!(call!(ge_si8(127, 2)), true);
-    assert_eq!(call!(ge_si8(127, 3)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_146() {
-    assert_eq!(call!(ge_si8(127, 4)), true);
-    assert_eq!(call!(ge_si8(127, 16)), true);
-    assert_eq!(call!(ge_si8(127, 126)), true);
-    assert_eq!(call!(ge_si8(127, 127)), true);
-    assert_eq!(call!(ge_ui16(0, 1)), false);
-    assert_eq!(call!(ge_ui16(0, 2)), false);
-    assert_eq!(call!(ge_ui16(0, 3)), false);
-    assert_eq!(call!(ge_ui16(0, 4)), false);
-    assert_eq!(call!(ge_ui16(0, 1717)), false);
-    assert_eq!(call!(ge_ui16(0, 17988)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_147() {
-    assert_eq!(call!(ge_ui16(0, 65096)), false);
-    assert_eq!(call!(ge_ui16(0, 65534)), false);
-    assert_eq!(call!(ge_ui16(0, 65535)), false);
-    assert_eq!(call!(ge_ui16(1, 2)), false);
-    assert_eq!(call!(ge_ui16(1, 3)), false);
-    assert_eq!(call!(ge_ui16(1, 4)), false);
-    assert_eq!(call!(ge_ui16(1, 1717)), false);
-    assert_eq!(call!(ge_ui16(1, 17988)), false);
-    assert_eq!(call!(ge_ui16(1, 65096)), false);
-    assert_eq!(call!(ge_ui16(1, 65534)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_148() {
-    assert_eq!(call!(ge_ui16(1, 65535)), false);
-    assert_eq!(call!(ge_ui16(2, 3)), false);
-    assert_eq!(call!(ge_ui16(2, 4)), false);
-    assert_eq!(call!(ge_ui16(2, 1717)), false);
-    assert_eq!(call!(ge_ui16(2, 17988)), false);
-    assert_eq!(call!(ge_ui16(2, 65096)), false);
-    assert_eq!(call!(ge_ui16(2, 65534)), false);
-    assert_eq!(call!(ge_ui16(2, 65535)), false);
-    assert_eq!(call!(ge_ui16(3, 4)), false);
-    assert_eq!(call!(ge_ui16(3, 1717)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_149() {
-    assert_eq!(call!(ge_ui16(3, 17988)), false);
-    assert_eq!(call!(ge_ui16(3, 65096)), false);
-    assert_eq!(call!(ge_ui16(3, 65534)), false);
-    assert_eq!(call!(ge_ui16(3, 65535)), false);
-    assert_eq!(call!(ge_ui16(4, 1717)), false);
-    assert_eq!(call!(ge_ui16(4, 17988)), false);
-    assert_eq!(call!(ge_ui16(4, 65096)), false);
-    assert_eq!(call!(ge_ui16(4, 65534)), false);
-    assert_eq!(call!(ge_ui16(4, 65535)), false);
-    assert_eq!(call!(ge_ui16(1717, 17988)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_150() {
-    assert_eq!(call!(ge_ui16(1717, 65096)), false);
-    assert_eq!(call!(ge_ui16(1717, 65534)), false);
-    assert_eq!(call!(ge_ui16(1717, 65535)), false);
-    assert_eq!(call!(ge_ui16(17988, 65096)), false);
-    assert_eq!(call!(ge_ui16(17988, 65534)), false);
-    assert_eq!(call!(ge_ui16(17988, 65535)), false);
-    assert_eq!(call!(ge_ui16(65096, 65534)), false);
-    assert_eq!(call!(ge_ui16(65096, 65535)), false);
-    assert_eq!(call!(ge_ui16(65534, 65535)), false);
-    assert_eq!(call!(ge_ui16(0, 0)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_151() {
-    assert_eq!(call!(ge_ui16(1, 0)), true);
-    assert_eq!(call!(ge_ui16(1, 1)), true);
-    assert_eq!(call!(ge_ui16(2, 0)), true);
-    assert_eq!(call!(ge_ui16(2, 1)), true);
-    assert_eq!(call!(ge_ui16(2, 2)), true);
-    assert_eq!(call!(ge_ui16(3, 0)), true);
-    assert_eq!(call!(ge_ui16(3, 1)), true);
-    assert_eq!(call!(ge_ui16(3, 2)), true);
-    assert_eq!(call!(ge_ui16(3, 3)), true);
-    assert_eq!(call!(ge_ui16(4, 0)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_152() {
-    assert_eq!(call!(ge_ui16(4, 1)), true);
-    assert_eq!(call!(ge_ui16(4, 2)), true);
-    assert_eq!(call!(ge_ui16(4, 3)), true);
-    assert_eq!(call!(ge_ui16(4, 4)), true);
-    assert_eq!(call!(ge_ui16(1717, 0)), true);
-    assert_eq!(call!(ge_ui16(1717, 1)), true);
-    assert_eq!(call!(ge_ui16(1717, 2)), true);
-    assert_eq!(call!(ge_ui16(1717, 3)), true);
-    assert_eq!(call!(ge_ui16(1717, 4)), true);
-    assert_eq!(call!(ge_ui16(1717, 1717)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_153() {
-    assert_eq!(call!(ge_ui16(17988, 0)), true);
-    assert_eq!(call!(ge_ui16(17988, 1)), true);
-    assert_eq!(call!(ge_ui16(17988, 2)), true);
-    assert_eq!(call!(ge_ui16(17988, 3)), true);
-    assert_eq!(call!(ge_ui16(17988, 4)), true);
-    assert_eq!(call!(ge_ui16(17988, 1717)), true);
-    assert_eq!(call!(ge_ui16(17988, 17988)), true);
-    assert_eq!(call!(ge_ui16(65096, 0)), true);
-    assert_eq!(call!(ge_ui16(65096, 1)), true);
-    assert_eq!(call!(ge_ui16(65096, 2)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_154() {
-    assert_eq!(call!(ge_ui16(65096, 3)), true);
-    assert_eq!(call!(ge_ui16(65096, 4)), true);
-    assert_eq!(call!(ge_ui16(65096, 1717)), true);
-    assert_eq!(call!(ge_ui16(65096, 17988)), true);
-    assert_eq!(call!(ge_ui16(65096, 65096)), true);
-    assert_eq!(call!(ge_ui16(65534, 0)), true);
-    assert_eq!(call!(ge_ui16(65534, 1)), true);
-    assert_eq!(call!(ge_ui16(65534, 2)), true);
-    assert_eq!(call!(ge_ui16(65534, 3)), true);
-    assert_eq!(call!(ge_ui16(65534, 4)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_155() {
-    assert_eq!(call!(ge_ui16(65534, 1717)), true);
-    assert_eq!(call!(ge_ui16(65534, 17988)), true);
-    assert_eq!(call!(ge_ui16(65534, 65096)), true);
-    assert_eq!(call!(ge_ui16(65534, 65534)), true);
-    assert_eq!(call!(ge_ui16(65535, 0)), true);
-    assert_eq!(call!(ge_ui16(65535, 1)), true);
-    assert_eq!(call!(ge_ui16(65535, 2)), true);
-    assert_eq!(call!(ge_ui16(65535, 3)), true);
-    assert_eq!(call!(ge_ui16(65535, 4)), true);
-    assert_eq!(call!(ge_ui16(65535, 1717)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_156() {
-    assert_eq!(call!(ge_ui16(65535, 17988)), true);
-    assert_eq!(call!(ge_ui16(65535, 65096)), true);
-    assert_eq!(call!(ge_ui16(65535, 65534)), true);
-    assert_eq!(call!(ge_ui16(65535, 65535)), true);
-    assert_eq!(call!(ge_ui32(0, 1)), false);
-    assert_eq!(call!(ge_ui32(0, 2)), false);
-    assert_eq!(call!(ge_ui32(0, 3)), false);
-    assert_eq!(call!(ge_ui32(0, 4)), false);
-    assert_eq!(call!(ge_ui32(0, 2119154652)), false);
-    assert_eq!(call!(ge_ui32(0, 3002788344)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_157() {
-    assert_eq!(call!(ge_ui32(0, 3482297128)), false);
-    assert_eq!(call!(ge_ui32(0, 4294967294)), false);
-    assert_eq!(call!(ge_ui32(0, 4294967295)), false);
-    assert_eq!(call!(ge_ui32(1, 2)), false);
-    assert_eq!(call!(ge_ui32(1, 3)), false);
-    assert_eq!(call!(ge_ui32(1, 4)), false);
-    assert_eq!(call!(ge_ui32(1, 2119154652)), false);
-    assert_eq!(call!(ge_ui32(1, 3002788344)), false);
-    assert_eq!(call!(ge_ui32(1, 3482297128)), false);
-    assert_eq!(call!(ge_ui32(1, 4294967294)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_158() {
-    assert_eq!(call!(ge_ui32(1, 4294967295)), false);
-    assert_eq!(call!(ge_ui32(2, 3)), false);
-    assert_eq!(call!(ge_ui32(2, 4)), false);
-    assert_eq!(call!(ge_ui32(2, 2119154652)), false);
-    assert_eq!(call!(ge_ui32(2, 3002788344)), false);
-    assert_eq!(call!(ge_ui32(2, 3482297128)), false);
-    assert_eq!(call!(ge_ui32(2, 4294967294)), false);
-    assert_eq!(call!(ge_ui32(2, 4294967295)), false);
-    assert_eq!(call!(ge_ui32(3, 4)), false);
-    assert_eq!(call!(ge_ui32(3, 2119154652)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_159() {
-    assert_eq!(call!(ge_ui32(3, 3002788344)), false);
-    assert_eq!(call!(ge_ui32(3, 3482297128)), false);
-    assert_eq!(call!(ge_ui32(3, 4294967294)), false);
-    assert_eq!(call!(ge_ui32(3, 4294967295)), false);
-    assert_eq!(call!(ge_ui32(4, 2119154652)), false);
-    assert_eq!(call!(ge_ui32(4, 3002788344)), false);
-    assert_eq!(call!(ge_ui32(4, 3482297128)), false);
-    assert_eq!(call!(ge_ui32(4, 4294967294)), false);
-    assert_eq!(call!(ge_ui32(4, 4294967295)), false);
-    assert_eq!(call!(ge_ui32(2119154652, 3002788344)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_160() {
-    assert_eq!(call!(ge_ui32(2119154652, 3482297128)), false);
-    assert_eq!(call!(ge_ui32(2119154652, 4294967294)), false);
-    assert_eq!(call!(ge_ui32(2119154652, 4294967295)), false);
-    assert_eq!(call!(ge_ui32(3002788344, 3482297128)), false);
-    assert_eq!(call!(ge_ui32(3002788344, 4294967294)), false);
-    assert_eq!(call!(ge_ui32(3002788344, 4294967295)), false);
-    assert_eq!(call!(ge_ui32(3482297128, 4294967294)), false);
-    assert_eq!(call!(ge_ui32(3482297128, 4294967295)), false);
-    assert_eq!(call!(ge_ui32(4294967294, 4294967295)), false);
-    assert_eq!(call!(ge_ui32(0, 0)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_161() {
-    assert_eq!(call!(ge_ui32(1, 0)), true);
-    assert_eq!(call!(ge_ui32(1, 1)), true);
-    assert_eq!(call!(ge_ui32(2, 0)), true);
-    assert_eq!(call!(ge_ui32(2, 1)), true);
-    assert_eq!(call!(ge_ui32(2, 2)), true);
-    assert_eq!(call!(ge_ui32(3, 0)), true);
-    assert_eq!(call!(ge_ui32(3, 1)), true);
-    assert_eq!(call!(ge_ui32(3, 2)), true);
-    assert_eq!(call!(ge_ui32(3, 3)), true);
-    assert_eq!(call!(ge_ui32(4, 0)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_162() {
-    assert_eq!(call!(ge_ui32(4, 1)), true);
-    assert_eq!(call!(ge_ui32(4, 2)), true);
-    assert_eq!(call!(ge_ui32(4, 3)), true);
-    assert_eq!(call!(ge_ui32(4, 4)), true);
-    assert_eq!(call!(ge_ui32(2119154652, 0)), true);
-    assert_eq!(call!(ge_ui32(2119154652, 1)), true);
-    assert_eq!(call!(ge_ui32(2119154652, 2)), true);
-    assert_eq!(call!(ge_ui32(2119154652, 3)), true);
-    assert_eq!(call!(ge_ui32(2119154652, 4)), true);
-    assert_eq!(call!(ge_ui32(2119154652, 2119154652)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_163() {
-    assert_eq!(call!(ge_ui32(3002788344, 0)), true);
-    assert_eq!(call!(ge_ui32(3002788344, 1)), true);
-    assert_eq!(call!(ge_ui32(3002788344, 2)), true);
-    assert_eq!(call!(ge_ui32(3002788344, 3)), true);
-    assert_eq!(call!(ge_ui32(3002788344, 4)), true);
-    assert_eq!(call!(ge_ui32(3002788344, 2119154652)), true);
-    assert_eq!(call!(ge_ui32(3002788344, 3002788344)), true);
-    assert_eq!(call!(ge_ui32(3482297128, 0)), true);
-    assert_eq!(call!(ge_ui32(3482297128, 1)), true);
-    assert_eq!(call!(ge_ui32(3482297128, 2)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_164() {
-    assert_eq!(call!(ge_ui32(3482297128, 3)), true);
-    assert_eq!(call!(ge_ui32(3482297128, 4)), true);
-    assert_eq!(call!(ge_ui32(3482297128, 2119154652)), true);
-    assert_eq!(call!(ge_ui32(3482297128, 3002788344)), true);
-    assert_eq!(call!(ge_ui32(3482297128, 3482297128)), true);
-    assert_eq!(call!(ge_ui32(4294967294, 0)), true);
-    assert_eq!(call!(ge_ui32(4294967294, 1)), true);
-    assert_eq!(call!(ge_ui32(4294967294, 2)), true);
-    assert_eq!(call!(ge_ui32(4294967294, 3)), true);
-    assert_eq!(call!(ge_ui32(4294967294, 4)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_165() {
-    assert_eq!(call!(ge_ui32(4294967294, 2119154652)), true);
-    assert_eq!(call!(ge_ui32(4294967294, 3002788344)), true);
-    assert_eq!(call!(ge_ui32(4294967294, 3482297128)), true);
-    assert_eq!(call!(ge_ui32(4294967294, 4294967294)), true);
-    assert_eq!(call!(ge_ui32(4294967295, 0)), true);
-    assert_eq!(call!(ge_ui32(4294967295, 1)), true);
-    assert_eq!(call!(ge_ui32(4294967295, 2)), true);
-    assert_eq!(call!(ge_ui32(4294967295, 3)), true);
-    assert_eq!(call!(ge_ui32(4294967295, 4)), true);
-    assert_eq!(call!(ge_ui32(4294967295, 2119154652)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_166() {
-    assert_eq!(call!(ge_ui32(4294967295, 3002788344)), true);
-    assert_eq!(call!(ge_ui32(4294967295, 3482297128)), true);
-    assert_eq!(call!(ge_ui32(4294967295, 4294967294)), true);
-    assert_eq!(call!(ge_ui32(4294967295, 4294967295)), true);
-    assert_eq!(call!(ge_ui64(0, 1)), false);
-    assert_eq!(call!(ge_ui64(0, 2)), false);
-    assert_eq!(call!(ge_ui64(0, 3)), false);
-    assert_eq!(call!(ge_ui64(0, 4)), false);
-    assert_eq!(call!(ge_ui64(0, 191084152064409600)), false);
-    assert_eq!(call!(ge_ui64(0, 11015955194427482112)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_167() {
-    assert_eq!(call!(ge_ui64(0, 16990600415051759616)), false);
-    assert_eq!(call!(ge_ui64(0, 18446744073709551614)), false);
-    assert_eq!(call!(ge_ui64(0, 18446744073709551615)), false);
-    assert_eq!(call!(ge_ui64(1, 2)), false);
-    assert_eq!(call!(ge_ui64(1, 3)), false);
-    assert_eq!(call!(ge_ui64(1, 4)), false);
-    assert_eq!(call!(ge_ui64(1, 191084152064409600)), false);
-    assert_eq!(call!(ge_ui64(1, 11015955194427482112)), false);
-    assert_eq!(call!(ge_ui64(1, 16990600415051759616)), false);
-    assert_eq!(call!(ge_ui64(1, 18446744073709551614)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_168() {
-    assert_eq!(call!(ge_ui64(1, 18446744073709551615)), false);
-    assert_eq!(call!(ge_ui64(2, 3)), false);
-    assert_eq!(call!(ge_ui64(2, 4)), false);
-    assert_eq!(call!(ge_ui64(2, 191084152064409600)), false);
-    assert_eq!(call!(ge_ui64(2, 11015955194427482112)), false);
-    assert_eq!(call!(ge_ui64(2, 16990600415051759616)), false);
-    assert_eq!(call!(ge_ui64(2, 18446744073709551614)), false);
-    assert_eq!(call!(ge_ui64(2, 18446744073709551615)), false);
-    assert_eq!(call!(ge_ui64(3, 4)), false);
-    assert_eq!(call!(ge_ui64(3, 191084152064409600)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_169() {
-    assert_eq!(call!(ge_ui64(3, 11015955194427482112)), false);
-    assert_eq!(call!(ge_ui64(3, 16990600415051759616)), false);
-    assert_eq!(call!(ge_ui64(3, 18446744073709551614)), false);
-    assert_eq!(call!(ge_ui64(3, 18446744073709551615)), false);
-    assert_eq!(call!(ge_ui64(4, 191084152064409600)), false);
-    assert_eq!(call!(ge_ui64(4, 11015955194427482112)), false);
-    assert_eq!(call!(ge_ui64(4, 16990600415051759616)), false);
-    assert_eq!(call!(ge_ui64(4, 18446744073709551614)), false);
-    assert_eq!(call!(ge_ui64(4, 18446744073709551615)), false);
-    assert_eq!(call!(ge_ui64(191084152064409600, 11015955194427482112)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_170() {
-    assert_eq!(call!(ge_ui64(191084152064409600, 16990600415051759616)), false);
-    assert_eq!(call!(ge_ui64(191084152064409600, 18446744073709551614)), false);
-    assert_eq!(call!(ge_ui64(191084152064409600, 18446744073709551615)), false);
-    assert_eq!(call!(ge_ui64(11015955194427482112, 16990600415051759616)), false);
-    assert_eq!(call!(ge_ui64(11015955194427482112, 18446744073709551614)), false);
-    assert_eq!(call!(ge_ui64(11015955194427482112, 18446744073709551615)), false);
-    assert_eq!(call!(ge_ui64(16990600415051759616, 18446744073709551614)), false);
-    assert_eq!(call!(ge_ui64(16990600415051759616, 18446744073709551615)), false);
-    assert_eq!(call!(ge_ui64(18446744073709551614, 18446744073709551615)), false);
-    assert_eq!(call!(ge_ui64(0, 0)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_171() {
-    assert_eq!(call!(ge_ui64(1, 0)), true);
-    assert_eq!(call!(ge_ui64(1, 1)), true);
-    assert_eq!(call!(ge_ui64(2, 0)), true);
-    assert_eq!(call!(ge_ui64(2, 1)), true);
-    assert_eq!(call!(ge_ui64(2, 2)), true);
-    assert_eq!(call!(ge_ui64(3, 0)), true);
-    assert_eq!(call!(ge_ui64(3, 1)), true);
-    assert_eq!(call!(ge_ui64(3, 2)), true);
-    assert_eq!(call!(ge_ui64(3, 3)), true);
-    assert_eq!(call!(ge_ui64(4, 0)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_172() {
-    assert_eq!(call!(ge_ui64(4, 1)), true);
-    assert_eq!(call!(ge_ui64(4, 2)), true);
-    assert_eq!(call!(ge_ui64(4, 3)), true);
-    assert_eq!(call!(ge_ui64(4, 4)), true);
-    assert_eq!(call!(ge_ui64(191084152064409600, 0)), true);
-    assert_eq!(call!(ge_ui64(191084152064409600, 1)), true);
-    assert_eq!(call!(ge_ui64(191084152064409600, 2)), true);
-    assert_eq!(call!(ge_ui64(191084152064409600, 3)), true);
-    assert_eq!(call!(ge_ui64(191084152064409600, 4)), true);
-    assert_eq!(call!(ge_ui64(191084152064409600, 191084152064409600)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_173() {
-    assert_eq!(call!(ge_ui64(11015955194427482112, 0)), true);
-    assert_eq!(call!(ge_ui64(11015955194427482112, 1)), true);
-    assert_eq!(call!(ge_ui64(11015955194427482112, 2)), true);
-    assert_eq!(call!(ge_ui64(11015955194427482112, 3)), true);
-    assert_eq!(call!(ge_ui64(11015955194427482112, 4)), true);
-    assert_eq!(call!(ge_ui64(11015955194427482112, 191084152064409600)), true);
-    assert_eq!(call!(ge_ui64(11015955194427482112, 11015955194427482112)), true);
-    assert_eq!(call!(ge_ui64(16990600415051759616, 0)), true);
-    assert_eq!(call!(ge_ui64(16990600415051759616, 1)), true);
-    assert_eq!(call!(ge_ui64(16990600415051759616, 2)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_174() {
-    assert_eq!(call!(ge_ui64(16990600415051759616, 3)), true);
-    assert_eq!(call!(ge_ui64(16990600415051759616, 4)), true);
-    assert_eq!(call!(ge_ui64(16990600415051759616, 191084152064409600)), true);
-    assert_eq!(call!(ge_ui64(16990600415051759616, 11015955194427482112)), true);
-    assert_eq!(call!(ge_ui64(16990600415051759616, 16990600415051759616)), true);
-    assert_eq!(call!(ge_ui64(18446744073709551614, 0)), true);
-    assert_eq!(call!(ge_ui64(18446744073709551614, 1)), true);
-    assert_eq!(call!(ge_ui64(18446744073709551614, 2)), true);
-    assert_eq!(call!(ge_ui64(18446744073709551614, 3)), true);
-    assert_eq!(call!(ge_ui64(18446744073709551614, 4)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_175() {
-    assert_eq!(call!(ge_ui64(18446744073709551614, 191084152064409600)), true);
-    assert_eq!(call!(ge_ui64(18446744073709551614, 11015955194427482112)), true);
-    assert_eq!(call!(ge_ui64(18446744073709551614, 16990600415051759616)), true);
-    assert_eq!(call!(ge_ui64(18446744073709551614, 18446744073709551614)), true);
-    assert_eq!(call!(ge_ui64(18446744073709551615, 0)), true);
-    assert_eq!(call!(ge_ui64(18446744073709551615, 1)), true);
-    assert_eq!(call!(ge_ui64(18446744073709551615, 2)), true);
-    assert_eq!(call!(ge_ui64(18446744073709551615, 3)), true);
-    assert_eq!(call!(ge_ui64(18446744073709551615, 4)), true);
-    assert_eq!(call!(ge_ui64(18446744073709551615, 191084152064409600)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_176() {
-    assert_eq!(call!(ge_ui64(18446744073709551615, 11015955194427482112)), true);
-    assert_eq!(call!(ge_ui64(18446744073709551615, 16990600415051759616)), true);
-    assert_eq!(call!(ge_ui64(18446744073709551615, 18446744073709551614)), true);
-    assert_eq!(call!(ge_ui64(18446744073709551615, 18446744073709551615)), true);
-    assert_eq!(call!(ge_ui8(0, 1)), false);
-    assert_eq!(call!(ge_ui8(0, 2)), false);
-    assert_eq!(call!(ge_ui8(0, 3)), false);
-    assert_eq!(call!(ge_ui8(0, 4)), false);
-    assert_eq!(call!(ge_ui8(0, 72)), false);
-    assert_eq!(call!(ge_ui8(0, 100)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_177() {
-    assert_eq!(call!(ge_ui8(0, 162)), false);
-    assert_eq!(call!(ge_ui8(0, 254)), false);
-    assert_eq!(call!(ge_ui8(0, 255)), false);
-    assert_eq!(call!(ge_ui8(1, 2)), false);
-    assert_eq!(call!(ge_ui8(1, 3)), false);
-    assert_eq!(call!(ge_ui8(1, 4)), false);
-    assert_eq!(call!(ge_ui8(1, 72)), false);
-    assert_eq!(call!(ge_ui8(1, 100)), false);
-    assert_eq!(call!(ge_ui8(1, 162)), false);
-    assert_eq!(call!(ge_ui8(1, 254)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_178() {
-    assert_eq!(call!(ge_ui8(1, 255)), false);
-    assert_eq!(call!(ge_ui8(2, 3)), false);
-    assert_eq!(call!(ge_ui8(2, 4)), false);
-    assert_eq!(call!(ge_ui8(2, 72)), false);
-    assert_eq!(call!(ge_ui8(2, 100)), false);
-    assert_eq!(call!(ge_ui8(2, 162)), false);
-    assert_eq!(call!(ge_ui8(2, 254)), false);
-    assert_eq!(call!(ge_ui8(2, 255)), false);
-    assert_eq!(call!(ge_ui8(3, 4)), false);
-    assert_eq!(call!(ge_ui8(3, 72)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_179() {
-    assert_eq!(call!(ge_ui8(3, 100)), false);
-    assert_eq!(call!(ge_ui8(3, 162)), false);
-    assert_eq!(call!(ge_ui8(3, 254)), false);
-    assert_eq!(call!(ge_ui8(3, 255)), false);
-    assert_eq!(call!(ge_ui8(4, 72)), false);
-    assert_eq!(call!(ge_ui8(4, 100)), false);
-    assert_eq!(call!(ge_ui8(4, 162)), false);
-    assert_eq!(call!(ge_ui8(4, 254)), false);
-    assert_eq!(call!(ge_ui8(4, 255)), false);
-    assert_eq!(call!(ge_ui8(72, 100)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_180() {
-    assert_eq!(call!(ge_ui8(72, 162)), false);
-    assert_eq!(call!(ge_ui8(72, 254)), false);
-    assert_eq!(call!(ge_ui8(72, 255)), false);
-    assert_eq!(call!(ge_ui8(100, 162)), false);
-    assert_eq!(call!(ge_ui8(100, 254)), false);
-    assert_eq!(call!(ge_ui8(100, 255)), false);
-    assert_eq!(call!(ge_ui8(162, 254)), false);
-    assert_eq!(call!(ge_ui8(162, 255)), false);
-    assert_eq!(call!(ge_ui8(254, 255)), false);
-    assert_eq!(call!(ge_ui8(0, 0)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_181() {
-    assert_eq!(call!(ge_ui8(1, 0)), true);
-    assert_eq!(call!(ge_ui8(1, 1)), true);
-    assert_eq!(call!(ge_ui8(2, 0)), true);
-    assert_eq!(call!(ge_ui8(2, 1)), true);
-    assert_eq!(call!(ge_ui8(2, 2)), true);
-    assert_eq!(call!(ge_ui8(3, 0)), true);
-    assert_eq!(call!(ge_ui8(3, 1)), true);
-    assert_eq!(call!(ge_ui8(3, 2)), true);
-    assert_eq!(call!(ge_ui8(3, 3)), true);
-    assert_eq!(call!(ge_ui8(4, 0)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_182() {
-    assert_eq!(call!(ge_ui8(4, 1)), true);
-    assert_eq!(call!(ge_ui8(4, 2)), true);
-    assert_eq!(call!(ge_ui8(4, 3)), true);
-    assert_eq!(call!(ge_ui8(4, 4)), true);
-    assert_eq!(call!(ge_ui8(72, 0)), true);
-    assert_eq!(call!(ge_ui8(72, 1)), true);
-    assert_eq!(call!(ge_ui8(72, 2)), true);
-    assert_eq!(call!(ge_ui8(72, 3)), true);
-    assert_eq!(call!(ge_ui8(72, 4)), true);
-    assert_eq!(call!(ge_ui8(72, 72)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_183() {
-    assert_eq!(call!(ge_ui8(100, 0)), true);
-    assert_eq!(call!(ge_ui8(100, 1)), true);
-    assert_eq!(call!(ge_ui8(100, 2)), true);
-    assert_eq!(call!(ge_ui8(100, 3)), true);
-    assert_eq!(call!(ge_ui8(100, 4)), true);
-    assert_eq!(call!(ge_ui8(100, 72)), true);
-    assert_eq!(call!(ge_ui8(100, 100)), true);
-    assert_eq!(call!(ge_ui8(162, 0)), true);
-    assert_eq!(call!(ge_ui8(162, 1)), true);
-    assert_eq!(call!(ge_ui8(162, 2)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_184() {
-    assert_eq!(call!(ge_ui8(162, 3)), true);
-    assert_eq!(call!(ge_ui8(162, 4)), true);
-    assert_eq!(call!(ge_ui8(162, 72)), true);
-    assert_eq!(call!(ge_ui8(162, 100)), true);
-    assert_eq!(call!(ge_ui8(162, 162)), true);
-    assert_eq!(call!(ge_ui8(254, 0)), true);
-    assert_eq!(call!(ge_ui8(254, 1)), true);
-    assert_eq!(call!(ge_ui8(254, 2)), true);
-    assert_eq!(call!(ge_ui8(254, 3)), true);
-    assert_eq!(call!(ge_ui8(254, 4)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_185() {
-    assert_eq!(call!(ge_ui8(254, 72)), true);
-    assert_eq!(call!(ge_ui8(254, 100)), true);
-    assert_eq!(call!(ge_ui8(254, 162)), true);
-    assert_eq!(call!(ge_ui8(254, 254)), true);
-    assert_eq!(call!(ge_ui8(255, 0)), true);
-    assert_eq!(call!(ge_ui8(255, 1)), true);
-    assert_eq!(call!(ge_ui8(255, 2)), true);
-    assert_eq!(call!(ge_ui8(255, 3)), true);
-    assert_eq!(call!(ge_ui8(255, 4)), true);
-    assert_eq!(call!(ge_ui8(255, 72)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_186() {
-    assert_eq!(call!(ge_ui8(255, 100)), true);
-    assert_eq!(call!(ge_ui8(255, 162)), true);
-    assert_eq!(call!(ge_ui8(255, 254)), true);
-    assert_eq!(call!(ge_ui8(255, 255)), true);
-    assert_eq!(call!(gt_si16(-32768, -32768)), false);
-    assert_eq!(call!(gt_si16(-32768, -32767)), false);
-    assert_eq!(call!(gt_si16(-32768, -32547)), false);
-    assert_eq!(call!(gt_si16(-32768, 0)), false);
-    assert_eq!(call!(gt_si16(-32768, 1)), false);
-    assert_eq!(call!(gt_si16(-32768, 2)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_187() {
-    assert_eq!(call!(gt_si16(-32768, 3)), false);
-    assert_eq!(call!(gt_si16(-32768, 4)), false);
-    assert_eq!(call!(gt_si16(-32768, 10486)), false);
-    assert_eq!(call!(gt_si16(-32768, 16514)), false);
-    assert_eq!(call!(gt_si16(-32768, 32766)), false);
-    assert_eq!(call!(gt_si16(-32768, 32767)), false);
-    assert_eq!(call!(gt_si16(-32767, -32767)), false);
-    assert_eq!(call!(gt_si16(-32767, -32547)), false);
-    assert_eq!(call!(gt_si16(-32767, 0)), false);
-    assert_eq!(call!(gt_si16(-32767, 1)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_188() {
-    assert_eq!(call!(gt_si16(-32767, 2)), false);
-    assert_eq!(call!(gt_si16(-32767, 3)), false);
-    assert_eq!(call!(gt_si16(-32767, 4)), false);
-    assert_eq!(call!(gt_si16(-32767, 10486)), false);
-    assert_eq!(call!(gt_si16(-32767, 16514)), false);
-    assert_eq!(call!(gt_si16(-32767, 32766)), false);
-    assert_eq!(call!(gt_si16(-32767, 32767)), false);
-    assert_eq!(call!(gt_si16(-32547, -32547)), false);
-    assert_eq!(call!(gt_si16(-32547, 0)), false);
-    assert_eq!(call!(gt_si16(-32547, 1)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_189() {
-    assert_eq!(call!(gt_si16(-32547, 2)), false);
-    assert_eq!(call!(gt_si16(-32547, 3)), false);
-    assert_eq!(call!(gt_si16(-32547, 4)), false);
-    assert_eq!(call!(gt_si16(-32547, 10486)), false);
-    assert_eq!(call!(gt_si16(-32547, 16514)), false);
-    assert_eq!(call!(gt_si16(-32547, 32766)), false);
-    assert_eq!(call!(gt_si16(-32547, 32767)), false);
-    assert_eq!(call!(gt_si16(0, 0)), false);
-    assert_eq!(call!(gt_si16(0, 1)), false);
-    assert_eq!(call!(gt_si16(0, 2)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_190() {
-    assert_eq!(call!(gt_si16(0, 3)), false);
-    assert_eq!(call!(gt_si16(0, 4)), false);
-    assert_eq!(call!(gt_si16(0, 10486)), false);
-    assert_eq!(call!(gt_si16(0, 16514)), false);
-    assert_eq!(call!(gt_si16(0, 32766)), false);
-    assert_eq!(call!(gt_si16(0, 32767)), false);
-    assert_eq!(call!(gt_si16(1, 1)), false);
-    assert_eq!(call!(gt_si16(1, 2)), false);
-    assert_eq!(call!(gt_si16(1, 3)), false);
-    assert_eq!(call!(gt_si16(1, 4)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_191() {
-    assert_eq!(call!(gt_si16(1, 10486)), false);
-    assert_eq!(call!(gt_si16(1, 16514)), false);
-    assert_eq!(call!(gt_si16(1, 32766)), false);
-    assert_eq!(call!(gt_si16(1, 32767)), false);
-    assert_eq!(call!(gt_si16(2, 2)), false);
-    assert_eq!(call!(gt_si16(2, 3)), false);
-    assert_eq!(call!(gt_si16(2, 4)), false);
-    assert_eq!(call!(gt_si16(2, 10486)), false);
-    assert_eq!(call!(gt_si16(2, 16514)), false);
-    assert_eq!(call!(gt_si16(2, 32766)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_192() {
-    assert_eq!(call!(gt_si16(2, 32767)), false);
-    assert_eq!(call!(gt_si16(3, 3)), false);
-    assert_eq!(call!(gt_si16(3, 4)), false);
-    assert_eq!(call!(gt_si16(3, 10486)), false);
-    assert_eq!(call!(gt_si16(3, 16514)), false);
-    assert_eq!(call!(gt_si16(3, 32766)), false);
-    assert_eq!(call!(gt_si16(3, 32767)), false);
-    assert_eq!(call!(gt_si16(4, 4)), false);
-    assert_eq!(call!(gt_si16(4, 10486)), false);
-    assert_eq!(call!(gt_si16(4, 16514)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_193() {
-    assert_eq!(call!(gt_si16(4, 32766)), false);
-    assert_eq!(call!(gt_si16(4, 32767)), false);
-    assert_eq!(call!(gt_si16(10486, 10486)), false);
-    assert_eq!(call!(gt_si16(10486, 16514)), false);
-    assert_eq!(call!(gt_si16(10486, 32766)), false);
-    assert_eq!(call!(gt_si16(10486, 32767)), false);
-    assert_eq!(call!(gt_si16(16514, 16514)), false);
-    assert_eq!(call!(gt_si16(16514, 32766)), false);
-    assert_eq!(call!(gt_si16(16514, 32767)), false);
-    assert_eq!(call!(gt_si16(32766, 32766)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_194() {
-    assert_eq!(call!(gt_si16(32766, 32767)), false);
-    assert_eq!(call!(gt_si16(32767, 32767)), false);
-    assert_eq!(call!(gt_si16(-32767, -32768)), true);
-    assert_eq!(call!(gt_si16(-32547, -32768)), true);
-    assert_eq!(call!(gt_si16(-32547, -32767)), true);
-    assert_eq!(call!(gt_si16(0, -32768)), true);
-    assert_eq!(call!(gt_si16(0, -32767)), true);
-    assert_eq!(call!(gt_si16(0, -32547)), true);
-    assert_eq!(call!(gt_si16(1, -32768)), true);
-    assert_eq!(call!(gt_si16(1, -32767)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_195() {
-    assert_eq!(call!(gt_si16(1, -32547)), true);
-    assert_eq!(call!(gt_si16(1, 0)), true);
-    assert_eq!(call!(gt_si16(2, -32768)), true);
-    assert_eq!(call!(gt_si16(2, -32767)), true);
-    assert_eq!(call!(gt_si16(2, -32547)), true);
-    assert_eq!(call!(gt_si16(2, 0)), true);
-    assert_eq!(call!(gt_si16(2, 1)), true);
-    assert_eq!(call!(gt_si16(3, -32768)), true);
-    assert_eq!(call!(gt_si16(3, -32767)), true);
-    assert_eq!(call!(gt_si16(3, -32547)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_196() {
-    assert_eq!(call!(gt_si16(3, 0)), true);
-    assert_eq!(call!(gt_si16(3, 1)), true);
-    assert_eq!(call!(gt_si16(3, 2)), true);
-    assert_eq!(call!(gt_si16(4, -32768)), true);
-    assert_eq!(call!(gt_si16(4, -32767)), true);
-    assert_eq!(call!(gt_si16(4, -32547)), true);
-    assert_eq!(call!(gt_si16(4, 0)), true);
-    assert_eq!(call!(gt_si16(4, 1)), true);
-    assert_eq!(call!(gt_si16(4, 2)), true);
-    assert_eq!(call!(gt_si16(4, 3)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_197() {
-    assert_eq!(call!(gt_si16(10486, -32768)), true);
-    assert_eq!(call!(gt_si16(10486, -32767)), true);
-    assert_eq!(call!(gt_si16(10486, -32547)), true);
-    assert_eq!(call!(gt_si16(10486, 0)), true);
-    assert_eq!(call!(gt_si16(10486, 1)), true);
-    assert_eq!(call!(gt_si16(10486, 2)), true);
-    assert_eq!(call!(gt_si16(10486, 3)), true);
-    assert_eq!(call!(gt_si16(10486, 4)), true);
-    assert_eq!(call!(gt_si16(16514, -32768)), true);
-    assert_eq!(call!(gt_si16(16514, -32767)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_198() {
-    assert_eq!(call!(gt_si16(16514, -32547)), true);
-    assert_eq!(call!(gt_si16(16514, 0)), true);
-    assert_eq!(call!(gt_si16(16514, 1)), true);
-    assert_eq!(call!(gt_si16(16514, 2)), true);
-    assert_eq!(call!(gt_si16(16514, 3)), true);
-    assert_eq!(call!(gt_si16(16514, 4)), true);
-    assert_eq!(call!(gt_si16(16514, 10486)), true);
-    assert_eq!(call!(gt_si16(32766, -32768)), true);
-    assert_eq!(call!(gt_si16(32766, -32767)), true);
-    assert_eq!(call!(gt_si16(32766, -32547)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_199() {
-    assert_eq!(call!(gt_si16(32766, 0)), true);
-    assert_eq!(call!(gt_si16(32766, 1)), true);
-    assert_eq!(call!(gt_si16(32766, 2)), true);
-    assert_eq!(call!(gt_si16(32766, 3)), true);
-    assert_eq!(call!(gt_si16(32766, 4)), true);
-    assert_eq!(call!(gt_si16(32766, 10486)), true);
-    assert_eq!(call!(gt_si16(32766, 16514)), true);
-    assert_eq!(call!(gt_si16(32767, -32768)), true);
-    assert_eq!(call!(gt_si16(32767, -32767)), true);
-    assert_eq!(call!(gt_si16(32767, -32547)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_200() {
-    assert_eq!(call!(gt_si16(32767, 0)), true);
-    assert_eq!(call!(gt_si16(32767, 1)), true);
-    assert_eq!(call!(gt_si16(32767, 2)), true);
-    assert_eq!(call!(gt_si16(32767, 3)), true);
-    assert_eq!(call!(gt_si16(32767, 4)), true);
-    assert_eq!(call!(gt_si16(32767, 10486)), true);
-    assert_eq!(call!(gt_si16(32767, 16514)), true);
-    assert_eq!(call!(gt_si16(32767, 32766)), true);
-    assert_eq!(call!(gt_si32(-2147483648, -2147483648)), false);
-    assert_eq!(call!(gt_si32(-2147483648, -2147483647)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_201() {
-    assert_eq!(call!(gt_si32(-2147483648, -1713183800)), false);
-    assert_eq!(call!(gt_si32(-2147483648, -1252582164)), false);
-    assert_eq!(call!(gt_si32(-2147483648, -1035405763)), false);
-    assert_eq!(call!(gt_si32(-2147483648, 0)), false);
-    assert_eq!(call!(gt_si32(-2147483648, 1)), false);
-    assert_eq!(call!(gt_si32(-2147483648, 2)), false);
-    assert_eq!(call!(gt_si32(-2147483648, 3)), false);
-    assert_eq!(call!(gt_si32(-2147483648, 4)), false);
-    assert_eq!(call!(gt_si32(-2147483648, 2147483646)), false);
-    assert_eq!(call!(gt_si32(-2147483648, 2147483647)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_202() {
-    assert_eq!(call!(gt_si32(-2147483647, -2147483647)), false);
-    assert_eq!(call!(gt_si32(-2147483647, -1713183800)), false);
-    assert_eq!(call!(gt_si32(-2147483647, -1252582164)), false);
-    assert_eq!(call!(gt_si32(-2147483647, -1035405763)), false);
-    assert_eq!(call!(gt_si32(-2147483647, 0)), false);
-    assert_eq!(call!(gt_si32(-2147483647, 1)), false);
-    assert_eq!(call!(gt_si32(-2147483647, 2)), false);
-    assert_eq!(call!(gt_si32(-2147483647, 3)), false);
-    assert_eq!(call!(gt_si32(-2147483647, 4)), false);
-    assert_eq!(call!(gt_si32(-2147483647, 2147483646)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_203() {
-    assert_eq!(call!(gt_si32(-2147483647, 2147483647)), false);
-    assert_eq!(call!(gt_si32(-1713183800, -1713183800)), false);
-    assert_eq!(call!(gt_si32(-1713183800, -1252582164)), false);
-    assert_eq!(call!(gt_si32(-1713183800, -1035405763)), false);
-    assert_eq!(call!(gt_si32(-1713183800, 0)), false);
-    assert_eq!(call!(gt_si32(-1713183800, 1)), false);
-    assert_eq!(call!(gt_si32(-1713183800, 2)), false);
-    assert_eq!(call!(gt_si32(-1713183800, 3)), false);
-    assert_eq!(call!(gt_si32(-1713183800, 4)), false);
-    assert_eq!(call!(gt_si32(-1713183800, 2147483646)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_204() {
-    assert_eq!(call!(gt_si32(-1713183800, 2147483647)), false);
-    assert_eq!(call!(gt_si32(-1252582164, -1252582164)), false);
-    assert_eq!(call!(gt_si32(-1252582164, -1035405763)), false);
-    assert_eq!(call!(gt_si32(-1252582164, 0)), false);
-    assert_eq!(call!(gt_si32(-1252582164, 1)), false);
-    assert_eq!(call!(gt_si32(-1252582164, 2)), false);
-    assert_eq!(call!(gt_si32(-1252582164, 3)), false);
-    assert_eq!(call!(gt_si32(-1252582164, 4)), false);
-    assert_eq!(call!(gt_si32(-1252582164, 2147483646)), false);
-    assert_eq!(call!(gt_si32(-1252582164, 2147483647)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_205() {
-    assert_eq!(call!(gt_si32(-1035405763, -1035405763)), false);
-    assert_eq!(call!(gt_si32(-1035405763, 0)), false);
-    assert_eq!(call!(gt_si32(-1035405763, 1)), false);
-    assert_eq!(call!(gt_si32(-1035405763, 2)), false);
-    assert_eq!(call!(gt_si32(-1035405763, 3)), false);
-    assert_eq!(call!(gt_si32(-1035405763, 4)), false);
-    assert_eq!(call!(gt_si32(-1035405763, 2147483646)), false);
-    assert_eq!(call!(gt_si32(-1035405763, 2147483647)), false);
-    assert_eq!(call!(gt_si32(0, 0)), false);
-    assert_eq!(call!(gt_si32(0, 1)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_206() {
-    assert_eq!(call!(gt_si32(0, 2)), false);
-    assert_eq!(call!(gt_si32(0, 3)), false);
-    assert_eq!(call!(gt_si32(0, 4)), false);
-    assert_eq!(call!(gt_si32(0, 2147483646)), false);
-    assert_eq!(call!(gt_si32(0, 2147483647)), false);
-    assert_eq!(call!(gt_si32(1, 1)), false);
-    assert_eq!(call!(gt_si32(1, 2)), false);
-    assert_eq!(call!(gt_si32(1, 3)), false);
-    assert_eq!(call!(gt_si32(1, 4)), false);
-    assert_eq!(call!(gt_si32(1, 2147483646)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_207() {
-    assert_eq!(call!(gt_si32(1, 2147483647)), false);
-    assert_eq!(call!(gt_si32(2, 2)), false);
-    assert_eq!(call!(gt_si32(2, 3)), false);
-    assert_eq!(call!(gt_si32(2, 4)), false);
-    assert_eq!(call!(gt_si32(2, 2147483646)), false);
-    assert_eq!(call!(gt_si32(2, 2147483647)), false);
-    assert_eq!(call!(gt_si32(3, 3)), false);
-    assert_eq!(call!(gt_si32(3, 4)), false);
-    assert_eq!(call!(gt_si32(3, 2147483646)), false);
-    assert_eq!(call!(gt_si32(3, 2147483647)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_208() {
-    assert_eq!(call!(gt_si32(4, 4)), false);
-    assert_eq!(call!(gt_si32(4, 2147483646)), false);
-    assert_eq!(call!(gt_si32(4, 2147483647)), false);
-    assert_eq!(call!(gt_si32(2147483646, 2147483646)), false);
-    assert_eq!(call!(gt_si32(2147483646, 2147483647)), false);
-    assert_eq!(call!(gt_si32(2147483647, 2147483647)), false);
-    assert_eq!(call!(gt_si32(-2147483647, -2147483648)), true);
-    assert_eq!(call!(gt_si32(-1713183800, -2147483648)), true);
-    assert_eq!(call!(gt_si32(-1713183800, -2147483647)), true);
-    assert_eq!(call!(gt_si32(-1252582164, -2147483648)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_209() {
-    assert_eq!(call!(gt_si32(-1252582164, -2147483647)), true);
-    assert_eq!(call!(gt_si32(-1252582164, -1713183800)), true);
-    assert_eq!(call!(gt_si32(-1035405763, -2147483648)), true);
-    assert_eq!(call!(gt_si32(-1035405763, -2147483647)), true);
-    assert_eq!(call!(gt_si32(-1035405763, -1713183800)), true);
-    assert_eq!(call!(gt_si32(-1035405763, -1252582164)), true);
-    assert_eq!(call!(gt_si32(0, -2147483648)), true);
-    assert_eq!(call!(gt_si32(0, -2147483647)), true);
-    assert_eq!(call!(gt_si32(0, -1713183800)), true);
-    assert_eq!(call!(gt_si32(0, -1252582164)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_210() {
-    assert_eq!(call!(gt_si32(0, -1035405763)), true);
-    assert_eq!(call!(gt_si32(1, -2147483648)), true);
-    assert_eq!(call!(gt_si32(1, -2147483647)), true);
-    assert_eq!(call!(gt_si32(1, -1713183800)), true);
-    assert_eq!(call!(gt_si32(1, -1252582164)), true);
-    assert_eq!(call!(gt_si32(1, -1035405763)), true);
-    assert_eq!(call!(gt_si32(1, 0)), true);
-    assert_eq!(call!(gt_si32(2, -2147483648)), true);
-    assert_eq!(call!(gt_si32(2, -2147483647)), true);
-    assert_eq!(call!(gt_si32(2, -1713183800)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_211() {
-    assert_eq!(call!(gt_si32(2, -1252582164)), true);
-    assert_eq!(call!(gt_si32(2, -1035405763)), true);
-    assert_eq!(call!(gt_si32(2, 0)), true);
-    assert_eq!(call!(gt_si32(2, 1)), true);
-    assert_eq!(call!(gt_si32(3, -2147483648)), true);
-    assert_eq!(call!(gt_si32(3, -2147483647)), true);
-    assert_eq!(call!(gt_si32(3, -1713183800)), true);
-    assert_eq!(call!(gt_si32(3, -1252582164)), true);
-    assert_eq!(call!(gt_si32(3, -1035405763)), true);
-    assert_eq!(call!(gt_si32(3, 0)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_212() {
-    assert_eq!(call!(gt_si32(3, 1)), true);
-    assert_eq!(call!(gt_si32(3, 2)), true);
-    assert_eq!(call!(gt_si32(4, -2147483648)), true);
-    assert_eq!(call!(gt_si32(4, -2147483647)), true);
-    assert_eq!(call!(gt_si32(4, -1713183800)), true);
-    assert_eq!(call!(gt_si32(4, -1252582164)), true);
-    assert_eq!(call!(gt_si32(4, -1035405763)), true);
-    assert_eq!(call!(gt_si32(4, 0)), true);
-    assert_eq!(call!(gt_si32(4, 1)), true);
-    assert_eq!(call!(gt_si32(4, 2)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_213() {
-    assert_eq!(call!(gt_si32(4, 3)), true);
-    assert_eq!(call!(gt_si32(2147483646, -2147483648)), true);
-    assert_eq!(call!(gt_si32(2147483646, -2147483647)), true);
-    assert_eq!(call!(gt_si32(2147483646, -1713183800)), true);
-    assert_eq!(call!(gt_si32(2147483646, -1252582164)), true);
-    assert_eq!(call!(gt_si32(2147483646, -1035405763)), true);
-    assert_eq!(call!(gt_si32(2147483646, 0)), true);
-    assert_eq!(call!(gt_si32(2147483646, 1)), true);
-    assert_eq!(call!(gt_si32(2147483646, 2)), true);
-    assert_eq!(call!(gt_si32(2147483646, 3)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_214() {
-    assert_eq!(call!(gt_si32(2147483646, 4)), true);
-    assert_eq!(call!(gt_si32(2147483647, -2147483648)), true);
-    assert_eq!(call!(gt_si32(2147483647, -2147483647)), true);
-    assert_eq!(call!(gt_si32(2147483647, -1713183800)), true);
-    assert_eq!(call!(gt_si32(2147483647, -1252582164)), true);
-    assert_eq!(call!(gt_si32(2147483647, -1035405763)), true);
-    assert_eq!(call!(gt_si32(2147483647, 0)), true);
-    assert_eq!(call!(gt_si32(2147483647, 1)), true);
-    assert_eq!(call!(gt_si32(2147483647, 2)), true);
-    assert_eq!(call!(gt_si32(2147483647, 3)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_215() {
-    assert_eq!(call!(gt_si32(2147483647, 4)), true);
-    assert_eq!(call!(gt_si32(2147483647, 2147483646)), true);
-    assert_eq!(call!(gt_si64(-9223372036854775808, -9223372036854775808)), false);
-    assert_eq!(call!(gt_si64(-9223372036854775808, -9223372036854775807)), false);
-    assert_eq!(call!(gt_si64(-9223372036854775808, -1741927215160008704)), false);
-    assert_eq!(call!(gt_si64(-9223372036854775808, -1328271339354574848)), false);
-    assert_eq!(call!(gt_si64(-9223372036854775808, 0)), false);
-    assert_eq!(call!(gt_si64(-9223372036854775808, 1)), false);
-    assert_eq!(call!(gt_si64(-9223372036854775808, 2)), false);
-    assert_eq!(call!(gt_si64(-9223372036854775808, 3)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_216() {
-    assert_eq!(call!(gt_si64(-9223372036854775808, 4)), false);
-    assert_eq!(call!(gt_si64(-9223372036854775808, 5577148965131116544)), false);
-    assert_eq!(call!(gt_si64(-9223372036854775808, 9223372036854775806)), false);
-    assert_eq!(call!(gt_si64(-9223372036854775808, 9223372036854775807)), false);
-    assert_eq!(call!(gt_si64(-9223372036854775807, -9223372036854775807)), false);
-    assert_eq!(call!(gt_si64(-9223372036854775807, -1741927215160008704)), false);
-    assert_eq!(call!(gt_si64(-9223372036854775807, -1328271339354574848)), false);
-    assert_eq!(call!(gt_si64(-9223372036854775807, 0)), false);
-    assert_eq!(call!(gt_si64(-9223372036854775807, 1)), false);
-    assert_eq!(call!(gt_si64(-9223372036854775807, 2)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_217() {
-    assert_eq!(call!(gt_si64(-9223372036854775807, 3)), false);
-    assert_eq!(call!(gt_si64(-9223372036854775807, 4)), false);
-    assert_eq!(call!(gt_si64(-9223372036854775807, 5577148965131116544)), false);
-    assert_eq!(call!(gt_si64(-9223372036854775807, 9223372036854775806)), false);
-    assert_eq!(call!(gt_si64(-9223372036854775807, 9223372036854775807)), false);
-    assert_eq!(call!(gt_si64(-1741927215160008704, -1741927215160008704)), false);
-    assert_eq!(call!(gt_si64(-1741927215160008704, -1328271339354574848)), false);
-    assert_eq!(call!(gt_si64(-1741927215160008704, 0)), false);
-    assert_eq!(call!(gt_si64(-1741927215160008704, 1)), false);
-    assert_eq!(call!(gt_si64(-1741927215160008704, 2)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_218() {
-    assert_eq!(call!(gt_si64(-1741927215160008704, 3)), false);
-    assert_eq!(call!(gt_si64(-1741927215160008704, 4)), false);
-    assert_eq!(call!(gt_si64(-1741927215160008704, 5577148965131116544)), false);
-    assert_eq!(call!(gt_si64(-1741927215160008704, 9223372036854775806)), false);
-    assert_eq!(call!(gt_si64(-1741927215160008704, 9223372036854775807)), false);
-    assert_eq!(call!(gt_si64(-1328271339354574848, -1328271339354574848)), false);
-    assert_eq!(call!(gt_si64(-1328271339354574848, 0)), false);
-    assert_eq!(call!(gt_si64(-1328271339354574848, 1)), false);
-    assert_eq!(call!(gt_si64(-1328271339354574848, 2)), false);
-    assert_eq!(call!(gt_si64(-1328271339354574848, 3)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_219() {
-    assert_eq!(call!(gt_si64(-1328271339354574848, 4)), false);
-    assert_eq!(call!(gt_si64(-1328271339354574848, 5577148965131116544)), false);
-    assert_eq!(call!(gt_si64(-1328271339354574848, 9223372036854775806)), false);
-    assert_eq!(call!(gt_si64(-1328271339354574848, 9223372036854775807)), false);
-    assert_eq!(call!(gt_si64(0, 0)), false);
-    assert_eq!(call!(gt_si64(0, 1)), false);
-    assert_eq!(call!(gt_si64(0, 2)), false);
-    assert_eq!(call!(gt_si64(0, 3)), false);
-    assert_eq!(call!(gt_si64(0, 4)), false);
-    assert_eq!(call!(gt_si64(0, 5577148965131116544)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_220() {
-    assert_eq!(call!(gt_si64(0, 9223372036854775806)), false);
-    assert_eq!(call!(gt_si64(0, 9223372036854775807)), false);
-    assert_eq!(call!(gt_si64(1, 1)), false);
-    assert_eq!(call!(gt_si64(1, 2)), false);
-    assert_eq!(call!(gt_si64(1, 3)), false);
-    assert_eq!(call!(gt_si64(1, 4)), false);
-    assert_eq!(call!(gt_si64(1, 5577148965131116544)), false);
-    assert_eq!(call!(gt_si64(1, 9223372036854775806)), false);
-    assert_eq!(call!(gt_si64(1, 9223372036854775807)), false);
-    assert_eq!(call!(gt_si64(2, 2)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_221() {
-    assert_eq!(call!(gt_si64(2, 3)), false);
-    assert_eq!(call!(gt_si64(2, 4)), false);
-    assert_eq!(call!(gt_si64(2, 5577148965131116544)), false);
-    assert_eq!(call!(gt_si64(2, 9223372036854775806)), false);
-    assert_eq!(call!(gt_si64(2, 9223372036854775807)), false);
-    assert_eq!(call!(gt_si64(3, 3)), false);
-    assert_eq!(call!(gt_si64(3, 4)), false);
-    assert_eq!(call!(gt_si64(3, 5577148965131116544)), false);
-    assert_eq!(call!(gt_si64(3, 9223372036854775806)), false);
-    assert_eq!(call!(gt_si64(3, 9223372036854775807)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_222() {
-    assert_eq!(call!(gt_si64(4, 4)), false);
-    assert_eq!(call!(gt_si64(4, 5577148965131116544)), false);
-    assert_eq!(call!(gt_si64(4, 9223372036854775806)), false);
-    assert_eq!(call!(gt_si64(4, 9223372036854775807)), false);
-    assert_eq!(call!(gt_si64(5577148965131116544, 5577148965131116544)), false);
-    assert_eq!(call!(gt_si64(5577148965131116544, 9223372036854775806)), false);
-    assert_eq!(call!(gt_si64(5577148965131116544, 9223372036854775807)), false);
-    assert_eq!(call!(gt_si64(9223372036854775806, 9223372036854775806)), false);
-    assert_eq!(call!(gt_si64(9223372036854775806, 9223372036854775807)), false);
-    assert_eq!(call!(gt_si64(9223372036854775807, 9223372036854775807)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_223() {
-    assert_eq!(call!(gt_si64(-9223372036854775807, -9223372036854775808)), true);
-    assert_eq!(call!(gt_si64(-1741927215160008704, -9223372036854775808)), true);
-    assert_eq!(call!(gt_si64(-1741927215160008704, -9223372036854775807)), true);
-    assert_eq!(call!(gt_si64(-1328271339354574848, -9223372036854775808)), true);
-    assert_eq!(call!(gt_si64(-1328271339354574848, -9223372036854775807)), true);
-    assert_eq!(call!(gt_si64(-1328271339354574848, -1741927215160008704)), true);
-    assert_eq!(call!(gt_si64(0, -9223372036854775808)), true);
-    assert_eq!(call!(gt_si64(0, -9223372036854775807)), true);
-    assert_eq!(call!(gt_si64(0, -1741927215160008704)), true);
-    assert_eq!(call!(gt_si64(0, -1328271339354574848)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_224() {
-    assert_eq!(call!(gt_si64(1, -9223372036854775808)), true);
-    assert_eq!(call!(gt_si64(1, -9223372036854775807)), true);
-    assert_eq!(call!(gt_si64(1, -1741927215160008704)), true);
-    assert_eq!(call!(gt_si64(1, -1328271339354574848)), true);
-    assert_eq!(call!(gt_si64(1, 0)), true);
-    assert_eq!(call!(gt_si64(2, -9223372036854775808)), true);
-    assert_eq!(call!(gt_si64(2, -9223372036854775807)), true);
-    assert_eq!(call!(gt_si64(2, -1741927215160008704)), true);
-    assert_eq!(call!(gt_si64(2, -1328271339354574848)), true);
-    assert_eq!(call!(gt_si64(2, 0)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_225() {
-    assert_eq!(call!(gt_si64(2, 1)), true);
-    assert_eq!(call!(gt_si64(3, -9223372036854775808)), true);
-    assert_eq!(call!(gt_si64(3, -9223372036854775807)), true);
-    assert_eq!(call!(gt_si64(3, -1741927215160008704)), true);
-    assert_eq!(call!(gt_si64(3, -1328271339354574848)), true);
-    assert_eq!(call!(gt_si64(3, 0)), true);
-    assert_eq!(call!(gt_si64(3, 1)), true);
-    assert_eq!(call!(gt_si64(3, 2)), true);
-    assert_eq!(call!(gt_si64(4, -9223372036854775808)), true);
-    assert_eq!(call!(gt_si64(4, -9223372036854775807)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_226() {
-    assert_eq!(call!(gt_si64(4, -1741927215160008704)), true);
-    assert_eq!(call!(gt_si64(4, -1328271339354574848)), true);
-    assert_eq!(call!(gt_si64(4, 0)), true);
-    assert_eq!(call!(gt_si64(4, 1)), true);
-    assert_eq!(call!(gt_si64(4, 2)), true);
-    assert_eq!(call!(gt_si64(4, 3)), true);
-    assert_eq!(call!(gt_si64(5577148965131116544, -9223372036854775808)), true);
-    assert_eq!(call!(gt_si64(5577148965131116544, -9223372036854775807)), true);
-    assert_eq!(call!(gt_si64(5577148965131116544, -1741927215160008704)), true);
-    assert_eq!(call!(gt_si64(5577148965131116544, -1328271339354574848)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_227() {
-    assert_eq!(call!(gt_si64(5577148965131116544, 0)), true);
-    assert_eq!(call!(gt_si64(5577148965131116544, 1)), true);
-    assert_eq!(call!(gt_si64(5577148965131116544, 2)), true);
-    assert_eq!(call!(gt_si64(5577148965131116544, 3)), true);
-    assert_eq!(call!(gt_si64(5577148965131116544, 4)), true);
-    assert_eq!(call!(gt_si64(9223372036854775806, -9223372036854775808)), true);
-    assert_eq!(call!(gt_si64(9223372036854775806, -9223372036854775807)), true);
-    assert_eq!(call!(gt_si64(9223372036854775806, -1741927215160008704)), true);
-    assert_eq!(call!(gt_si64(9223372036854775806, -1328271339354574848)), true);
-    assert_eq!(call!(gt_si64(9223372036854775806, 0)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_228() {
-    assert_eq!(call!(gt_si64(9223372036854775806, 1)), true);
-    assert_eq!(call!(gt_si64(9223372036854775806, 2)), true);
-    assert_eq!(call!(gt_si64(9223372036854775806, 3)), true);
-    assert_eq!(call!(gt_si64(9223372036854775806, 4)), true);
-    assert_eq!(call!(gt_si64(9223372036854775806, 5577148965131116544)), true);
-    assert_eq!(call!(gt_si64(9223372036854775807, -9223372036854775808)), true);
-    assert_eq!(call!(gt_si64(9223372036854775807, -9223372036854775807)), true);
-    assert_eq!(call!(gt_si64(9223372036854775807, -1741927215160008704)), true);
-    assert_eq!(call!(gt_si64(9223372036854775807, -1328271339354574848)), true);
-    assert_eq!(call!(gt_si64(9223372036854775807, 0)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_229() {
-    assert_eq!(call!(gt_si64(9223372036854775807, 1)), true);
-    assert_eq!(call!(gt_si64(9223372036854775807, 2)), true);
-    assert_eq!(call!(gt_si64(9223372036854775807, 3)), true);
-    assert_eq!(call!(gt_si64(9223372036854775807, 4)), true);
-    assert_eq!(call!(gt_si64(9223372036854775807, 5577148965131116544)), true);
-    assert_eq!(call!(gt_si64(9223372036854775807, 9223372036854775806)), true);
-    assert_eq!(call!(gt_si8(-128, -128)), false);
-    assert_eq!(call!(gt_si8(-128, -127)), false);
-    assert_eq!(call!(gt_si8(-128, 0)), false);
-    assert_eq!(call!(gt_si8(-128, 1)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_230() {
-    assert_eq!(call!(gt_si8(-128, 2)), false);
-    assert_eq!(call!(gt_si8(-128, 3)), false);
-    assert_eq!(call!(gt_si8(-128, 4)), false);
-    assert_eq!(call!(gt_si8(-128, 16)), false);
-    assert_eq!(call!(gt_si8(-128, 126)), false);
-    assert_eq!(call!(gt_si8(-128, 127)), false);
-    assert_eq!(call!(gt_si8(-127, -127)), false);
-    assert_eq!(call!(gt_si8(-127, 0)), false);
-    assert_eq!(call!(gt_si8(-127, 1)), false);
-    assert_eq!(call!(gt_si8(-127, 2)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_231() {
-    assert_eq!(call!(gt_si8(-127, 3)), false);
-    assert_eq!(call!(gt_si8(-127, 4)), false);
-    assert_eq!(call!(gt_si8(-127, 16)), false);
-    assert_eq!(call!(gt_si8(-127, 126)), false);
-    assert_eq!(call!(gt_si8(-127, 127)), false);
-    assert_eq!(call!(gt_si8(0, 0)), false);
-    assert_eq!(call!(gt_si8(0, 1)), false);
-    assert_eq!(call!(gt_si8(0, 2)), false);
-    assert_eq!(call!(gt_si8(0, 3)), false);
-    assert_eq!(call!(gt_si8(0, 4)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_232() {
-    assert_eq!(call!(gt_si8(0, 16)), false);
-    assert_eq!(call!(gt_si8(0, 126)), false);
-    assert_eq!(call!(gt_si8(0, 127)), false);
-    assert_eq!(call!(gt_si8(1, 1)), false);
-    assert_eq!(call!(gt_si8(1, 2)), false);
-    assert_eq!(call!(gt_si8(1, 3)), false);
-    assert_eq!(call!(gt_si8(1, 4)), false);
-    assert_eq!(call!(gt_si8(1, 16)), false);
-    assert_eq!(call!(gt_si8(1, 126)), false);
-    assert_eq!(call!(gt_si8(1, 127)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_233() {
-    assert_eq!(call!(gt_si8(2, 2)), false);
-    assert_eq!(call!(gt_si8(2, 3)), false);
-    assert_eq!(call!(gt_si8(2, 4)), false);
-    assert_eq!(call!(gt_si8(2, 16)), false);
-    assert_eq!(call!(gt_si8(2, 126)), false);
-    assert_eq!(call!(gt_si8(2, 127)), false);
-    assert_eq!(call!(gt_si8(3, 3)), false);
-    assert_eq!(call!(gt_si8(3, 4)), false);
-    assert_eq!(call!(gt_si8(3, 16)), false);
-    assert_eq!(call!(gt_si8(3, 126)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_234() {
-    assert_eq!(call!(gt_si8(3, 127)), false);
-    assert_eq!(call!(gt_si8(4, 4)), false);
-    assert_eq!(call!(gt_si8(4, 16)), false);
-    assert_eq!(call!(gt_si8(4, 126)), false);
-    assert_eq!(call!(gt_si8(4, 127)), false);
-    assert_eq!(call!(gt_si8(16, 16)), false);
-    assert_eq!(call!(gt_si8(16, 126)), false);
-    assert_eq!(call!(gt_si8(16, 127)), false);
-    assert_eq!(call!(gt_si8(126, 126)), false);
-    assert_eq!(call!(gt_si8(126, 127)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_235() {
-    assert_eq!(call!(gt_si8(127, 127)), false);
-    assert_eq!(call!(gt_si8(-127, -128)), true);
-    assert_eq!(call!(gt_si8(0, -128)), true);
-    assert_eq!(call!(gt_si8(0, -127)), true);
-    assert_eq!(call!(gt_si8(1, -128)), true);
-    assert_eq!(call!(gt_si8(1, -127)), true);
-    assert_eq!(call!(gt_si8(1, 0)), true);
-    assert_eq!(call!(gt_si8(2, -128)), true);
-    assert_eq!(call!(gt_si8(2, -127)), true);
-    assert_eq!(call!(gt_si8(2, 0)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_236() {
-    assert_eq!(call!(gt_si8(2, 1)), true);
-    assert_eq!(call!(gt_si8(3, -128)), true);
-    assert_eq!(call!(gt_si8(3, -127)), true);
-    assert_eq!(call!(gt_si8(3, 0)), true);
-    assert_eq!(call!(gt_si8(3, 1)), true);
-    assert_eq!(call!(gt_si8(3, 2)), true);
-    assert_eq!(call!(gt_si8(4, -128)), true);
-    assert_eq!(call!(gt_si8(4, -127)), true);
-    assert_eq!(call!(gt_si8(4, 0)), true);
-    assert_eq!(call!(gt_si8(4, 1)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_237() {
-    assert_eq!(call!(gt_si8(4, 2)), true);
-    assert_eq!(call!(gt_si8(4, 3)), true);
-    assert_eq!(call!(gt_si8(16, -128)), true);
-    assert_eq!(call!(gt_si8(16, -127)), true);
-    assert_eq!(call!(gt_si8(16, 0)), true);
-    assert_eq!(call!(gt_si8(16, 1)), true);
-    assert_eq!(call!(gt_si8(16, 2)), true);
-    assert_eq!(call!(gt_si8(16, 3)), true);
-    assert_eq!(call!(gt_si8(16, 4)), true);
-    assert_eq!(call!(gt_si8(126, -128)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_238() {
-    assert_eq!(call!(gt_si8(126, -127)), true);
-    assert_eq!(call!(gt_si8(126, 0)), true);
-    assert_eq!(call!(gt_si8(126, 1)), true);
-    assert_eq!(call!(gt_si8(126, 2)), true);
-    assert_eq!(call!(gt_si8(126, 3)), true);
-    assert_eq!(call!(gt_si8(126, 4)), true);
-    assert_eq!(call!(gt_si8(126, 16)), true);
-    assert_eq!(call!(gt_si8(127, -128)), true);
-    assert_eq!(call!(gt_si8(127, -127)), true);
-    assert_eq!(call!(gt_si8(127, 0)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_239() {
-    assert_eq!(call!(gt_si8(127, 1)), true);
-    assert_eq!(call!(gt_si8(127, 2)), true);
-    assert_eq!(call!(gt_si8(127, 3)), true);
-    assert_eq!(call!(gt_si8(127, 4)), true);
-    assert_eq!(call!(gt_si8(127, 16)), true);
-    assert_eq!(call!(gt_si8(127, 126)), true);
-    assert_eq!(call!(gt_ui16(0, 0)), false);
-    assert_eq!(call!(gt_ui16(0, 1)), false);
-    assert_eq!(call!(gt_ui16(0, 2)), false);
-    assert_eq!(call!(gt_ui16(0, 3)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_240() {
-    assert_eq!(call!(gt_ui16(0, 4)), false);
-    assert_eq!(call!(gt_ui16(0, 1717)), false);
-    assert_eq!(call!(gt_ui16(0, 17988)), false);
-    assert_eq!(call!(gt_ui16(0, 65096)), false);
-    assert_eq!(call!(gt_ui16(0, 65534)), false);
-    assert_eq!(call!(gt_ui16(0, 65535)), false);
-    assert_eq!(call!(gt_ui16(1, 1)), false);
-    assert_eq!(call!(gt_ui16(1, 2)), false);
-    assert_eq!(call!(gt_ui16(1, 3)), false);
-    assert_eq!(call!(gt_ui16(1, 4)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_241() {
-    assert_eq!(call!(gt_ui16(1, 1717)), false);
-    assert_eq!(call!(gt_ui16(1, 17988)), false);
-    assert_eq!(call!(gt_ui16(1, 65096)), false);
-    assert_eq!(call!(gt_ui16(1, 65534)), false);
-    assert_eq!(call!(gt_ui16(1, 65535)), false);
-    assert_eq!(call!(gt_ui16(2, 2)), false);
-    assert_eq!(call!(gt_ui16(2, 3)), false);
-    assert_eq!(call!(gt_ui16(2, 4)), false);
-    assert_eq!(call!(gt_ui16(2, 1717)), false);
-    assert_eq!(call!(gt_ui16(2, 17988)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_242() {
-    assert_eq!(call!(gt_ui16(2, 65096)), false);
-    assert_eq!(call!(gt_ui16(2, 65534)), false);
-    assert_eq!(call!(gt_ui16(2, 65535)), false);
-    assert_eq!(call!(gt_ui16(3, 3)), false);
-    assert_eq!(call!(gt_ui16(3, 4)), false);
-    assert_eq!(call!(gt_ui16(3, 1717)), false);
-    assert_eq!(call!(gt_ui16(3, 17988)), false);
-    assert_eq!(call!(gt_ui16(3, 65096)), false);
-    assert_eq!(call!(gt_ui16(3, 65534)), false);
-    assert_eq!(call!(gt_ui16(3, 65535)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_243() {
-    assert_eq!(call!(gt_ui16(4, 4)), false);
-    assert_eq!(call!(gt_ui16(4, 1717)), false);
-    assert_eq!(call!(gt_ui16(4, 17988)), false);
-    assert_eq!(call!(gt_ui16(4, 65096)), false);
-    assert_eq!(call!(gt_ui16(4, 65534)), false);
-    assert_eq!(call!(gt_ui16(4, 65535)), false);
-    assert_eq!(call!(gt_ui16(1717, 1717)), false);
-    assert_eq!(call!(gt_ui16(1717, 17988)), false);
-    assert_eq!(call!(gt_ui16(1717, 65096)), false);
-    assert_eq!(call!(gt_ui16(1717, 65534)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_244() {
-    assert_eq!(call!(gt_ui16(1717, 65535)), false);
-    assert_eq!(call!(gt_ui16(17988, 17988)), false);
-    assert_eq!(call!(gt_ui16(17988, 65096)), false);
-    assert_eq!(call!(gt_ui16(17988, 65534)), false);
-    assert_eq!(call!(gt_ui16(17988, 65535)), false);
-    assert_eq!(call!(gt_ui16(65096, 65096)), false);
-    assert_eq!(call!(gt_ui16(65096, 65534)), false);
-    assert_eq!(call!(gt_ui16(65096, 65535)), false);
-    assert_eq!(call!(gt_ui16(65534, 65534)), false);
-    assert_eq!(call!(gt_ui16(65534, 65535)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_245() {
-    assert_eq!(call!(gt_ui16(65535, 65535)), false);
-    assert_eq!(call!(gt_ui16(1, 0)), true);
-    assert_eq!(call!(gt_ui16(2, 0)), true);
-    assert_eq!(call!(gt_ui16(2, 1)), true);
-    assert_eq!(call!(gt_ui16(3, 0)), true);
-    assert_eq!(call!(gt_ui16(3, 1)), true);
-    assert_eq!(call!(gt_ui16(3, 2)), true);
-    assert_eq!(call!(gt_ui16(4, 0)), true);
-    assert_eq!(call!(gt_ui16(4, 1)), true);
-    assert_eq!(call!(gt_ui16(4, 2)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_246() {
-    assert_eq!(call!(gt_ui16(4, 3)), true);
-    assert_eq!(call!(gt_ui16(1717, 0)), true);
-    assert_eq!(call!(gt_ui16(1717, 1)), true);
-    assert_eq!(call!(gt_ui16(1717, 2)), true);
-    assert_eq!(call!(gt_ui16(1717, 3)), true);
-    assert_eq!(call!(gt_ui16(1717, 4)), true);
-    assert_eq!(call!(gt_ui16(17988, 0)), true);
-    assert_eq!(call!(gt_ui16(17988, 1)), true);
-    assert_eq!(call!(gt_ui16(17988, 2)), true);
-    assert_eq!(call!(gt_ui16(17988, 3)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_247() {
-    assert_eq!(call!(gt_ui16(17988, 4)), true);
-    assert_eq!(call!(gt_ui16(17988, 1717)), true);
-    assert_eq!(call!(gt_ui16(65096, 0)), true);
-    assert_eq!(call!(gt_ui16(65096, 1)), true);
-    assert_eq!(call!(gt_ui16(65096, 2)), true);
-    assert_eq!(call!(gt_ui16(65096, 3)), true);
-    assert_eq!(call!(gt_ui16(65096, 4)), true);
-    assert_eq!(call!(gt_ui16(65096, 1717)), true);
-    assert_eq!(call!(gt_ui16(65096, 17988)), true);
-    assert_eq!(call!(gt_ui16(65534, 0)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_248() {
-    assert_eq!(call!(gt_ui16(65534, 1)), true);
-    assert_eq!(call!(gt_ui16(65534, 2)), true);
-    assert_eq!(call!(gt_ui16(65534, 3)), true);
-    assert_eq!(call!(gt_ui16(65534, 4)), true);
-    assert_eq!(call!(gt_ui16(65534, 1717)), true);
-    assert_eq!(call!(gt_ui16(65534, 17988)), true);
-    assert_eq!(call!(gt_ui16(65534, 65096)), true);
-    assert_eq!(call!(gt_ui16(65535, 0)), true);
-    assert_eq!(call!(gt_ui16(65535, 1)), true);
-    assert_eq!(call!(gt_ui16(65535, 2)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_249() {
-    assert_eq!(call!(gt_ui16(65535, 3)), true);
-    assert_eq!(call!(gt_ui16(65535, 4)), true);
-    assert_eq!(call!(gt_ui16(65535, 1717)), true);
-    assert_eq!(call!(gt_ui16(65535, 17988)), true);
-    assert_eq!(call!(gt_ui16(65535, 65096)), true);
-    assert_eq!(call!(gt_ui16(65535, 65534)), true);
-    assert_eq!(call!(gt_ui32(0, 0)), false);
-    assert_eq!(call!(gt_ui32(0, 1)), false);
-    assert_eq!(call!(gt_ui32(0, 2)), false);
-    assert_eq!(call!(gt_ui32(0, 3)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_250() {
-    assert_eq!(call!(gt_ui32(0, 4)), false);
-    assert_eq!(call!(gt_ui32(0, 2119154652)), false);
-    assert_eq!(call!(gt_ui32(0, 3002788344)), false);
-    assert_eq!(call!(gt_ui32(0, 3482297128)), false);
-    assert_eq!(call!(gt_ui32(0, 4294967294)), false);
-    assert_eq!(call!(gt_ui32(0, 4294967295)), false);
-    assert_eq!(call!(gt_ui32(1, 1)), false);
-    assert_eq!(call!(gt_ui32(1, 2)), false);
-    assert_eq!(call!(gt_ui32(1, 3)), false);
-    assert_eq!(call!(gt_ui32(1, 4)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_251() {
-    assert_eq!(call!(gt_ui32(1, 2119154652)), false);
-    assert_eq!(call!(gt_ui32(1, 3002788344)), false);
-    assert_eq!(call!(gt_ui32(1, 3482297128)), false);
-    assert_eq!(call!(gt_ui32(1, 4294967294)), false);
-    assert_eq!(call!(gt_ui32(1, 4294967295)), false);
-    assert_eq!(call!(gt_ui32(2, 2)), false);
-    assert_eq!(call!(gt_ui32(2, 3)), false);
-    assert_eq!(call!(gt_ui32(2, 4)), false);
-    assert_eq!(call!(gt_ui32(2, 2119154652)), false);
-    assert_eq!(call!(gt_ui32(2, 3002788344)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_252() {
-    assert_eq!(call!(gt_ui32(2, 3482297128)), false);
-    assert_eq!(call!(gt_ui32(2, 4294967294)), false);
-    assert_eq!(call!(gt_ui32(2, 4294967295)), false);
-    assert_eq!(call!(gt_ui32(3, 3)), false);
-    assert_eq!(call!(gt_ui32(3, 4)), false);
-    assert_eq!(call!(gt_ui32(3, 2119154652)), false);
-    assert_eq!(call!(gt_ui32(3, 3002788344)), false);
-    assert_eq!(call!(gt_ui32(3, 3482297128)), false);
-    assert_eq!(call!(gt_ui32(3, 4294967294)), false);
-    assert_eq!(call!(gt_ui32(3, 4294967295)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_253() {
-    assert_eq!(call!(gt_ui32(4, 4)), false);
-    assert_eq!(call!(gt_ui32(4, 2119154652)), false);
-    assert_eq!(call!(gt_ui32(4, 3002788344)), false);
-    assert_eq!(call!(gt_ui32(4, 3482297128)), false);
-    assert_eq!(call!(gt_ui32(4, 4294967294)), false);
-    assert_eq!(call!(gt_ui32(4, 4294967295)), false);
-    assert_eq!(call!(gt_ui32(2119154652, 2119154652)), false);
-    assert_eq!(call!(gt_ui32(2119154652, 3002788344)), false);
-    assert_eq!(call!(gt_ui32(2119154652, 3482297128)), false);
-    assert_eq!(call!(gt_ui32(2119154652, 4294967294)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_254() {
-    assert_eq!(call!(gt_ui32(2119154652, 4294967295)), false);
-    assert_eq!(call!(gt_ui32(3002788344, 3002788344)), false);
-    assert_eq!(call!(gt_ui32(3002788344, 3482297128)), false);
-    assert_eq!(call!(gt_ui32(3002788344, 4294967294)), false);
-    assert_eq!(call!(gt_ui32(3002788344, 4294967295)), false);
-    assert_eq!(call!(gt_ui32(3482297128, 3482297128)), false);
-    assert_eq!(call!(gt_ui32(3482297128, 4294967294)), false);
-    assert_eq!(call!(gt_ui32(3482297128, 4294967295)), false);
-    assert_eq!(call!(gt_ui32(4294967294, 4294967294)), false);
-    assert_eq!(call!(gt_ui32(4294967294, 4294967295)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_255() {
-    assert_eq!(call!(gt_ui32(4294967295, 4294967295)), false);
-    assert_eq!(call!(gt_ui32(1, 0)), true);
-    assert_eq!(call!(gt_ui32(2, 0)), true);
-    assert_eq!(call!(gt_ui32(2, 1)), true);
-    assert_eq!(call!(gt_ui32(3, 0)), true);
-    assert_eq!(call!(gt_ui32(3, 1)), true);
-    assert_eq!(call!(gt_ui32(3, 2)), true);
-    assert_eq!(call!(gt_ui32(4, 0)), true);
-    assert_eq!(call!(gt_ui32(4, 1)), true);
-    assert_eq!(call!(gt_ui32(4, 2)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_256() {
-    assert_eq!(call!(gt_ui32(4, 3)), true);
-    assert_eq!(call!(gt_ui32(2119154652, 0)), true);
-    assert_eq!(call!(gt_ui32(2119154652, 1)), true);
-    assert_eq!(call!(gt_ui32(2119154652, 2)), true);
-    assert_eq!(call!(gt_ui32(2119154652, 3)), true);
-    assert_eq!(call!(gt_ui32(2119154652, 4)), true);
-    assert_eq!(call!(gt_ui32(3002788344, 0)), true);
-    assert_eq!(call!(gt_ui32(3002788344, 1)), true);
-    assert_eq!(call!(gt_ui32(3002788344, 2)), true);
-    assert_eq!(call!(gt_ui32(3002788344, 3)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_257() {
-    assert_eq!(call!(gt_ui32(3002788344, 4)), true);
-    assert_eq!(call!(gt_ui32(3002788344, 2119154652)), true);
-    assert_eq!(call!(gt_ui32(3482297128, 0)), true);
-    assert_eq!(call!(gt_ui32(3482297128, 1)), true);
-    assert_eq!(call!(gt_ui32(3482297128, 2)), true);
-    assert_eq!(call!(gt_ui32(3482297128, 3)), true);
-    assert_eq!(call!(gt_ui32(3482297128, 4)), true);
-    assert_eq!(call!(gt_ui32(3482297128, 2119154652)), true);
-    assert_eq!(call!(gt_ui32(3482297128, 3002788344)), true);
-    assert_eq!(call!(gt_ui32(4294967294, 0)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_258() {
-    assert_eq!(call!(gt_ui32(4294967294, 1)), true);
-    assert_eq!(call!(gt_ui32(4294967294, 2)), true);
-    assert_eq!(call!(gt_ui32(4294967294, 3)), true);
-    assert_eq!(call!(gt_ui32(4294967294, 4)), true);
-    assert_eq!(call!(gt_ui32(4294967294, 2119154652)), true);
-    assert_eq!(call!(gt_ui32(4294967294, 3002788344)), true);
-    assert_eq!(call!(gt_ui32(4294967294, 3482297128)), true);
-    assert_eq!(call!(gt_ui32(4294967295, 0)), true);
-    assert_eq!(call!(gt_ui32(4294967295, 1)), true);
-    assert_eq!(call!(gt_ui32(4294967295, 2)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_259() {
-    assert_eq!(call!(gt_ui32(4294967295, 3)), true);
-    assert_eq!(call!(gt_ui32(4294967295, 4)), true);
-    assert_eq!(call!(gt_ui32(4294967295, 2119154652)), true);
-    assert_eq!(call!(gt_ui32(4294967295, 3002788344)), true);
-    assert_eq!(call!(gt_ui32(4294967295, 3482297128)), true);
-    assert_eq!(call!(gt_ui32(4294967295, 4294967294)), true);
-    assert_eq!(call!(gt_ui64(0, 0)), false);
-    assert_eq!(call!(gt_ui64(0, 1)), false);
-    assert_eq!(call!(gt_ui64(0, 2)), false);
-    assert_eq!(call!(gt_ui64(0, 3)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_260() {
-    assert_eq!(call!(gt_ui64(0, 4)), false);
-    assert_eq!(call!(gt_ui64(0, 191084152064409600)), false);
-    assert_eq!(call!(gt_ui64(0, 11015955194427482112)), false);
-    assert_eq!(call!(gt_ui64(0, 16990600415051759616)), false);
-    assert_eq!(call!(gt_ui64(0, 18446744073709551614)), false);
-    assert_eq!(call!(gt_ui64(0, 18446744073709551615)), false);
-    assert_eq!(call!(gt_ui64(1, 1)), false);
-    assert_eq!(call!(gt_ui64(1, 2)), false);
-    assert_eq!(call!(gt_ui64(1, 3)), false);
-    assert_eq!(call!(gt_ui64(1, 4)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_261() {
-    assert_eq!(call!(gt_ui64(1, 191084152064409600)), false);
-    assert_eq!(call!(gt_ui64(1, 11015955194427482112)), false);
-    assert_eq!(call!(gt_ui64(1, 16990600415051759616)), false);
-    assert_eq!(call!(gt_ui64(1, 18446744073709551614)), false);
-    assert_eq!(call!(gt_ui64(1, 18446744073709551615)), false);
-    assert_eq!(call!(gt_ui64(2, 2)), false);
-    assert_eq!(call!(gt_ui64(2, 3)), false);
-    assert_eq!(call!(gt_ui64(2, 4)), false);
-    assert_eq!(call!(gt_ui64(2, 191084152064409600)), false);
-    assert_eq!(call!(gt_ui64(2, 11015955194427482112)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_262() {
-    assert_eq!(call!(gt_ui64(2, 16990600415051759616)), false);
-    assert_eq!(call!(gt_ui64(2, 18446744073709551614)), false);
-    assert_eq!(call!(gt_ui64(2, 18446744073709551615)), false);
-    assert_eq!(call!(gt_ui64(3, 3)), false);
-    assert_eq!(call!(gt_ui64(3, 4)), false);
-    assert_eq!(call!(gt_ui64(3, 191084152064409600)), false);
-    assert_eq!(call!(gt_ui64(3, 11015955194427482112)), false);
-    assert_eq!(call!(gt_ui64(3, 16990600415051759616)), false);
-    assert_eq!(call!(gt_ui64(3, 18446744073709551614)), false);
-    assert_eq!(call!(gt_ui64(3, 18446744073709551615)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_263() {
-    assert_eq!(call!(gt_ui64(4, 4)), false);
-    assert_eq!(call!(gt_ui64(4, 191084152064409600)), false);
-    assert_eq!(call!(gt_ui64(4, 11015955194427482112)), false);
-    assert_eq!(call!(gt_ui64(4, 16990600415051759616)), false);
-    assert_eq!(call!(gt_ui64(4, 18446744073709551614)), false);
-    assert_eq!(call!(gt_ui64(4, 18446744073709551615)), false);
-    assert_eq!(call!(gt_ui64(191084152064409600, 191084152064409600)), false);
-    assert_eq!(call!(gt_ui64(191084152064409600, 11015955194427482112)), false);
-    assert_eq!(call!(gt_ui64(191084152064409600, 16990600415051759616)), false);
-    assert_eq!(call!(gt_ui64(191084152064409600, 18446744073709551614)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_264() {
-    assert_eq!(call!(gt_ui64(191084152064409600, 18446744073709551615)), false);
-    assert_eq!(call!(gt_ui64(11015955194427482112, 11015955194427482112)), false);
-    assert_eq!(call!(gt_ui64(11015955194427482112, 16990600415051759616)), false);
-    assert_eq!(call!(gt_ui64(11015955194427482112, 18446744073709551614)), false);
-    assert_eq!(call!(gt_ui64(11015955194427482112, 18446744073709551615)), false);
-    assert_eq!(call!(gt_ui64(16990600415051759616, 16990600415051759616)), false);
-    assert_eq!(call!(gt_ui64(16990600415051759616, 18446744073709551614)), false);
-    assert_eq!(call!(gt_ui64(16990600415051759616, 18446744073709551615)), false);
-    assert_eq!(call!(gt_ui64(18446744073709551614, 18446744073709551614)), false);
-    assert_eq!(call!(gt_ui64(18446744073709551614, 18446744073709551615)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_265() {
-    assert_eq!(call!(gt_ui64(18446744073709551615, 18446744073709551615)), false);
-    assert_eq!(call!(gt_ui64(1, 0)), true);
-    assert_eq!(call!(gt_ui64(2, 0)), true);
-    assert_eq!(call!(gt_ui64(2, 1)), true);
-    assert_eq!(call!(gt_ui64(3, 0)), true);
-    assert_eq!(call!(gt_ui64(3, 1)), true);
-    assert_eq!(call!(gt_ui64(3, 2)), true);
-    assert_eq!(call!(gt_ui64(4, 0)), true);
-    assert_eq!(call!(gt_ui64(4, 1)), true);
-    assert_eq!(call!(gt_ui64(4, 2)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_266() {
-    assert_eq!(call!(gt_ui64(4, 3)), true);
-    assert_eq!(call!(gt_ui64(191084152064409600, 0)), true);
-    assert_eq!(call!(gt_ui64(191084152064409600, 1)), true);
-    assert_eq!(call!(gt_ui64(191084152064409600, 2)), true);
-    assert_eq!(call!(gt_ui64(191084152064409600, 3)), true);
-    assert_eq!(call!(gt_ui64(191084152064409600, 4)), true);
-    assert_eq!(call!(gt_ui64(11015955194427482112, 0)), true);
-    assert_eq!(call!(gt_ui64(11015955194427482112, 1)), true);
-    assert_eq!(call!(gt_ui64(11015955194427482112, 2)), true);
-    assert_eq!(call!(gt_ui64(11015955194427482112, 3)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_267() {
-    assert_eq!(call!(gt_ui64(11015955194427482112, 4)), true);
-    assert_eq!(call!(gt_ui64(11015955194427482112, 191084152064409600)), true);
-    assert_eq!(call!(gt_ui64(16990600415051759616, 0)), true);
-    assert_eq!(call!(gt_ui64(16990600415051759616, 1)), true);
-    assert_eq!(call!(gt_ui64(16990600415051759616, 2)), true);
-    assert_eq!(call!(gt_ui64(16990600415051759616, 3)), true);
-    assert_eq!(call!(gt_ui64(16990600415051759616, 4)), true);
-    assert_eq!(call!(gt_ui64(16990600415051759616, 191084152064409600)), true);
-    assert_eq!(call!(gt_ui64(16990600415051759616, 11015955194427482112)), true);
-    assert_eq!(call!(gt_ui64(18446744073709551614, 0)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_268() {
-    assert_eq!(call!(gt_ui64(18446744073709551614, 1)), true);
-    assert_eq!(call!(gt_ui64(18446744073709551614, 2)), true);
-    assert_eq!(call!(gt_ui64(18446744073709551614, 3)), true);
-    assert_eq!(call!(gt_ui64(18446744073709551614, 4)), true);
-    assert_eq!(call!(gt_ui64(18446744073709551614, 191084152064409600)), true);
-    assert_eq!(call!(gt_ui64(18446744073709551614, 11015955194427482112)), true);
-    assert_eq!(call!(gt_ui64(18446744073709551614, 16990600415051759616)), true);
-    assert_eq!(call!(gt_ui64(18446744073709551615, 0)), true);
-    assert_eq!(call!(gt_ui64(18446744073709551615, 1)), true);
-    assert_eq!(call!(gt_ui64(18446744073709551615, 2)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_269() {
-    assert_eq!(call!(gt_ui64(18446744073709551615, 3)), true);
-    assert_eq!(call!(gt_ui64(18446744073709551615, 4)), true);
-    assert_eq!(call!(gt_ui64(18446744073709551615, 191084152064409600)), true);
-    assert_eq!(call!(gt_ui64(18446744073709551615, 11015955194427482112)), true);
-    assert_eq!(call!(gt_ui64(18446744073709551615, 16990600415051759616)), true);
-    assert_eq!(call!(gt_ui64(18446744073709551615, 18446744073709551614)), true);
-    assert_eq!(call!(gt_ui8(0, 0)), false);
-    assert_eq!(call!(gt_ui8(0, 1)), false);
-    assert_eq!(call!(gt_ui8(0, 2)), false);
-    assert_eq!(call!(gt_ui8(0, 3)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_270() {
-    assert_eq!(call!(gt_ui8(0, 4)), false);
-    assert_eq!(call!(gt_ui8(0, 72)), false);
-    assert_eq!(call!(gt_ui8(0, 100)), false);
-    assert_eq!(call!(gt_ui8(0, 162)), false);
-    assert_eq!(call!(gt_ui8(0, 254)), false);
-    assert_eq!(call!(gt_ui8(0, 255)), false);
-    assert_eq!(call!(gt_ui8(1, 1)), false);
-    assert_eq!(call!(gt_ui8(1, 2)), false);
-    assert_eq!(call!(gt_ui8(1, 3)), false);
-    assert_eq!(call!(gt_ui8(1, 4)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_271() {
-    assert_eq!(call!(gt_ui8(1, 72)), false);
-    assert_eq!(call!(gt_ui8(1, 100)), false);
-    assert_eq!(call!(gt_ui8(1, 162)), false);
-    assert_eq!(call!(gt_ui8(1, 254)), false);
-    assert_eq!(call!(gt_ui8(1, 255)), false);
-    assert_eq!(call!(gt_ui8(2, 2)), false);
-    assert_eq!(call!(gt_ui8(2, 3)), false);
-    assert_eq!(call!(gt_ui8(2, 4)), false);
-    assert_eq!(call!(gt_ui8(2, 72)), false);
-    assert_eq!(call!(gt_ui8(2, 100)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_272() {
-    assert_eq!(call!(gt_ui8(2, 162)), false);
-    assert_eq!(call!(gt_ui8(2, 254)), false);
-    assert_eq!(call!(gt_ui8(2, 255)), false);
-    assert_eq!(call!(gt_ui8(3, 3)), false);
-    assert_eq!(call!(gt_ui8(3, 4)), false);
-    assert_eq!(call!(gt_ui8(3, 72)), false);
-    assert_eq!(call!(gt_ui8(3, 100)), false);
-    assert_eq!(call!(gt_ui8(3, 162)), false);
-    assert_eq!(call!(gt_ui8(3, 254)), false);
-    assert_eq!(call!(gt_ui8(3, 255)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_273() {
-    assert_eq!(call!(gt_ui8(4, 4)), false);
-    assert_eq!(call!(gt_ui8(4, 72)), false);
-    assert_eq!(call!(gt_ui8(4, 100)), false);
-    assert_eq!(call!(gt_ui8(4, 162)), false);
-    assert_eq!(call!(gt_ui8(4, 254)), false);
-    assert_eq!(call!(gt_ui8(4, 255)), false);
-    assert_eq!(call!(gt_ui8(72, 72)), false);
-    assert_eq!(call!(gt_ui8(72, 100)), false);
-    assert_eq!(call!(gt_ui8(72, 162)), false);
-    assert_eq!(call!(gt_ui8(72, 254)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_274() {
-    assert_eq!(call!(gt_ui8(72, 255)), false);
-    assert_eq!(call!(gt_ui8(100, 100)), false);
-    assert_eq!(call!(gt_ui8(100, 162)), false);
-    assert_eq!(call!(gt_ui8(100, 254)), false);
-    assert_eq!(call!(gt_ui8(100, 255)), false);
-    assert_eq!(call!(gt_ui8(162, 162)), false);
-    assert_eq!(call!(gt_ui8(162, 254)), false);
-    assert_eq!(call!(gt_ui8(162, 255)), false);
-    assert_eq!(call!(gt_ui8(254, 254)), false);
-    assert_eq!(call!(gt_ui8(254, 255)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_275() {
-    assert_eq!(call!(gt_ui8(255, 255)), false);
-    assert_eq!(call!(gt_ui8(1, 0)), true);
-    assert_eq!(call!(gt_ui8(2, 0)), true);
-    assert_eq!(call!(gt_ui8(2, 1)), true);
-    assert_eq!(call!(gt_ui8(3, 0)), true);
-    assert_eq!(call!(gt_ui8(3, 1)), true);
-    assert_eq!(call!(gt_ui8(3, 2)), true);
-    assert_eq!(call!(gt_ui8(4, 0)), true);
-    assert_eq!(call!(gt_ui8(4, 1)), true);
-    assert_eq!(call!(gt_ui8(4, 2)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_276() {
-    assert_eq!(call!(gt_ui8(4, 3)), true);
-    assert_eq!(call!(gt_ui8(72, 0)), true);
-    assert_eq!(call!(gt_ui8(72, 1)), true);
-    assert_eq!(call!(gt_ui8(72, 2)), true);
-    assert_eq!(call!(gt_ui8(72, 3)), true);
-    assert_eq!(call!(gt_ui8(72, 4)), true);
-    assert_eq!(call!(gt_ui8(100, 0)), true);
-    assert_eq!(call!(gt_ui8(100, 1)), true);
-    assert_eq!(call!(gt_ui8(100, 2)), true);
-    assert_eq!(call!(gt_ui8(100, 3)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_277() {
-    assert_eq!(call!(gt_ui8(100, 4)), true);
-    assert_eq!(call!(gt_ui8(100, 72)), true);
-    assert_eq!(call!(gt_ui8(162, 0)), true);
-    assert_eq!(call!(gt_ui8(162, 1)), true);
-    assert_eq!(call!(gt_ui8(162, 2)), true);
-    assert_eq!(call!(gt_ui8(162, 3)), true);
-    assert_eq!(call!(gt_ui8(162, 4)), true);
-    assert_eq!(call!(gt_ui8(162, 72)), true);
-    assert_eq!(call!(gt_ui8(162, 100)), true);
-    assert_eq!(call!(gt_ui8(254, 0)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_278() {
-    assert_eq!(call!(gt_ui8(254, 1)), true);
-    assert_eq!(call!(gt_ui8(254, 2)), true);
-    assert_eq!(call!(gt_ui8(254, 3)), true);
-    assert_eq!(call!(gt_ui8(254, 4)), true);
-    assert_eq!(call!(gt_ui8(254, 72)), true);
-    assert_eq!(call!(gt_ui8(254, 100)), true);
-    assert_eq!(call!(gt_ui8(254, 162)), true);
-    assert_eq!(call!(gt_ui8(255, 0)), true);
-    assert_eq!(call!(gt_ui8(255, 1)), true);
-    assert_eq!(call!(gt_ui8(255, 2)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_279() {
-    assert_eq!(call!(gt_ui8(255, 3)), true);
-    assert_eq!(call!(gt_ui8(255, 4)), true);
-    assert_eq!(call!(gt_ui8(255, 72)), true);
-    assert_eq!(call!(gt_ui8(255, 100)), true);
-    assert_eq!(call!(gt_ui8(255, 162)), true);
-    assert_eq!(call!(gt_ui8(255, 254)), true);
-    assert_eq!(call!(le_si16(-32767, -32768)), false);
-    assert_eq!(call!(le_si16(-32547, -32768)), false);
-    assert_eq!(call!(le_si16(-32547, -32767)), false);
-    assert_eq!(call!(le_si16(0, -32768)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_280() {
-    assert_eq!(call!(le_si16(0, -32767)), false);
-    assert_eq!(call!(le_si16(0, -32547)), false);
-    assert_eq!(call!(le_si16(1, -32768)), false);
-    assert_eq!(call!(le_si16(1, -32767)), false);
-    assert_eq!(call!(le_si16(1, -32547)), false);
-    assert_eq!(call!(le_si16(1, 0)), false);
-    assert_eq!(call!(le_si16(2, -32768)), false);
-    assert_eq!(call!(le_si16(2, -32767)), false);
-    assert_eq!(call!(le_si16(2, -32547)), false);
-    assert_eq!(call!(le_si16(2, 0)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_281() {
-    assert_eq!(call!(le_si16(2, 1)), false);
-    assert_eq!(call!(le_si16(3, -32768)), false);
-    assert_eq!(call!(le_si16(3, -32767)), false);
-    assert_eq!(call!(le_si16(3, -32547)), false);
-    assert_eq!(call!(le_si16(3, 0)), false);
-    assert_eq!(call!(le_si16(3, 1)), false);
-    assert_eq!(call!(le_si16(3, 2)), false);
-    assert_eq!(call!(le_si16(4, -32768)), false);
-    assert_eq!(call!(le_si16(4, -32767)), false);
-    assert_eq!(call!(le_si16(4, -32547)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_282() {
-    assert_eq!(call!(le_si16(4, 0)), false);
-    assert_eq!(call!(le_si16(4, 1)), false);
-    assert_eq!(call!(le_si16(4, 2)), false);
-    assert_eq!(call!(le_si16(4, 3)), false);
-    assert_eq!(call!(le_si16(10486, -32768)), false);
-    assert_eq!(call!(le_si16(10486, -32767)), false);
-    assert_eq!(call!(le_si16(10486, -32547)), false);
-    assert_eq!(call!(le_si16(10486, 0)), false);
-    assert_eq!(call!(le_si16(10486, 1)), false);
-    assert_eq!(call!(le_si16(10486, 2)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_283() {
-    assert_eq!(call!(le_si16(10486, 3)), false);
-    assert_eq!(call!(le_si16(10486, 4)), false);
-    assert_eq!(call!(le_si16(16514, -32768)), false);
-    assert_eq!(call!(le_si16(16514, -32767)), false);
-    assert_eq!(call!(le_si16(16514, -32547)), false);
-    assert_eq!(call!(le_si16(16514, 0)), false);
-    assert_eq!(call!(le_si16(16514, 1)), false);
-    assert_eq!(call!(le_si16(16514, 2)), false);
-    assert_eq!(call!(le_si16(16514, 3)), false);
-    assert_eq!(call!(le_si16(16514, 4)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_284() {
-    assert_eq!(call!(le_si16(16514, 10486)), false);
-    assert_eq!(call!(le_si16(32766, -32768)), false);
-    assert_eq!(call!(le_si16(32766, -32767)), false);
-    assert_eq!(call!(le_si16(32766, -32547)), false);
-    assert_eq!(call!(le_si16(32766, 0)), false);
-    assert_eq!(call!(le_si16(32766, 1)), false);
-    assert_eq!(call!(le_si16(32766, 2)), false);
-    assert_eq!(call!(le_si16(32766, 3)), false);
-    assert_eq!(call!(le_si16(32766, 4)), false);
-    assert_eq!(call!(le_si16(32766, 10486)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_285() {
-    assert_eq!(call!(le_si16(32766, 16514)), false);
-    assert_eq!(call!(le_si16(32767, -32768)), false);
-    assert_eq!(call!(le_si16(32767, -32767)), false);
-    assert_eq!(call!(le_si16(32767, -32547)), false);
-    assert_eq!(call!(le_si16(32767, 0)), false);
-    assert_eq!(call!(le_si16(32767, 1)), false);
-    assert_eq!(call!(le_si16(32767, 2)), false);
-    assert_eq!(call!(le_si16(32767, 3)), false);
-    assert_eq!(call!(le_si16(32767, 4)), false);
-    assert_eq!(call!(le_si16(32767, 10486)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_286() {
-    assert_eq!(call!(le_si16(32767, 16514)), false);
-    assert_eq!(call!(le_si16(32767, 32766)), false);
-    assert_eq!(call!(le_si16(-32768, -32768)), true);
-    assert_eq!(call!(le_si16(-32768, -32767)), true);
-    assert_eq!(call!(le_si16(-32768, -32547)), true);
-    assert_eq!(call!(le_si16(-32768, 0)), true);
-    assert_eq!(call!(le_si16(-32768, 1)), true);
-    assert_eq!(call!(le_si16(-32768, 2)), true);
-    assert_eq!(call!(le_si16(-32768, 3)), true);
-    assert_eq!(call!(le_si16(-32768, 4)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_287() {
-    assert_eq!(call!(le_si16(-32768, 10486)), true);
-    assert_eq!(call!(le_si16(-32768, 16514)), true);
-    assert_eq!(call!(le_si16(-32768, 32766)), true);
-    assert_eq!(call!(le_si16(-32768, 32767)), true);
-    assert_eq!(call!(le_si16(-32767, -32767)), true);
-    assert_eq!(call!(le_si16(-32767, -32547)), true);
-    assert_eq!(call!(le_si16(-32767, 0)), true);
-    assert_eq!(call!(le_si16(-32767, 1)), true);
-    assert_eq!(call!(le_si16(-32767, 2)), true);
-    assert_eq!(call!(le_si16(-32767, 3)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_288() {
-    assert_eq!(call!(le_si16(-32767, 4)), true);
-    assert_eq!(call!(le_si16(-32767, 10486)), true);
-    assert_eq!(call!(le_si16(-32767, 16514)), true);
-    assert_eq!(call!(le_si16(-32767, 32766)), true);
-    assert_eq!(call!(le_si16(-32767, 32767)), true);
-    assert_eq!(call!(le_si16(-32547, -32547)), true);
-    assert_eq!(call!(le_si16(-32547, 0)), true);
-    assert_eq!(call!(le_si16(-32547, 1)), true);
-    assert_eq!(call!(le_si16(-32547, 2)), true);
-    assert_eq!(call!(le_si16(-32547, 3)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_289() {
-    assert_eq!(call!(le_si16(-32547, 4)), true);
-    assert_eq!(call!(le_si16(-32547, 10486)), true);
-    assert_eq!(call!(le_si16(-32547, 16514)), true);
-    assert_eq!(call!(le_si16(-32547, 32766)), true);
-    assert_eq!(call!(le_si16(-32547, 32767)), true);
-    assert_eq!(call!(le_si16(0, 0)), true);
-    assert_eq!(call!(le_si16(0, 1)), true);
-    assert_eq!(call!(le_si16(0, 2)), true);
-    assert_eq!(call!(le_si16(0, 3)), true);
-    assert_eq!(call!(le_si16(0, 4)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_290() {
-    assert_eq!(call!(le_si16(0, 10486)), true);
-    assert_eq!(call!(le_si16(0, 16514)), true);
-    assert_eq!(call!(le_si16(0, 32766)), true);
-    assert_eq!(call!(le_si16(0, 32767)), true);
-    assert_eq!(call!(le_si16(1, 1)), true);
-    assert_eq!(call!(le_si16(1, 2)), true);
-    assert_eq!(call!(le_si16(1, 3)), true);
-    assert_eq!(call!(le_si16(1, 4)), true);
-    assert_eq!(call!(le_si16(1, 10486)), true);
-    assert_eq!(call!(le_si16(1, 16514)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_291() {
-    assert_eq!(call!(le_si16(1, 32766)), true);
-    assert_eq!(call!(le_si16(1, 32767)), true);
-    assert_eq!(call!(le_si16(2, 2)), true);
-    assert_eq!(call!(le_si16(2, 3)), true);
-    assert_eq!(call!(le_si16(2, 4)), true);
-    assert_eq!(call!(le_si16(2, 10486)), true);
-    assert_eq!(call!(le_si16(2, 16514)), true);
-    assert_eq!(call!(le_si16(2, 32766)), true);
-    assert_eq!(call!(le_si16(2, 32767)), true);
-    assert_eq!(call!(le_si16(3, 3)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_292() {
-    assert_eq!(call!(le_si16(3, 4)), true);
-    assert_eq!(call!(le_si16(3, 10486)), true);
-    assert_eq!(call!(le_si16(3, 16514)), true);
-    assert_eq!(call!(le_si16(3, 32766)), true);
-    assert_eq!(call!(le_si16(3, 32767)), true);
-    assert_eq!(call!(le_si16(4, 4)), true);
-    assert_eq!(call!(le_si16(4, 10486)), true);
-    assert_eq!(call!(le_si16(4, 16514)), true);
-    assert_eq!(call!(le_si16(4, 32766)), true);
-    assert_eq!(call!(le_si16(4, 32767)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_293() {
-    assert_eq!(call!(le_si16(10486, 10486)), true);
-    assert_eq!(call!(le_si16(10486, 16514)), true);
-    assert_eq!(call!(le_si16(10486, 32766)), true);
-    assert_eq!(call!(le_si16(10486, 32767)), true);
-    assert_eq!(call!(le_si16(16514, 16514)), true);
-    assert_eq!(call!(le_si16(16514, 32766)), true);
-    assert_eq!(call!(le_si16(16514, 32767)), true);
-    assert_eq!(call!(le_si16(32766, 32766)), true);
-    assert_eq!(call!(le_si16(32766, 32767)), true);
-    assert_eq!(call!(le_si16(32767, 32767)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_294() {
-    assert_eq!(call!(le_si32(-2147483647, -2147483648)), false);
-    assert_eq!(call!(le_si32(-1713183800, -2147483648)), false);
-    assert_eq!(call!(le_si32(-1713183800, -2147483647)), false);
-    assert_eq!(call!(le_si32(-1252582164, -2147483648)), false);
-    assert_eq!(call!(le_si32(-1252582164, -2147483647)), false);
-    assert_eq!(call!(le_si32(-1252582164, -1713183800)), false);
-    assert_eq!(call!(le_si32(-1035405763, -2147483648)), false);
-    assert_eq!(call!(le_si32(-1035405763, -2147483647)), false);
-    assert_eq!(call!(le_si32(-1035405763, -1713183800)), false);
-    assert_eq!(call!(le_si32(-1035405763, -1252582164)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_295() {
-    assert_eq!(call!(le_si32(0, -2147483648)), false);
-    assert_eq!(call!(le_si32(0, -2147483647)), false);
-    assert_eq!(call!(le_si32(0, -1713183800)), false);
-    assert_eq!(call!(le_si32(0, -1252582164)), false);
-    assert_eq!(call!(le_si32(0, -1035405763)), false);
-    assert_eq!(call!(le_si32(1, -2147483648)), false);
-    assert_eq!(call!(le_si32(1, -2147483647)), false);
-    assert_eq!(call!(le_si32(1, -1713183800)), false);
-    assert_eq!(call!(le_si32(1, -1252582164)), false);
-    assert_eq!(call!(le_si32(1, -1035405763)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_296() {
-    assert_eq!(call!(le_si32(1, 0)), false);
-    assert_eq!(call!(le_si32(2, -2147483648)), false);
-    assert_eq!(call!(le_si32(2, -2147483647)), false);
-    assert_eq!(call!(le_si32(2, -1713183800)), false);
-    assert_eq!(call!(le_si32(2, -1252582164)), false);
-    assert_eq!(call!(le_si32(2, -1035405763)), false);
-    assert_eq!(call!(le_si32(2, 0)), false);
-    assert_eq!(call!(le_si32(2, 1)), false);
-    assert_eq!(call!(le_si32(3, -2147483648)), false);
-    assert_eq!(call!(le_si32(3, -2147483647)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_297() {
-    assert_eq!(call!(le_si32(3, -1713183800)), false);
-    assert_eq!(call!(le_si32(3, -1252582164)), false);
-    assert_eq!(call!(le_si32(3, -1035405763)), false);
-    assert_eq!(call!(le_si32(3, 0)), false);
-    assert_eq!(call!(le_si32(3, 1)), false);
-    assert_eq!(call!(le_si32(3, 2)), false);
-    assert_eq!(call!(le_si32(4, -2147483648)), false);
-    assert_eq!(call!(le_si32(4, -2147483647)), false);
-    assert_eq!(call!(le_si32(4, -1713183800)), false);
-    assert_eq!(call!(le_si32(4, -1252582164)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_298() {
-    assert_eq!(call!(le_si32(4, -1035405763)), false);
-    assert_eq!(call!(le_si32(4, 0)), false);
-    assert_eq!(call!(le_si32(4, 1)), false);
-    assert_eq!(call!(le_si32(4, 2)), false);
-    assert_eq!(call!(le_si32(4, 3)), false);
-    assert_eq!(call!(le_si32(2147483646, -2147483648)), false);
-    assert_eq!(call!(le_si32(2147483646, -2147483647)), false);
-    assert_eq!(call!(le_si32(2147483646, -1713183800)), false);
-    assert_eq!(call!(le_si32(2147483646, -1252582164)), false);
-    assert_eq!(call!(le_si32(2147483646, -1035405763)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_299() {
-    assert_eq!(call!(le_si32(2147483646, 0)), false);
-    assert_eq!(call!(le_si32(2147483646, 1)), false);
-    assert_eq!(call!(le_si32(2147483646, 2)), false);
-    assert_eq!(call!(le_si32(2147483646, 3)), false);
-    assert_eq!(call!(le_si32(2147483646, 4)), false);
-    assert_eq!(call!(le_si32(2147483647, -2147483648)), false);
-    assert_eq!(call!(le_si32(2147483647, -2147483647)), false);
-    assert_eq!(call!(le_si32(2147483647, -1713183800)), false);
-    assert_eq!(call!(le_si32(2147483647, -1252582164)), false);
-    assert_eq!(call!(le_si32(2147483647, -1035405763)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_300() {
-    assert_eq!(call!(le_si32(2147483647, 0)), false);
-    assert_eq!(call!(le_si32(2147483647, 1)), false);
-    assert_eq!(call!(le_si32(2147483647, 2)), false);
-    assert_eq!(call!(le_si32(2147483647, 3)), false);
-    assert_eq!(call!(le_si32(2147483647, 4)), false);
-    assert_eq!(call!(le_si32(2147483647, 2147483646)), false);
-    assert_eq!(call!(le_si32(-2147483648, -2147483648)), true);
-    assert_eq!(call!(le_si32(-2147483648, -2147483647)), true);
-    assert_eq!(call!(le_si32(-2147483648, -1713183800)), true);
-    assert_eq!(call!(le_si32(-2147483648, -1252582164)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_301() {
-    assert_eq!(call!(le_si32(-2147483648, -1035405763)), true);
-    assert_eq!(call!(le_si32(-2147483648, 0)), true);
-    assert_eq!(call!(le_si32(-2147483648, 1)), true);
-    assert_eq!(call!(le_si32(-2147483648, 2)), true);
-    assert_eq!(call!(le_si32(-2147483648, 3)), true);
-    assert_eq!(call!(le_si32(-2147483648, 4)), true);
-    assert_eq!(call!(le_si32(-2147483648, 2147483646)), true);
-    assert_eq!(call!(le_si32(-2147483648, 2147483647)), true);
-    assert_eq!(call!(le_si32(-2147483647, -2147483647)), true);
-    assert_eq!(call!(le_si32(-2147483647, -1713183800)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_302() {
-    assert_eq!(call!(le_si32(-2147483647, -1252582164)), true);
-    assert_eq!(call!(le_si32(-2147483647, -1035405763)), true);
-    assert_eq!(call!(le_si32(-2147483647, 0)), true);
-    assert_eq!(call!(le_si32(-2147483647, 1)), true);
-    assert_eq!(call!(le_si32(-2147483647, 2)), true);
-    assert_eq!(call!(le_si32(-2147483647, 3)), true);
-    assert_eq!(call!(le_si32(-2147483647, 4)), true);
-    assert_eq!(call!(le_si32(-2147483647, 2147483646)), true);
-    assert_eq!(call!(le_si32(-2147483647, 2147483647)), true);
-    assert_eq!(call!(le_si32(-1713183800, -1713183800)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_303() {
-    assert_eq!(call!(le_si32(-1713183800, -1252582164)), true);
-    assert_eq!(call!(le_si32(-1713183800, -1035405763)), true);
-    assert_eq!(call!(le_si32(-1713183800, 0)), true);
-    assert_eq!(call!(le_si32(-1713183800, 1)), true);
-    assert_eq!(call!(le_si32(-1713183800, 2)), true);
-    assert_eq!(call!(le_si32(-1713183800, 3)), true);
-    assert_eq!(call!(le_si32(-1713183800, 4)), true);
-    assert_eq!(call!(le_si32(-1713183800, 2147483646)), true);
-    assert_eq!(call!(le_si32(-1713183800, 2147483647)), true);
-    assert_eq!(call!(le_si32(-1252582164, -1252582164)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_304() {
-    assert_eq!(call!(le_si32(-1252582164, -1035405763)), true);
-    assert_eq!(call!(le_si32(-1252582164, 0)), true);
-    assert_eq!(call!(le_si32(-1252582164, 1)), true);
-    assert_eq!(call!(le_si32(-1252582164, 2)), true);
-    assert_eq!(call!(le_si32(-1252582164, 3)), true);
-    assert_eq!(call!(le_si32(-1252582164, 4)), true);
-    assert_eq!(call!(le_si32(-1252582164, 2147483646)), true);
-    assert_eq!(call!(le_si32(-1252582164, 2147483647)), true);
-    assert_eq!(call!(le_si32(-1035405763, -1035405763)), true);
-    assert_eq!(call!(le_si32(-1035405763, 0)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_305() {
-    assert_eq!(call!(le_si32(-1035405763, 1)), true);
-    assert_eq!(call!(le_si32(-1035405763, 2)), true);
-    assert_eq!(call!(le_si32(-1035405763, 3)), true);
-    assert_eq!(call!(le_si32(-1035405763, 4)), true);
-    assert_eq!(call!(le_si32(-1035405763, 2147483646)), true);
-    assert_eq!(call!(le_si32(-1035405763, 2147483647)), true);
-    assert_eq!(call!(le_si32(0, 0)), true);
-    assert_eq!(call!(le_si32(0, 1)), true);
-    assert_eq!(call!(le_si32(0, 2)), true);
-    assert_eq!(call!(le_si32(0, 3)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_306() {
-    assert_eq!(call!(le_si32(0, 4)), true);
-    assert_eq!(call!(le_si32(0, 2147483646)), true);
-    assert_eq!(call!(le_si32(0, 2147483647)), true);
-    assert_eq!(call!(le_si32(1, 1)), true);
-    assert_eq!(call!(le_si32(1, 2)), true);
-    assert_eq!(call!(le_si32(1, 3)), true);
-    assert_eq!(call!(le_si32(1, 4)), true);
-    assert_eq!(call!(le_si32(1, 2147483646)), true);
-    assert_eq!(call!(le_si32(1, 2147483647)), true);
-    assert_eq!(call!(le_si32(2, 2)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_307() {
-    assert_eq!(call!(le_si32(2, 3)), true);
-    assert_eq!(call!(le_si32(2, 4)), true);
-    assert_eq!(call!(le_si32(2, 2147483646)), true);
-    assert_eq!(call!(le_si32(2, 2147483647)), true);
-    assert_eq!(call!(le_si32(3, 3)), true);
-    assert_eq!(call!(le_si32(3, 4)), true);
-    assert_eq!(call!(le_si32(3, 2147483646)), true);
-    assert_eq!(call!(le_si32(3, 2147483647)), true);
-    assert_eq!(call!(le_si32(4, 4)), true);
-    assert_eq!(call!(le_si32(4, 2147483646)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_308() {
-    assert_eq!(call!(le_si32(4, 2147483647)), true);
-    assert_eq!(call!(le_si32(2147483646, 2147483646)), true);
-    assert_eq!(call!(le_si32(2147483646, 2147483647)), true);
-    assert_eq!(call!(le_si32(2147483647, 2147483647)), true);
-    assert_eq!(call!(le_si64(-9223372036854775807, -9223372036854775808)), false);
-    assert_eq!(call!(le_si64(-1741927215160008704, -9223372036854775808)), false);
-    assert_eq!(call!(le_si64(-1741927215160008704, -9223372036854775807)), false);
-    assert_eq!(call!(le_si64(-1328271339354574848, -9223372036854775808)), false);
-    assert_eq!(call!(le_si64(-1328271339354574848, -9223372036854775807)), false);
-    assert_eq!(call!(le_si64(-1328271339354574848, -1741927215160008704)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_309() {
-    assert_eq!(call!(le_si64(0, -9223372036854775808)), false);
-    assert_eq!(call!(le_si64(0, -9223372036854775807)), false);
-    assert_eq!(call!(le_si64(0, -1741927215160008704)), false);
-    assert_eq!(call!(le_si64(0, -1328271339354574848)), false);
-    assert_eq!(call!(le_si64(1, -9223372036854775808)), false);
-    assert_eq!(call!(le_si64(1, -9223372036854775807)), false);
-    assert_eq!(call!(le_si64(1, -1741927215160008704)), false);
-    assert_eq!(call!(le_si64(1, -1328271339354574848)), false);
-    assert_eq!(call!(le_si64(1, 0)), false);
-    assert_eq!(call!(le_si64(2, -9223372036854775808)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_310() {
-    assert_eq!(call!(le_si64(2, -9223372036854775807)), false);
-    assert_eq!(call!(le_si64(2, -1741927215160008704)), false);
-    assert_eq!(call!(le_si64(2, -1328271339354574848)), false);
-    assert_eq!(call!(le_si64(2, 0)), false);
-    assert_eq!(call!(le_si64(2, 1)), false);
-    assert_eq!(call!(le_si64(3, -9223372036854775808)), false);
-    assert_eq!(call!(le_si64(3, -9223372036854775807)), false);
-    assert_eq!(call!(le_si64(3, -1741927215160008704)), false);
-    assert_eq!(call!(le_si64(3, -1328271339354574848)), false);
-    assert_eq!(call!(le_si64(3, 0)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_311() {
-    assert_eq!(call!(le_si64(3, 1)), false);
-    assert_eq!(call!(le_si64(3, 2)), false);
-    assert_eq!(call!(le_si64(4, -9223372036854775808)), false);
-    assert_eq!(call!(le_si64(4, -9223372036854775807)), false);
-    assert_eq!(call!(le_si64(4, -1741927215160008704)), false);
-    assert_eq!(call!(le_si64(4, -1328271339354574848)), false);
-    assert_eq!(call!(le_si64(4, 0)), false);
-    assert_eq!(call!(le_si64(4, 1)), false);
-    assert_eq!(call!(le_si64(4, 2)), false);
-    assert_eq!(call!(le_si64(4, 3)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_312() {
-    assert_eq!(call!(le_si64(5577148965131116544, -9223372036854775808)), false);
-    assert_eq!(call!(le_si64(5577148965131116544, -9223372036854775807)), false);
-    assert_eq!(call!(le_si64(5577148965131116544, -1741927215160008704)), false);
-    assert_eq!(call!(le_si64(5577148965131116544, -1328271339354574848)), false);
-    assert_eq!(call!(le_si64(5577148965131116544, 0)), false);
-    assert_eq!(call!(le_si64(5577148965131116544, 1)), false);
-    assert_eq!(call!(le_si64(5577148965131116544, 2)), false);
-    assert_eq!(call!(le_si64(5577148965131116544, 3)), false);
-    assert_eq!(call!(le_si64(5577148965131116544, 4)), false);
-    assert_eq!(call!(le_si64(9223372036854775806, -9223372036854775808)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_313() {
-    assert_eq!(call!(le_si64(9223372036854775806, -9223372036854775807)), false);
-    assert_eq!(call!(le_si64(9223372036854775806, -1741927215160008704)), false);
-    assert_eq!(call!(le_si64(9223372036854775806, -1328271339354574848)), false);
-    assert_eq!(call!(le_si64(9223372036854775806, 0)), false);
-    assert_eq!(call!(le_si64(9223372036854775806, 1)), false);
-    assert_eq!(call!(le_si64(9223372036854775806, 2)), false);
-    assert_eq!(call!(le_si64(9223372036854775806, 3)), false);
-    assert_eq!(call!(le_si64(9223372036854775806, 4)), false);
-    assert_eq!(call!(le_si64(9223372036854775806, 5577148965131116544)), false);
-    assert_eq!(call!(le_si64(9223372036854775807, -9223372036854775808)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_314() {
-    assert_eq!(call!(le_si64(9223372036854775807, -9223372036854775807)), false);
-    assert_eq!(call!(le_si64(9223372036854775807, -1741927215160008704)), false);
-    assert_eq!(call!(le_si64(9223372036854775807, -1328271339354574848)), false);
-    assert_eq!(call!(le_si64(9223372036854775807, 0)), false);
-    assert_eq!(call!(le_si64(9223372036854775807, 1)), false);
-    assert_eq!(call!(le_si64(9223372036854775807, 2)), false);
-    assert_eq!(call!(le_si64(9223372036854775807, 3)), false);
-    assert_eq!(call!(le_si64(9223372036854775807, 4)), false);
-    assert_eq!(call!(le_si64(9223372036854775807, 5577148965131116544)), false);
-    assert_eq!(call!(le_si64(9223372036854775807, 9223372036854775806)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_315() {
-    assert_eq!(call!(le_si64(-9223372036854775808, -9223372036854775808)), true);
-    assert_eq!(call!(le_si64(-9223372036854775808, -9223372036854775807)), true);
-    assert_eq!(call!(le_si64(-9223372036854775808, -1741927215160008704)), true);
-    assert_eq!(call!(le_si64(-9223372036854775808, -1328271339354574848)), true);
-    assert_eq!(call!(le_si64(-9223372036854775808, 0)), true);
-    assert_eq!(call!(le_si64(-9223372036854775808, 1)), true);
-    assert_eq!(call!(le_si64(-9223372036854775808, 2)), true);
-    assert_eq!(call!(le_si64(-9223372036854775808, 3)), true);
-    assert_eq!(call!(le_si64(-9223372036854775808, 4)), true);
-    assert_eq!(call!(le_si64(-9223372036854775808, 5577148965131116544)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_316() {
-    assert_eq!(call!(le_si64(-9223372036854775808, 9223372036854775806)), true);
-    assert_eq!(call!(le_si64(-9223372036854775808, 9223372036854775807)), true);
-    assert_eq!(call!(le_si64(-9223372036854775807, -9223372036854775807)), true);
-    assert_eq!(call!(le_si64(-9223372036854775807, -1741927215160008704)), true);
-    assert_eq!(call!(le_si64(-9223372036854775807, -1328271339354574848)), true);
-    assert_eq!(call!(le_si64(-9223372036854775807, 0)), true);
-    assert_eq!(call!(le_si64(-9223372036854775807, 1)), true);
-    assert_eq!(call!(le_si64(-9223372036854775807, 2)), true);
-    assert_eq!(call!(le_si64(-9223372036854775807, 3)), true);
-    assert_eq!(call!(le_si64(-9223372036854775807, 4)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_317() {
-    assert_eq!(call!(le_si64(-9223372036854775807, 5577148965131116544)), true);
-    assert_eq!(call!(le_si64(-9223372036854775807, 9223372036854775806)), true);
-    assert_eq!(call!(le_si64(-9223372036854775807, 9223372036854775807)), true);
-    assert_eq!(call!(le_si64(-1741927215160008704, -1741927215160008704)), true);
-    assert_eq!(call!(le_si64(-1741927215160008704, -1328271339354574848)), true);
-    assert_eq!(call!(le_si64(-1741927215160008704, 0)), true);
-    assert_eq!(call!(le_si64(-1741927215160008704, 1)), true);
-    assert_eq!(call!(le_si64(-1741927215160008704, 2)), true);
-    assert_eq!(call!(le_si64(-1741927215160008704, 3)), true);
-    assert_eq!(call!(le_si64(-1741927215160008704, 4)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_318() {
-    assert_eq!(call!(le_si64(-1741927215160008704, 5577148965131116544)), true);
-    assert_eq!(call!(le_si64(-1741927215160008704, 9223372036854775806)), true);
-    assert_eq!(call!(le_si64(-1741927215160008704, 9223372036854775807)), true);
-    assert_eq!(call!(le_si64(-1328271339354574848, -1328271339354574848)), true);
-    assert_eq!(call!(le_si64(-1328271339354574848, 0)), true);
-    assert_eq!(call!(le_si64(-1328271339354574848, 1)), true);
-    assert_eq!(call!(le_si64(-1328271339354574848, 2)), true);
-    assert_eq!(call!(le_si64(-1328271339354574848, 3)), true);
-    assert_eq!(call!(le_si64(-1328271339354574848, 4)), true);
-    assert_eq!(call!(le_si64(-1328271339354574848, 5577148965131116544)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_319() {
-    assert_eq!(call!(le_si64(-1328271339354574848, 9223372036854775806)), true);
-    assert_eq!(call!(le_si64(-1328271339354574848, 9223372036854775807)), true);
-    assert_eq!(call!(le_si64(0, 0)), true);
-    assert_eq!(call!(le_si64(0, 1)), true);
-    assert_eq!(call!(le_si64(0, 2)), true);
-    assert_eq!(call!(le_si64(0, 3)), true);
-    assert_eq!(call!(le_si64(0, 4)), true);
-    assert_eq!(call!(le_si64(0, 5577148965131116544)), true);
-    assert_eq!(call!(le_si64(0, 9223372036854775806)), true);
-    assert_eq!(call!(le_si64(0, 9223372036854775807)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_320() {
-    assert_eq!(call!(le_si64(1, 1)), true);
-    assert_eq!(call!(le_si64(1, 2)), true);
-    assert_eq!(call!(le_si64(1, 3)), true);
-    assert_eq!(call!(le_si64(1, 4)), true);
-    assert_eq!(call!(le_si64(1, 5577148965131116544)), true);
-    assert_eq!(call!(le_si64(1, 9223372036854775806)), true);
-    assert_eq!(call!(le_si64(1, 9223372036854775807)), true);
-    assert_eq!(call!(le_si64(2, 2)), true);
-    assert_eq!(call!(le_si64(2, 3)), true);
-    assert_eq!(call!(le_si64(2, 4)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_321() {
-    assert_eq!(call!(le_si64(2, 5577148965131116544)), true);
-    assert_eq!(call!(le_si64(2, 9223372036854775806)), true);
-    assert_eq!(call!(le_si64(2, 9223372036854775807)), true);
-    assert_eq!(call!(le_si64(3, 3)), true);
-    assert_eq!(call!(le_si64(3, 4)), true);
-    assert_eq!(call!(le_si64(3, 5577148965131116544)), true);
-    assert_eq!(call!(le_si64(3, 9223372036854775806)), true);
-    assert_eq!(call!(le_si64(3, 9223372036854775807)), true);
-    assert_eq!(call!(le_si64(4, 4)), true);
-    assert_eq!(call!(le_si64(4, 5577148965131116544)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_322() {
-    assert_eq!(call!(le_si64(4, 9223372036854775806)), true);
-    assert_eq!(call!(le_si64(4, 9223372036854775807)), true);
-    assert_eq!(call!(le_si64(5577148965131116544, 5577148965131116544)), true);
-    assert_eq!(call!(le_si64(5577148965131116544, 9223372036854775806)), true);
-    assert_eq!(call!(le_si64(5577148965131116544, 9223372036854775807)), true);
-    assert_eq!(call!(le_si64(9223372036854775806, 9223372036854775806)), true);
-    assert_eq!(call!(le_si64(9223372036854775806, 9223372036854775807)), true);
-    assert_eq!(call!(le_si64(9223372036854775807, 9223372036854775807)), true);
-    assert_eq!(call!(le_si8(-127, -128)), false);
-    assert_eq!(call!(le_si8(0, -128)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_323() {
-    assert_eq!(call!(le_si8(0, -127)), false);
-    assert_eq!(call!(le_si8(1, -128)), false);
-    assert_eq!(call!(le_si8(1, -127)), false);
-    assert_eq!(call!(le_si8(1, 0)), false);
-    assert_eq!(call!(le_si8(2, -128)), false);
-    assert_eq!(call!(le_si8(2, -127)), false);
-    assert_eq!(call!(le_si8(2, 0)), false);
-    assert_eq!(call!(le_si8(2, 1)), false);
-    assert_eq!(call!(le_si8(3, -128)), false);
-    assert_eq!(call!(le_si8(3, -127)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_324() {
-    assert_eq!(call!(le_si8(3, 0)), false);
-    assert_eq!(call!(le_si8(3, 1)), false);
-    assert_eq!(call!(le_si8(3, 2)), false);
-    assert_eq!(call!(le_si8(4, -128)), false);
-    assert_eq!(call!(le_si8(4, -127)), false);
-    assert_eq!(call!(le_si8(4, 0)), false);
-    assert_eq!(call!(le_si8(4, 1)), false);
-    assert_eq!(call!(le_si8(4, 2)), false);
-    assert_eq!(call!(le_si8(4, 3)), false);
-    assert_eq!(call!(le_si8(16, -128)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_325() {
-    assert_eq!(call!(le_si8(16, -127)), false);
-    assert_eq!(call!(le_si8(16, 0)), false);
-    assert_eq!(call!(le_si8(16, 1)), false);
-    assert_eq!(call!(le_si8(16, 2)), false);
-    assert_eq!(call!(le_si8(16, 3)), false);
-    assert_eq!(call!(le_si8(16, 4)), false);
-    assert_eq!(call!(le_si8(126, -128)), false);
-    assert_eq!(call!(le_si8(126, -127)), false);
-    assert_eq!(call!(le_si8(126, 0)), false);
-    assert_eq!(call!(le_si8(126, 1)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_326() {
-    assert_eq!(call!(le_si8(126, 2)), false);
-    assert_eq!(call!(le_si8(126, 3)), false);
-    assert_eq!(call!(le_si8(126, 4)), false);
-    assert_eq!(call!(le_si8(126, 16)), false);
-    assert_eq!(call!(le_si8(127, -128)), false);
-    assert_eq!(call!(le_si8(127, -127)), false);
-    assert_eq!(call!(le_si8(127, 0)), false);
-    assert_eq!(call!(le_si8(127, 1)), false);
-    assert_eq!(call!(le_si8(127, 2)), false);
-    assert_eq!(call!(le_si8(127, 3)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_327() {
-    assert_eq!(call!(le_si8(127, 4)), false);
-    assert_eq!(call!(le_si8(127, 16)), false);
-    assert_eq!(call!(le_si8(127, 126)), false);
-    assert_eq!(call!(le_si8(-128, -128)), true);
-    assert_eq!(call!(le_si8(-128, -127)), true);
-    assert_eq!(call!(le_si8(-128, 0)), true);
-    assert_eq!(call!(le_si8(-128, 1)), true);
-    assert_eq!(call!(le_si8(-128, 2)), true);
-    assert_eq!(call!(le_si8(-128, 3)), true);
-    assert_eq!(call!(le_si8(-128, 4)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_328() {
-    assert_eq!(call!(le_si8(-128, 16)), true);
-    assert_eq!(call!(le_si8(-128, 126)), true);
-    assert_eq!(call!(le_si8(-128, 127)), true);
-    assert_eq!(call!(le_si8(-127, -127)), true);
-    assert_eq!(call!(le_si8(-127, 0)), true);
-    assert_eq!(call!(le_si8(-127, 1)), true);
-    assert_eq!(call!(le_si8(-127, 2)), true);
-    assert_eq!(call!(le_si8(-127, 3)), true);
-    assert_eq!(call!(le_si8(-127, 4)), true);
-    assert_eq!(call!(le_si8(-127, 16)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_329() {
-    assert_eq!(call!(le_si8(-127, 126)), true);
-    assert_eq!(call!(le_si8(-127, 127)), true);
-    assert_eq!(call!(le_si8(0, 0)), true);
-    assert_eq!(call!(le_si8(0, 1)), true);
-    assert_eq!(call!(le_si8(0, 2)), true);
-    assert_eq!(call!(le_si8(0, 3)), true);
-    assert_eq!(call!(le_si8(0, 4)), true);
-    assert_eq!(call!(le_si8(0, 16)), true);
-    assert_eq!(call!(le_si8(0, 126)), true);
-    assert_eq!(call!(le_si8(0, 127)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_330() {
-    assert_eq!(call!(le_si8(1, 1)), true);
-    assert_eq!(call!(le_si8(1, 2)), true);
-    assert_eq!(call!(le_si8(1, 3)), true);
-    assert_eq!(call!(le_si8(1, 4)), true);
-    assert_eq!(call!(le_si8(1, 16)), true);
-    assert_eq!(call!(le_si8(1, 126)), true);
-    assert_eq!(call!(le_si8(1, 127)), true);
-    assert_eq!(call!(le_si8(2, 2)), true);
-    assert_eq!(call!(le_si8(2, 3)), true);
-    assert_eq!(call!(le_si8(2, 4)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_331() {
-    assert_eq!(call!(le_si8(2, 16)), true);
-    assert_eq!(call!(le_si8(2, 126)), true);
-    assert_eq!(call!(le_si8(2, 127)), true);
-    assert_eq!(call!(le_si8(3, 3)), true);
-    assert_eq!(call!(le_si8(3, 4)), true);
-    assert_eq!(call!(le_si8(3, 16)), true);
-    assert_eq!(call!(le_si8(3, 126)), true);
-    assert_eq!(call!(le_si8(3, 127)), true);
-    assert_eq!(call!(le_si8(4, 4)), true);
-    assert_eq!(call!(le_si8(4, 16)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_332() {
-    assert_eq!(call!(le_si8(4, 126)), true);
-    assert_eq!(call!(le_si8(4, 127)), true);
-    assert_eq!(call!(le_si8(16, 16)), true);
-    assert_eq!(call!(le_si8(16, 126)), true);
-    assert_eq!(call!(le_si8(16, 127)), true);
-    assert_eq!(call!(le_si8(126, 126)), true);
-    assert_eq!(call!(le_si8(126, 127)), true);
-    assert_eq!(call!(le_si8(127, 127)), true);
-    assert_eq!(call!(le_ui16(1, 0)), false);
-    assert_eq!(call!(le_ui16(2, 0)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_333() {
-    assert_eq!(call!(le_ui16(2, 1)), false);
-    assert_eq!(call!(le_ui16(3, 0)), false);
-    assert_eq!(call!(le_ui16(3, 1)), false);
-    assert_eq!(call!(le_ui16(3, 2)), false);
-    assert_eq!(call!(le_ui16(4, 0)), false);
-    assert_eq!(call!(le_ui16(4, 1)), false);
-    assert_eq!(call!(le_ui16(4, 2)), false);
-    assert_eq!(call!(le_ui16(4, 3)), false);
-    assert_eq!(call!(le_ui16(1717, 0)), false);
-    assert_eq!(call!(le_ui16(1717, 1)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_334() {
-    assert_eq!(call!(le_ui16(1717, 2)), false);
-    assert_eq!(call!(le_ui16(1717, 3)), false);
-    assert_eq!(call!(le_ui16(1717, 4)), false);
-    assert_eq!(call!(le_ui16(17988, 0)), false);
-    assert_eq!(call!(le_ui16(17988, 1)), false);
-    assert_eq!(call!(le_ui16(17988, 2)), false);
-    assert_eq!(call!(le_ui16(17988, 3)), false);
-    assert_eq!(call!(le_ui16(17988, 4)), false);
-    assert_eq!(call!(le_ui16(17988, 1717)), false);
-    assert_eq!(call!(le_ui16(65096, 0)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_335() {
-    assert_eq!(call!(le_ui16(65096, 1)), false);
-    assert_eq!(call!(le_ui16(65096, 2)), false);
-    assert_eq!(call!(le_ui16(65096, 3)), false);
-    assert_eq!(call!(le_ui16(65096, 4)), false);
-    assert_eq!(call!(le_ui16(65096, 1717)), false);
-    assert_eq!(call!(le_ui16(65096, 17988)), false);
-    assert_eq!(call!(le_ui16(65534, 0)), false);
-    assert_eq!(call!(le_ui16(65534, 1)), false);
-    assert_eq!(call!(le_ui16(65534, 2)), false);
-    assert_eq!(call!(le_ui16(65534, 3)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_336() {
-    assert_eq!(call!(le_ui16(65534, 4)), false);
-    assert_eq!(call!(le_ui16(65534, 1717)), false);
-    assert_eq!(call!(le_ui16(65534, 17988)), false);
-    assert_eq!(call!(le_ui16(65534, 65096)), false);
-    assert_eq!(call!(le_ui16(65535, 0)), false);
-    assert_eq!(call!(le_ui16(65535, 1)), false);
-    assert_eq!(call!(le_ui16(65535, 2)), false);
-    assert_eq!(call!(le_ui16(65535, 3)), false);
-    assert_eq!(call!(le_ui16(65535, 4)), false);
-    assert_eq!(call!(le_ui16(65535, 1717)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_337() {
-    assert_eq!(call!(le_ui16(65535, 17988)), false);
-    assert_eq!(call!(le_ui16(65535, 65096)), false);
-    assert_eq!(call!(le_ui16(65535, 65534)), false);
-    assert_eq!(call!(le_ui16(0, 0)), true);
-    assert_eq!(call!(le_ui16(0, 1)), true);
-    assert_eq!(call!(le_ui16(0, 2)), true);
-    assert_eq!(call!(le_ui16(0, 3)), true);
-    assert_eq!(call!(le_ui16(0, 4)), true);
-    assert_eq!(call!(le_ui16(0, 1717)), true);
-    assert_eq!(call!(le_ui16(0, 17988)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_338() {
-    assert_eq!(call!(le_ui16(0, 65096)), true);
-    assert_eq!(call!(le_ui16(0, 65534)), true);
-    assert_eq!(call!(le_ui16(0, 65535)), true);
-    assert_eq!(call!(le_ui16(1, 1)), true);
-    assert_eq!(call!(le_ui16(1, 2)), true);
-    assert_eq!(call!(le_ui16(1, 3)), true);
-    assert_eq!(call!(le_ui16(1, 4)), true);
-    assert_eq!(call!(le_ui16(1, 1717)), true);
-    assert_eq!(call!(le_ui16(1, 17988)), true);
-    assert_eq!(call!(le_ui16(1, 65096)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_339() {
-    assert_eq!(call!(le_ui16(1, 65534)), true);
-    assert_eq!(call!(le_ui16(1, 65535)), true);
-    assert_eq!(call!(le_ui16(2, 2)), true);
-    assert_eq!(call!(le_ui16(2, 3)), true);
-    assert_eq!(call!(le_ui16(2, 4)), true);
-    assert_eq!(call!(le_ui16(2, 1717)), true);
-    assert_eq!(call!(le_ui16(2, 17988)), true);
-    assert_eq!(call!(le_ui16(2, 65096)), true);
-    assert_eq!(call!(le_ui16(2, 65534)), true);
-    assert_eq!(call!(le_ui16(2, 65535)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_340() {
-    assert_eq!(call!(le_ui16(3, 3)), true);
-    assert_eq!(call!(le_ui16(3, 4)), true);
-    assert_eq!(call!(le_ui16(3, 1717)), true);
-    assert_eq!(call!(le_ui16(3, 17988)), true);
-    assert_eq!(call!(le_ui16(3, 65096)), true);
-    assert_eq!(call!(le_ui16(3, 65534)), true);
-    assert_eq!(call!(le_ui16(3, 65535)), true);
-    assert_eq!(call!(le_ui16(4, 4)), true);
-    assert_eq!(call!(le_ui16(4, 1717)), true);
-    assert_eq!(call!(le_ui16(4, 17988)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_341() {
-    assert_eq!(call!(le_ui16(4, 65096)), true);
-    assert_eq!(call!(le_ui16(4, 65534)), true);
-    assert_eq!(call!(le_ui16(4, 65535)), true);
-    assert_eq!(call!(le_ui16(1717, 1717)), true);
-    assert_eq!(call!(le_ui16(1717, 17988)), true);
-    assert_eq!(call!(le_ui16(1717, 65096)), true);
-    assert_eq!(call!(le_ui16(1717, 65534)), true);
-    assert_eq!(call!(le_ui16(1717, 65535)), true);
-    assert_eq!(call!(le_ui16(17988, 17988)), true);
-    assert_eq!(call!(le_ui16(17988, 65096)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_342() {
-    assert_eq!(call!(le_ui16(17988, 65534)), true);
-    assert_eq!(call!(le_ui16(17988, 65535)), true);
-    assert_eq!(call!(le_ui16(65096, 65096)), true);
-    assert_eq!(call!(le_ui16(65096, 65534)), true);
-    assert_eq!(call!(le_ui16(65096, 65535)), true);
-    assert_eq!(call!(le_ui16(65534, 65534)), true);
-    assert_eq!(call!(le_ui16(65534, 65535)), true);
-    assert_eq!(call!(le_ui16(65535, 65535)), true);
-    assert_eq!(call!(le_ui32(1, 0)), false);
-    assert_eq!(call!(le_ui32(2, 0)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_343() {
-    assert_eq!(call!(le_ui32(2, 1)), false);
-    assert_eq!(call!(le_ui32(3, 0)), false);
-    assert_eq!(call!(le_ui32(3, 1)), false);
-    assert_eq!(call!(le_ui32(3, 2)), false);
-    assert_eq!(call!(le_ui32(4, 0)), false);
-    assert_eq!(call!(le_ui32(4, 1)), false);
-    assert_eq!(call!(le_ui32(4, 2)), false);
-    assert_eq!(call!(le_ui32(4, 3)), false);
-    assert_eq!(call!(le_ui32(2119154652, 0)), false);
-    assert_eq!(call!(le_ui32(2119154652, 1)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_344() {
-    assert_eq!(call!(le_ui32(2119154652, 2)), false);
-    assert_eq!(call!(le_ui32(2119154652, 3)), false);
-    assert_eq!(call!(le_ui32(2119154652, 4)), false);
-    assert_eq!(call!(le_ui32(3002788344, 0)), false);
-    assert_eq!(call!(le_ui32(3002788344, 1)), false);
-    assert_eq!(call!(le_ui32(3002788344, 2)), false);
-    assert_eq!(call!(le_ui32(3002788344, 3)), false);
-    assert_eq!(call!(le_ui32(3002788344, 4)), false);
-    assert_eq!(call!(le_ui32(3002788344, 2119154652)), false);
-    assert_eq!(call!(le_ui32(3482297128, 0)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_345() {
-    assert_eq!(call!(le_ui32(3482297128, 1)), false);
-    assert_eq!(call!(le_ui32(3482297128, 2)), false);
-    assert_eq!(call!(le_ui32(3482297128, 3)), false);
-    assert_eq!(call!(le_ui32(3482297128, 4)), false);
-    assert_eq!(call!(le_ui32(3482297128, 2119154652)), false);
-    assert_eq!(call!(le_ui32(3482297128, 3002788344)), false);
-    assert_eq!(call!(le_ui32(4294967294, 0)), false);
-    assert_eq!(call!(le_ui32(4294967294, 1)), false);
-    assert_eq!(call!(le_ui32(4294967294, 2)), false);
-    assert_eq!(call!(le_ui32(4294967294, 3)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_346() {
-    assert_eq!(call!(le_ui32(4294967294, 4)), false);
-    assert_eq!(call!(le_ui32(4294967294, 2119154652)), false);
-    assert_eq!(call!(le_ui32(4294967294, 3002788344)), false);
-    assert_eq!(call!(le_ui32(4294967294, 3482297128)), false);
-    assert_eq!(call!(le_ui32(4294967295, 0)), false);
-    assert_eq!(call!(le_ui32(4294967295, 1)), false);
-    assert_eq!(call!(le_ui32(4294967295, 2)), false);
-    assert_eq!(call!(le_ui32(4294967295, 3)), false);
-    assert_eq!(call!(le_ui32(4294967295, 4)), false);
-    assert_eq!(call!(le_ui32(4294967295, 2119154652)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_347() {
-    assert_eq!(call!(le_ui32(4294967295, 3002788344)), false);
-    assert_eq!(call!(le_ui32(4294967295, 3482297128)), false);
-    assert_eq!(call!(le_ui32(4294967295, 4294967294)), false);
-    assert_eq!(call!(le_ui32(0, 0)), true);
-    assert_eq!(call!(le_ui32(0, 1)), true);
-    assert_eq!(call!(le_ui32(0, 2)), true);
-    assert_eq!(call!(le_ui32(0, 3)), true);
-    assert_eq!(call!(le_ui32(0, 4)), true);
-    assert_eq!(call!(le_ui32(0, 2119154652)), true);
-    assert_eq!(call!(le_ui32(0, 3002788344)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_348() {
-    assert_eq!(call!(le_ui32(0, 3482297128)), true);
-    assert_eq!(call!(le_ui32(0, 4294967294)), true);
-    assert_eq!(call!(le_ui32(0, 4294967295)), true);
-    assert_eq!(call!(le_ui32(1, 1)), true);
-    assert_eq!(call!(le_ui32(1, 2)), true);
-    assert_eq!(call!(le_ui32(1, 3)), true);
-    assert_eq!(call!(le_ui32(1, 4)), true);
-    assert_eq!(call!(le_ui32(1, 2119154652)), true);
-    assert_eq!(call!(le_ui32(1, 3002788344)), true);
-    assert_eq!(call!(le_ui32(1, 3482297128)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_349() {
-    assert_eq!(call!(le_ui32(1, 4294967294)), true);
-    assert_eq!(call!(le_ui32(1, 4294967295)), true);
-    assert_eq!(call!(le_ui32(2, 2)), true);
-    assert_eq!(call!(le_ui32(2, 3)), true);
-    assert_eq!(call!(le_ui32(2, 4)), true);
-    assert_eq!(call!(le_ui32(2, 2119154652)), true);
-    assert_eq!(call!(le_ui32(2, 3002788344)), true);
-    assert_eq!(call!(le_ui32(2, 3482297128)), true);
-    assert_eq!(call!(le_ui32(2, 4294967294)), true);
-    assert_eq!(call!(le_ui32(2, 4294967295)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_350() {
-    assert_eq!(call!(le_ui32(3, 3)), true);
-    assert_eq!(call!(le_ui32(3, 4)), true);
-    assert_eq!(call!(le_ui32(3, 2119154652)), true);
-    assert_eq!(call!(le_ui32(3, 3002788344)), true);
-    assert_eq!(call!(le_ui32(3, 3482297128)), true);
-    assert_eq!(call!(le_ui32(3, 4294967294)), true);
-    assert_eq!(call!(le_ui32(3, 4294967295)), true);
-    assert_eq!(call!(le_ui32(4, 4)), true);
-    assert_eq!(call!(le_ui32(4, 2119154652)), true);
-    assert_eq!(call!(le_ui32(4, 3002788344)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_351() {
-    assert_eq!(call!(le_ui32(4, 3482297128)), true);
-    assert_eq!(call!(le_ui32(4, 4294967294)), true);
-    assert_eq!(call!(le_ui32(4, 4294967295)), true);
-    assert_eq!(call!(le_ui32(2119154652, 2119154652)), true);
-    assert_eq!(call!(le_ui32(2119154652, 3002788344)), true);
-    assert_eq!(call!(le_ui32(2119154652, 3482297128)), true);
-    assert_eq!(call!(le_ui32(2119154652, 4294967294)), true);
-    assert_eq!(call!(le_ui32(2119154652, 4294967295)), true);
-    assert_eq!(call!(le_ui32(3002788344, 3002788344)), true);
-    assert_eq!(call!(le_ui32(3002788344, 3482297128)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_352() {
-    assert_eq!(call!(le_ui32(3002788344, 4294967294)), true);
-    assert_eq!(call!(le_ui32(3002788344, 4294967295)), true);
-    assert_eq!(call!(le_ui32(3482297128, 3482297128)), true);
-    assert_eq!(call!(le_ui32(3482297128, 4294967294)), true);
-    assert_eq!(call!(le_ui32(3482297128, 4294967295)), true);
-    assert_eq!(call!(le_ui32(4294967294, 4294967294)), true);
-    assert_eq!(call!(le_ui32(4294967294, 4294967295)), true);
-    assert_eq!(call!(le_ui32(4294967295, 4294967295)), true);
-    assert_eq!(call!(le_ui64(1, 0)), false);
-    assert_eq!(call!(le_ui64(2, 0)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_353() {
-    assert_eq!(call!(le_ui64(2, 1)), false);
-    assert_eq!(call!(le_ui64(3, 0)), false);
-    assert_eq!(call!(le_ui64(3, 1)), false);
-    assert_eq!(call!(le_ui64(3, 2)), false);
-    assert_eq!(call!(le_ui64(4, 0)), false);
-    assert_eq!(call!(le_ui64(4, 1)), false);
-    assert_eq!(call!(le_ui64(4, 2)), false);
-    assert_eq!(call!(le_ui64(4, 3)), false);
-    assert_eq!(call!(le_ui64(191084152064409600, 0)), false);
-    assert_eq!(call!(le_ui64(191084152064409600, 1)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_354() {
-    assert_eq!(call!(le_ui64(191084152064409600, 2)), false);
-    assert_eq!(call!(le_ui64(191084152064409600, 3)), false);
-    assert_eq!(call!(le_ui64(191084152064409600, 4)), false);
-    assert_eq!(call!(le_ui64(11015955194427482112, 0)), false);
-    assert_eq!(call!(le_ui64(11015955194427482112, 1)), false);
-    assert_eq!(call!(le_ui64(11015955194427482112, 2)), false);
-    assert_eq!(call!(le_ui64(11015955194427482112, 3)), false);
-    assert_eq!(call!(le_ui64(11015955194427482112, 4)), false);
-    assert_eq!(call!(le_ui64(11015955194427482112, 191084152064409600)), false);
-    assert_eq!(call!(le_ui64(16990600415051759616, 0)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_355() {
-    assert_eq!(call!(le_ui64(16990600415051759616, 1)), false);
-    assert_eq!(call!(le_ui64(16990600415051759616, 2)), false);
-    assert_eq!(call!(le_ui64(16990600415051759616, 3)), false);
-    assert_eq!(call!(le_ui64(16990600415051759616, 4)), false);
-    assert_eq!(call!(le_ui64(16990600415051759616, 191084152064409600)), false);
-    assert_eq!(call!(le_ui64(16990600415051759616, 11015955194427482112)), false);
-    assert_eq!(call!(le_ui64(18446744073709551614, 0)), false);
-    assert_eq!(call!(le_ui64(18446744073709551614, 1)), false);
-    assert_eq!(call!(le_ui64(18446744073709551614, 2)), false);
-    assert_eq!(call!(le_ui64(18446744073709551614, 3)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_356() {
-    assert_eq!(call!(le_ui64(18446744073709551614, 4)), false);
-    assert_eq!(call!(le_ui64(18446744073709551614, 191084152064409600)), false);
-    assert_eq!(call!(le_ui64(18446744073709551614, 11015955194427482112)), false);
-    assert_eq!(call!(le_ui64(18446744073709551614, 16990600415051759616)), false);
-    assert_eq!(call!(le_ui64(18446744073709551615, 0)), false);
-    assert_eq!(call!(le_ui64(18446744073709551615, 1)), false);
-    assert_eq!(call!(le_ui64(18446744073709551615, 2)), false);
-    assert_eq!(call!(le_ui64(18446744073709551615, 3)), false);
-    assert_eq!(call!(le_ui64(18446744073709551615, 4)), false);
-    assert_eq!(call!(le_ui64(18446744073709551615, 191084152064409600)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_357() {
-    assert_eq!(call!(le_ui64(18446744073709551615, 11015955194427482112)), false);
-    assert_eq!(call!(le_ui64(18446744073709551615, 16990600415051759616)), false);
-    assert_eq!(call!(le_ui64(18446744073709551615, 18446744073709551614)), false);
-    assert_eq!(call!(le_ui64(0, 0)), true);
-    assert_eq!(call!(le_ui64(0, 1)), true);
-    assert_eq!(call!(le_ui64(0, 2)), true);
-    assert_eq!(call!(le_ui64(0, 3)), true);
-    assert_eq!(call!(le_ui64(0, 4)), true);
-    assert_eq!(call!(le_ui64(0, 191084152064409600)), true);
-    assert_eq!(call!(le_ui64(0, 11015955194427482112)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_358() {
-    assert_eq!(call!(le_ui64(0, 16990600415051759616)), true);
-    assert_eq!(call!(le_ui64(0, 18446744073709551614)), true);
-    assert_eq!(call!(le_ui64(0, 18446744073709551615)), true);
-    assert_eq!(call!(le_ui64(1, 1)), true);
-    assert_eq!(call!(le_ui64(1, 2)), true);
-    assert_eq!(call!(le_ui64(1, 3)), true);
-    assert_eq!(call!(le_ui64(1, 4)), true);
-    assert_eq!(call!(le_ui64(1, 191084152064409600)), true);
-    assert_eq!(call!(le_ui64(1, 11015955194427482112)), true);
-    assert_eq!(call!(le_ui64(1, 16990600415051759616)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_359() {
-    assert_eq!(call!(le_ui64(1, 18446744073709551614)), true);
-    assert_eq!(call!(le_ui64(1, 18446744073709551615)), true);
-    assert_eq!(call!(le_ui64(2, 2)), true);
-    assert_eq!(call!(le_ui64(2, 3)), true);
-    assert_eq!(call!(le_ui64(2, 4)), true);
-    assert_eq!(call!(le_ui64(2, 191084152064409600)), true);
-    assert_eq!(call!(le_ui64(2, 11015955194427482112)), true);
-    assert_eq!(call!(le_ui64(2, 16990600415051759616)), true);
-    assert_eq!(call!(le_ui64(2, 18446744073709551614)), true);
-    assert_eq!(call!(le_ui64(2, 18446744073709551615)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_360() {
-    assert_eq!(call!(le_ui64(3, 3)), true);
-    assert_eq!(call!(le_ui64(3, 4)), true);
-    assert_eq!(call!(le_ui64(3, 191084152064409600)), true);
-    assert_eq!(call!(le_ui64(3, 11015955194427482112)), true);
-    assert_eq!(call!(le_ui64(3, 16990600415051759616)), true);
-    assert_eq!(call!(le_ui64(3, 18446744073709551614)), true);
-    assert_eq!(call!(le_ui64(3, 18446744073709551615)), true);
-    assert_eq!(call!(le_ui64(4, 4)), true);
-    assert_eq!(call!(le_ui64(4, 191084152064409600)), true);
-    assert_eq!(call!(le_ui64(4, 11015955194427482112)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_361() {
-    assert_eq!(call!(le_ui64(4, 16990600415051759616)), true);
-    assert_eq!(call!(le_ui64(4, 18446744073709551614)), true);
-    assert_eq!(call!(le_ui64(4, 18446744073709551615)), true);
-    assert_eq!(call!(le_ui64(191084152064409600, 191084152064409600)), true);
-    assert_eq!(call!(le_ui64(191084152064409600, 11015955194427482112)), true);
-    assert_eq!(call!(le_ui64(191084152064409600, 16990600415051759616)), true);
-    assert_eq!(call!(le_ui64(191084152064409600, 18446744073709551614)), true);
-    assert_eq!(call!(le_ui64(191084152064409600, 18446744073709551615)), true);
-    assert_eq!(call!(le_ui64(11015955194427482112, 11015955194427482112)), true);
-    assert_eq!(call!(le_ui64(11015955194427482112, 16990600415051759616)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_362() {
-    assert_eq!(call!(le_ui64(11015955194427482112, 18446744073709551614)), true);
-    assert_eq!(call!(le_ui64(11015955194427482112, 18446744073709551615)), true);
-    assert_eq!(call!(le_ui64(16990600415051759616, 16990600415051759616)), true);
-    assert_eq!(call!(le_ui64(16990600415051759616, 18446744073709551614)), true);
-    assert_eq!(call!(le_ui64(16990600415051759616, 18446744073709551615)), true);
-    assert_eq!(call!(le_ui64(18446744073709551614, 18446744073709551614)), true);
-    assert_eq!(call!(le_ui64(18446744073709551614, 18446744073709551615)), true);
-    assert_eq!(call!(le_ui64(18446744073709551615, 18446744073709551615)), true);
-    assert_eq!(call!(le_ui8(1, 0)), false);
-    assert_eq!(call!(le_ui8(2, 0)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_363() {
-    assert_eq!(call!(le_ui8(2, 1)), false);
-    assert_eq!(call!(le_ui8(3, 0)), false);
-    assert_eq!(call!(le_ui8(3, 1)), false);
-    assert_eq!(call!(le_ui8(3, 2)), false);
-    assert_eq!(call!(le_ui8(4, 0)), false);
-    assert_eq!(call!(le_ui8(4, 1)), false);
-    assert_eq!(call!(le_ui8(4, 2)), false);
-    assert_eq!(call!(le_ui8(4, 3)), false);
-    assert_eq!(call!(le_ui8(72, 0)), false);
-    assert_eq!(call!(le_ui8(72, 1)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_364() {
-    assert_eq!(call!(le_ui8(72, 2)), false);
-    assert_eq!(call!(le_ui8(72, 3)), false);
-    assert_eq!(call!(le_ui8(72, 4)), false);
-    assert_eq!(call!(le_ui8(100, 0)), false);
-    assert_eq!(call!(le_ui8(100, 1)), false);
-    assert_eq!(call!(le_ui8(100, 2)), false);
-    assert_eq!(call!(le_ui8(100, 3)), false);
-    assert_eq!(call!(le_ui8(100, 4)), false);
-    assert_eq!(call!(le_ui8(100, 72)), false);
-    assert_eq!(call!(le_ui8(162, 0)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_365() {
-    assert_eq!(call!(le_ui8(162, 1)), false);
-    assert_eq!(call!(le_ui8(162, 2)), false);
-    assert_eq!(call!(le_ui8(162, 3)), false);
-    assert_eq!(call!(le_ui8(162, 4)), false);
-    assert_eq!(call!(le_ui8(162, 72)), false);
-    assert_eq!(call!(le_ui8(162, 100)), false);
-    assert_eq!(call!(le_ui8(254, 0)), false);
-    assert_eq!(call!(le_ui8(254, 1)), false);
-    assert_eq!(call!(le_ui8(254, 2)), false);
-    assert_eq!(call!(le_ui8(254, 3)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_366() {
-    assert_eq!(call!(le_ui8(254, 4)), false);
-    assert_eq!(call!(le_ui8(254, 72)), false);
-    assert_eq!(call!(le_ui8(254, 100)), false);
-    assert_eq!(call!(le_ui8(254, 162)), false);
-    assert_eq!(call!(le_ui8(255, 0)), false);
-    assert_eq!(call!(le_ui8(255, 1)), false);
-    assert_eq!(call!(le_ui8(255, 2)), false);
-    assert_eq!(call!(le_ui8(255, 3)), false);
-    assert_eq!(call!(le_ui8(255, 4)), false);
-    assert_eq!(call!(le_ui8(255, 72)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_367() {
-    assert_eq!(call!(le_ui8(255, 100)), false);
-    assert_eq!(call!(le_ui8(255, 162)), false);
-    assert_eq!(call!(le_ui8(255, 254)), false);
-    assert_eq!(call!(le_ui8(0, 0)), true);
-    assert_eq!(call!(le_ui8(0, 1)), true);
-    assert_eq!(call!(le_ui8(0, 2)), true);
-    assert_eq!(call!(le_ui8(0, 3)), true);
-    assert_eq!(call!(le_ui8(0, 4)), true);
-    assert_eq!(call!(le_ui8(0, 72)), true);
-    assert_eq!(call!(le_ui8(0, 100)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_368() {
-    assert_eq!(call!(le_ui8(0, 162)), true);
-    assert_eq!(call!(le_ui8(0, 254)), true);
-    assert_eq!(call!(le_ui8(0, 255)), true);
-    assert_eq!(call!(le_ui8(1, 1)), true);
-    assert_eq!(call!(le_ui8(1, 2)), true);
-    assert_eq!(call!(le_ui8(1, 3)), true);
-    assert_eq!(call!(le_ui8(1, 4)), true);
-    assert_eq!(call!(le_ui8(1, 72)), true);
-    assert_eq!(call!(le_ui8(1, 100)), true);
-    assert_eq!(call!(le_ui8(1, 162)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_369() {
-    assert_eq!(call!(le_ui8(1, 254)), true);
-    assert_eq!(call!(le_ui8(1, 255)), true);
-    assert_eq!(call!(le_ui8(2, 2)), true);
-    assert_eq!(call!(le_ui8(2, 3)), true);
-    assert_eq!(call!(le_ui8(2, 4)), true);
-    assert_eq!(call!(le_ui8(2, 72)), true);
-    assert_eq!(call!(le_ui8(2, 100)), true);
-    assert_eq!(call!(le_ui8(2, 162)), true);
-    assert_eq!(call!(le_ui8(2, 254)), true);
-    assert_eq!(call!(le_ui8(2, 255)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_370() {
-    assert_eq!(call!(le_ui8(3, 3)), true);
-    assert_eq!(call!(le_ui8(3, 4)), true);
-    assert_eq!(call!(le_ui8(3, 72)), true);
-    assert_eq!(call!(le_ui8(3, 100)), true);
-    assert_eq!(call!(le_ui8(3, 162)), true);
-    assert_eq!(call!(le_ui8(3, 254)), true);
-    assert_eq!(call!(le_ui8(3, 255)), true);
-    assert_eq!(call!(le_ui8(4, 4)), true);
-    assert_eq!(call!(le_ui8(4, 72)), true);
-    assert_eq!(call!(le_ui8(4, 100)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_371() {
-    assert_eq!(call!(le_ui8(4, 162)), true);
-    assert_eq!(call!(le_ui8(4, 254)), true);
-    assert_eq!(call!(le_ui8(4, 255)), true);
-    assert_eq!(call!(le_ui8(72, 72)), true);
-    assert_eq!(call!(le_ui8(72, 100)), true);
-    assert_eq!(call!(le_ui8(72, 162)), true);
-    assert_eq!(call!(le_ui8(72, 254)), true);
-    assert_eq!(call!(le_ui8(72, 255)), true);
-    assert_eq!(call!(le_ui8(100, 100)), true);
-    assert_eq!(call!(le_ui8(100, 162)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_372() {
-    assert_eq!(call!(le_ui8(100, 254)), true);
-    assert_eq!(call!(le_ui8(100, 255)), true);
-    assert_eq!(call!(le_ui8(162, 162)), true);
-    assert_eq!(call!(le_ui8(162, 254)), true);
-    assert_eq!(call!(le_ui8(162, 255)), true);
-    assert_eq!(call!(le_ui8(254, 254)), true);
-    assert_eq!(call!(le_ui8(254, 255)), true);
-    assert_eq!(call!(le_ui8(255, 255)), true);
-    assert_eq!(call!(lt_si16(-32768, -32768)), false);
-    assert_eq!(call!(lt_si16(-32767, -32768)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_373() {
-    assert_eq!(call!(lt_si16(-32767, -32767)), false);
-    assert_eq!(call!(lt_si16(-32547, -32768)), false);
-    assert_eq!(call!(lt_si16(-32547, -32767)), false);
-    assert_eq!(call!(lt_si16(-32547, -32547)), false);
-    assert_eq!(call!(lt_si16(0, -32768)), false);
-    assert_eq!(call!(lt_si16(0, -32767)), false);
-    assert_eq!(call!(lt_si16(0, -32547)), false);
-    assert_eq!(call!(lt_si16(0, 0)), false);
-    assert_eq!(call!(lt_si16(1, -32768)), false);
-    assert_eq!(call!(lt_si16(1, -32767)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_374() {
-    assert_eq!(call!(lt_si16(1, -32547)), false);
-    assert_eq!(call!(lt_si16(1, 0)), false);
-    assert_eq!(call!(lt_si16(1, 1)), false);
-    assert_eq!(call!(lt_si16(2, -32768)), false);
-    assert_eq!(call!(lt_si16(2, -32767)), false);
-    assert_eq!(call!(lt_si16(2, -32547)), false);
-    assert_eq!(call!(lt_si16(2, 0)), false);
-    assert_eq!(call!(lt_si16(2, 1)), false);
-    assert_eq!(call!(lt_si16(2, 2)), false);
-    assert_eq!(call!(lt_si16(3, -32768)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_375() {
-    assert_eq!(call!(lt_si16(3, -32767)), false);
-    assert_eq!(call!(lt_si16(3, -32547)), false);
-    assert_eq!(call!(lt_si16(3, 0)), false);
-    assert_eq!(call!(lt_si16(3, 1)), false);
-    assert_eq!(call!(lt_si16(3, 2)), false);
-    assert_eq!(call!(lt_si16(3, 3)), false);
-    assert_eq!(call!(lt_si16(4, -32768)), false);
-    assert_eq!(call!(lt_si16(4, -32767)), false);
-    assert_eq!(call!(lt_si16(4, -32547)), false);
-    assert_eq!(call!(lt_si16(4, 0)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_376() {
-    assert_eq!(call!(lt_si16(4, 1)), false);
-    assert_eq!(call!(lt_si16(4, 2)), false);
-    assert_eq!(call!(lt_si16(4, 3)), false);
-    assert_eq!(call!(lt_si16(4, 4)), false);
-    assert_eq!(call!(lt_si16(10486, -32768)), false);
-    assert_eq!(call!(lt_si16(10486, -32767)), false);
-    assert_eq!(call!(lt_si16(10486, -32547)), false);
-    assert_eq!(call!(lt_si16(10486, 0)), false);
-    assert_eq!(call!(lt_si16(10486, 1)), false);
-    assert_eq!(call!(lt_si16(10486, 2)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_377() {
-    assert_eq!(call!(lt_si16(10486, 3)), false);
-    assert_eq!(call!(lt_si16(10486, 4)), false);
-    assert_eq!(call!(lt_si16(10486, 10486)), false);
-    assert_eq!(call!(lt_si16(16514, -32768)), false);
-    assert_eq!(call!(lt_si16(16514, -32767)), false);
-    assert_eq!(call!(lt_si16(16514, -32547)), false);
-    assert_eq!(call!(lt_si16(16514, 0)), false);
-    assert_eq!(call!(lt_si16(16514, 1)), false);
-    assert_eq!(call!(lt_si16(16514, 2)), false);
-    assert_eq!(call!(lt_si16(16514, 3)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_378() {
-    assert_eq!(call!(lt_si16(16514, 4)), false);
-    assert_eq!(call!(lt_si16(16514, 10486)), false);
-    assert_eq!(call!(lt_si16(16514, 16514)), false);
-    assert_eq!(call!(lt_si16(32766, -32768)), false);
-    assert_eq!(call!(lt_si16(32766, -32767)), false);
-    assert_eq!(call!(lt_si16(32766, -32547)), false);
-    assert_eq!(call!(lt_si16(32766, 0)), false);
-    assert_eq!(call!(lt_si16(32766, 1)), false);
-    assert_eq!(call!(lt_si16(32766, 2)), false);
-    assert_eq!(call!(lt_si16(32766, 3)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_379() {
-    assert_eq!(call!(lt_si16(32766, 4)), false);
-    assert_eq!(call!(lt_si16(32766, 10486)), false);
-    assert_eq!(call!(lt_si16(32766, 16514)), false);
-    assert_eq!(call!(lt_si16(32766, 32766)), false);
-    assert_eq!(call!(lt_si16(32767, -32768)), false);
-    assert_eq!(call!(lt_si16(32767, -32767)), false);
-    assert_eq!(call!(lt_si16(32767, -32547)), false);
-    assert_eq!(call!(lt_si16(32767, 0)), false);
-    assert_eq!(call!(lt_si16(32767, 1)), false);
-    assert_eq!(call!(lt_si16(32767, 2)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_380() {
-    assert_eq!(call!(lt_si16(32767, 3)), false);
-    assert_eq!(call!(lt_si16(32767, 4)), false);
-    assert_eq!(call!(lt_si16(32767, 10486)), false);
-    assert_eq!(call!(lt_si16(32767, 16514)), false);
-    assert_eq!(call!(lt_si16(32767, 32766)), false);
-    assert_eq!(call!(lt_si16(32767, 32767)), false);
-    assert_eq!(call!(lt_si16(-32768, -32767)), true);
-    assert_eq!(call!(lt_si16(-32768, -32547)), true);
-    assert_eq!(call!(lt_si16(-32768, 0)), true);
-    assert_eq!(call!(lt_si16(-32768, 1)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_381() {
-    assert_eq!(call!(lt_si16(-32768, 2)), true);
-    assert_eq!(call!(lt_si16(-32768, 3)), true);
-    assert_eq!(call!(lt_si16(-32768, 4)), true);
-    assert_eq!(call!(lt_si16(-32768, 10486)), true);
-    assert_eq!(call!(lt_si16(-32768, 16514)), true);
-    assert_eq!(call!(lt_si16(-32768, 32766)), true);
-    assert_eq!(call!(lt_si16(-32768, 32767)), true);
-    assert_eq!(call!(lt_si16(-32767, -32547)), true);
-    assert_eq!(call!(lt_si16(-32767, 0)), true);
-    assert_eq!(call!(lt_si16(-32767, 1)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_382() {
-    assert_eq!(call!(lt_si16(-32767, 2)), true);
-    assert_eq!(call!(lt_si16(-32767, 3)), true);
-    assert_eq!(call!(lt_si16(-32767, 4)), true);
-    assert_eq!(call!(lt_si16(-32767, 10486)), true);
-    assert_eq!(call!(lt_si16(-32767, 16514)), true);
-    assert_eq!(call!(lt_si16(-32767, 32766)), true);
-    assert_eq!(call!(lt_si16(-32767, 32767)), true);
-    assert_eq!(call!(lt_si16(-32547, 0)), true);
-    assert_eq!(call!(lt_si16(-32547, 1)), true);
-    assert_eq!(call!(lt_si16(-32547, 2)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_383() {
-    assert_eq!(call!(lt_si16(-32547, 3)), true);
-    assert_eq!(call!(lt_si16(-32547, 4)), true);
-    assert_eq!(call!(lt_si16(-32547, 10486)), true);
-    assert_eq!(call!(lt_si16(-32547, 16514)), true);
-    assert_eq!(call!(lt_si16(-32547, 32766)), true);
-    assert_eq!(call!(lt_si16(-32547, 32767)), true);
-    assert_eq!(call!(lt_si16(0, 1)), true);
-    assert_eq!(call!(lt_si16(0, 2)), true);
-    assert_eq!(call!(lt_si16(0, 3)), true);
-    assert_eq!(call!(lt_si16(0, 4)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_384() {
-    assert_eq!(call!(lt_si16(0, 10486)), true);
-    assert_eq!(call!(lt_si16(0, 16514)), true);
-    assert_eq!(call!(lt_si16(0, 32766)), true);
-    assert_eq!(call!(lt_si16(0, 32767)), true);
-    assert_eq!(call!(lt_si16(1, 2)), true);
-    assert_eq!(call!(lt_si16(1, 3)), true);
-    assert_eq!(call!(lt_si16(1, 4)), true);
-    assert_eq!(call!(lt_si16(1, 10486)), true);
-    assert_eq!(call!(lt_si16(1, 16514)), true);
-    assert_eq!(call!(lt_si16(1, 32766)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_385() {
-    assert_eq!(call!(lt_si16(1, 32767)), true);
-    assert_eq!(call!(lt_si16(2, 3)), true);
-    assert_eq!(call!(lt_si16(2, 4)), true);
-    assert_eq!(call!(lt_si16(2, 10486)), true);
-    assert_eq!(call!(lt_si16(2, 16514)), true);
-    assert_eq!(call!(lt_si16(2, 32766)), true);
-    assert_eq!(call!(lt_si16(2, 32767)), true);
-    assert_eq!(call!(lt_si16(3, 4)), true);
-    assert_eq!(call!(lt_si16(3, 10486)), true);
-    assert_eq!(call!(lt_si16(3, 16514)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_386() {
-    assert_eq!(call!(lt_si16(3, 32766)), true);
-    assert_eq!(call!(lt_si16(3, 32767)), true);
-    assert_eq!(call!(lt_si16(4, 10486)), true);
-    assert_eq!(call!(lt_si16(4, 16514)), true);
-    assert_eq!(call!(lt_si16(4, 32766)), true);
-    assert_eq!(call!(lt_si16(4, 32767)), true);
-    assert_eq!(call!(lt_si16(10486, 16514)), true);
-    assert_eq!(call!(lt_si16(10486, 32766)), true);
-    assert_eq!(call!(lt_si16(10486, 32767)), true);
-    assert_eq!(call!(lt_si16(16514, 32766)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_387() {
-    assert_eq!(call!(lt_si16(16514, 32767)), true);
-    assert_eq!(call!(lt_si16(32766, 32767)), true);
-    assert_eq!(call!(lt_si32(-2147483648, -2147483648)), false);
-    assert_eq!(call!(lt_si32(-2147483647, -2147483648)), false);
-    assert_eq!(call!(lt_si32(-2147483647, -2147483647)), false);
-    assert_eq!(call!(lt_si32(-1713183800, -2147483648)), false);
-    assert_eq!(call!(lt_si32(-1713183800, -2147483647)), false);
-    assert_eq!(call!(lt_si32(-1713183800, -1713183800)), false);
-    assert_eq!(call!(lt_si32(-1252582164, -2147483648)), false);
-    assert_eq!(call!(lt_si32(-1252582164, -2147483647)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_388() {
-    assert_eq!(call!(lt_si32(-1252582164, -1713183800)), false);
-    assert_eq!(call!(lt_si32(-1252582164, -1252582164)), false);
-    assert_eq!(call!(lt_si32(-1035405763, -2147483648)), false);
-    assert_eq!(call!(lt_si32(-1035405763, -2147483647)), false);
-    assert_eq!(call!(lt_si32(-1035405763, -1713183800)), false);
-    assert_eq!(call!(lt_si32(-1035405763, -1252582164)), false);
-    assert_eq!(call!(lt_si32(-1035405763, -1035405763)), false);
-    assert_eq!(call!(lt_si32(0, -2147483648)), false);
-    assert_eq!(call!(lt_si32(0, -2147483647)), false);
-    assert_eq!(call!(lt_si32(0, -1713183800)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_389() {
-    assert_eq!(call!(lt_si32(0, -1252582164)), false);
-    assert_eq!(call!(lt_si32(0, -1035405763)), false);
-    assert_eq!(call!(lt_si32(0, 0)), false);
-    assert_eq!(call!(lt_si32(1, -2147483648)), false);
-    assert_eq!(call!(lt_si32(1, -2147483647)), false);
-    assert_eq!(call!(lt_si32(1, -1713183800)), false);
-    assert_eq!(call!(lt_si32(1, -1252582164)), false);
-    assert_eq!(call!(lt_si32(1, -1035405763)), false);
-    assert_eq!(call!(lt_si32(1, 0)), false);
-    assert_eq!(call!(lt_si32(1, 1)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_390() {
-    assert_eq!(call!(lt_si32(2, -2147483648)), false);
-    assert_eq!(call!(lt_si32(2, -2147483647)), false);
-    assert_eq!(call!(lt_si32(2, -1713183800)), false);
-    assert_eq!(call!(lt_si32(2, -1252582164)), false);
-    assert_eq!(call!(lt_si32(2, -1035405763)), false);
-    assert_eq!(call!(lt_si32(2, 0)), false);
-    assert_eq!(call!(lt_si32(2, 1)), false);
-    assert_eq!(call!(lt_si32(2, 2)), false);
-    assert_eq!(call!(lt_si32(3, -2147483648)), false);
-    assert_eq!(call!(lt_si32(3, -2147483647)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_391() {
-    assert_eq!(call!(lt_si32(3, -1713183800)), false);
-    assert_eq!(call!(lt_si32(3, -1252582164)), false);
-    assert_eq!(call!(lt_si32(3, -1035405763)), false);
-    assert_eq!(call!(lt_si32(3, 0)), false);
-    assert_eq!(call!(lt_si32(3, 1)), false);
-    assert_eq!(call!(lt_si32(3, 2)), false);
-    assert_eq!(call!(lt_si32(3, 3)), false);
-    assert_eq!(call!(lt_si32(4, -2147483648)), false);
-    assert_eq!(call!(lt_si32(4, -2147483647)), false);
-    assert_eq!(call!(lt_si32(4, -1713183800)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_392() {
-    assert_eq!(call!(lt_si32(4, -1252582164)), false);
-    assert_eq!(call!(lt_si32(4, -1035405763)), false);
-    assert_eq!(call!(lt_si32(4, 0)), false);
-    assert_eq!(call!(lt_si32(4, 1)), false);
-    assert_eq!(call!(lt_si32(4, 2)), false);
-    assert_eq!(call!(lt_si32(4, 3)), false);
-    assert_eq!(call!(lt_si32(4, 4)), false);
-    assert_eq!(call!(lt_si32(2147483646, -2147483648)), false);
-    assert_eq!(call!(lt_si32(2147483646, -2147483647)), false);
-    assert_eq!(call!(lt_si32(2147483646, -1713183800)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_393() {
-    assert_eq!(call!(lt_si32(2147483646, -1252582164)), false);
-    assert_eq!(call!(lt_si32(2147483646, -1035405763)), false);
-    assert_eq!(call!(lt_si32(2147483646, 0)), false);
-    assert_eq!(call!(lt_si32(2147483646, 1)), false);
-    assert_eq!(call!(lt_si32(2147483646, 2)), false);
-    assert_eq!(call!(lt_si32(2147483646, 3)), false);
-    assert_eq!(call!(lt_si32(2147483646, 4)), false);
-    assert_eq!(call!(lt_si32(2147483646, 2147483646)), false);
-    assert_eq!(call!(lt_si32(2147483647, -2147483648)), false);
-    assert_eq!(call!(lt_si32(2147483647, -2147483647)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_394() {
-    assert_eq!(call!(lt_si32(2147483647, -1713183800)), false);
-    assert_eq!(call!(lt_si32(2147483647, -1252582164)), false);
-    assert_eq!(call!(lt_si32(2147483647, -1035405763)), false);
-    assert_eq!(call!(lt_si32(2147483647, 0)), false);
-    assert_eq!(call!(lt_si32(2147483647, 1)), false);
-    assert_eq!(call!(lt_si32(2147483647, 2)), false);
-    assert_eq!(call!(lt_si32(2147483647, 3)), false);
-    assert_eq!(call!(lt_si32(2147483647, 4)), false);
-    assert_eq!(call!(lt_si32(2147483647, 2147483646)), false);
-    assert_eq!(call!(lt_si32(2147483647, 2147483647)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_395() {
-    assert_eq!(call!(lt_si32(-2147483648, -2147483647)), true);
-    assert_eq!(call!(lt_si32(-2147483648, -1713183800)), true);
-    assert_eq!(call!(lt_si32(-2147483648, -1252582164)), true);
-    assert_eq!(call!(lt_si32(-2147483648, -1035405763)), true);
-    assert_eq!(call!(lt_si32(-2147483648, 0)), true);
-    assert_eq!(call!(lt_si32(-2147483648, 1)), true);
-    assert_eq!(call!(lt_si32(-2147483648, 2)), true);
-    assert_eq!(call!(lt_si32(-2147483648, 3)), true);
-    assert_eq!(call!(lt_si32(-2147483648, 4)), true);
-    assert_eq!(call!(lt_si32(-2147483648, 2147483646)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_396() {
-    assert_eq!(call!(lt_si32(-2147483648, 2147483647)), true);
-    assert_eq!(call!(lt_si32(-2147483647, -1713183800)), true);
-    assert_eq!(call!(lt_si32(-2147483647, -1252582164)), true);
-    assert_eq!(call!(lt_si32(-2147483647, -1035405763)), true);
-    assert_eq!(call!(lt_si32(-2147483647, 0)), true);
-    assert_eq!(call!(lt_si32(-2147483647, 1)), true);
-    assert_eq!(call!(lt_si32(-2147483647, 2)), true);
-    assert_eq!(call!(lt_si32(-2147483647, 3)), true);
-    assert_eq!(call!(lt_si32(-2147483647, 4)), true);
-    assert_eq!(call!(lt_si32(-2147483647, 2147483646)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_397() {
-    assert_eq!(call!(lt_si32(-2147483647, 2147483647)), true);
-    assert_eq!(call!(lt_si32(-1713183800, -1252582164)), true);
-    assert_eq!(call!(lt_si32(-1713183800, -1035405763)), true);
-    assert_eq!(call!(lt_si32(-1713183800, 0)), true);
-    assert_eq!(call!(lt_si32(-1713183800, 1)), true);
-    assert_eq!(call!(lt_si32(-1713183800, 2)), true);
-    assert_eq!(call!(lt_si32(-1713183800, 3)), true);
-    assert_eq!(call!(lt_si32(-1713183800, 4)), true);
-    assert_eq!(call!(lt_si32(-1713183800, 2147483646)), true);
-    assert_eq!(call!(lt_si32(-1713183800, 2147483647)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_398() {
-    assert_eq!(call!(lt_si32(-1252582164, -1035405763)), true);
-    assert_eq!(call!(lt_si32(-1252582164, 0)), true);
-    assert_eq!(call!(lt_si32(-1252582164, 1)), true);
-    assert_eq!(call!(lt_si32(-1252582164, 2)), true);
-    assert_eq!(call!(lt_si32(-1252582164, 3)), true);
-    assert_eq!(call!(lt_si32(-1252582164, 4)), true);
-    assert_eq!(call!(lt_si32(-1252582164, 2147483646)), true);
-    assert_eq!(call!(lt_si32(-1252582164, 2147483647)), true);
-    assert_eq!(call!(lt_si32(-1035405763, 0)), true);
-    assert_eq!(call!(lt_si32(-1035405763, 1)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_399() {
-    assert_eq!(call!(lt_si32(-1035405763, 2)), true);
-    assert_eq!(call!(lt_si32(-1035405763, 3)), true);
-    assert_eq!(call!(lt_si32(-1035405763, 4)), true);
-    assert_eq!(call!(lt_si32(-1035405763, 2147483646)), true);
-    assert_eq!(call!(lt_si32(-1035405763, 2147483647)), true);
-    assert_eq!(call!(lt_si32(0, 1)), true);
-    assert_eq!(call!(lt_si32(0, 2)), true);
-    assert_eq!(call!(lt_si32(0, 3)), true);
-    assert_eq!(call!(lt_si32(0, 4)), true);
-    assert_eq!(call!(lt_si32(0, 2147483646)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_400() {
-    assert_eq!(call!(lt_si32(0, 2147483647)), true);
-    assert_eq!(call!(lt_si32(1, 2)), true);
-    assert_eq!(call!(lt_si32(1, 3)), true);
-    assert_eq!(call!(lt_si32(1, 4)), true);
-    assert_eq!(call!(lt_si32(1, 2147483646)), true);
-    assert_eq!(call!(lt_si32(1, 2147483647)), true);
-    assert_eq!(call!(lt_si32(2, 3)), true);
-    assert_eq!(call!(lt_si32(2, 4)), true);
-    assert_eq!(call!(lt_si32(2, 2147483646)), true);
-    assert_eq!(call!(lt_si32(2, 2147483647)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_401() {
-    assert_eq!(call!(lt_si32(3, 4)), true);
-    assert_eq!(call!(lt_si32(3, 2147483646)), true);
-    assert_eq!(call!(lt_si32(3, 2147483647)), true);
-    assert_eq!(call!(lt_si32(4, 2147483646)), true);
-    assert_eq!(call!(lt_si32(4, 2147483647)), true);
-    assert_eq!(call!(lt_si32(2147483646, 2147483647)), true);
-    assert_eq!(call!(lt_si64(-9223372036854775808, -9223372036854775808)), false);
-    assert_eq!(call!(lt_si64(-9223372036854775807, -9223372036854775808)), false);
-    assert_eq!(call!(lt_si64(-9223372036854775807, -9223372036854775807)), false);
-    assert_eq!(call!(lt_si64(-1741927215160008704, -9223372036854775808)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_402() {
-    assert_eq!(call!(lt_si64(-1741927215160008704, -9223372036854775807)), false);
-    assert_eq!(call!(lt_si64(-1741927215160008704, -1741927215160008704)), false);
-    assert_eq!(call!(lt_si64(-1328271339354574848, -9223372036854775808)), false);
-    assert_eq!(call!(lt_si64(-1328271339354574848, -9223372036854775807)), false);
-    assert_eq!(call!(lt_si64(-1328271339354574848, -1741927215160008704)), false);
-    assert_eq!(call!(lt_si64(-1328271339354574848, -1328271339354574848)), false);
-    assert_eq!(call!(lt_si64(0, -9223372036854775808)), false);
-    assert_eq!(call!(lt_si64(0, -9223372036854775807)), false);
-    assert_eq!(call!(lt_si64(0, -1741927215160008704)), false);
-    assert_eq!(call!(lt_si64(0, -1328271339354574848)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_403() {
-    assert_eq!(call!(lt_si64(0, 0)), false);
-    assert_eq!(call!(lt_si64(1, -9223372036854775808)), false);
-    assert_eq!(call!(lt_si64(1, -9223372036854775807)), false);
-    assert_eq!(call!(lt_si64(1, -1741927215160008704)), false);
-    assert_eq!(call!(lt_si64(1, -1328271339354574848)), false);
-    assert_eq!(call!(lt_si64(1, 0)), false);
-    assert_eq!(call!(lt_si64(1, 1)), false);
-    assert_eq!(call!(lt_si64(2, -9223372036854775808)), false);
-    assert_eq!(call!(lt_si64(2, -9223372036854775807)), false);
-    assert_eq!(call!(lt_si64(2, -1741927215160008704)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_404() {
-    assert_eq!(call!(lt_si64(2, -1328271339354574848)), false);
-    assert_eq!(call!(lt_si64(2, 0)), false);
-    assert_eq!(call!(lt_si64(2, 1)), false);
-    assert_eq!(call!(lt_si64(2, 2)), false);
-    assert_eq!(call!(lt_si64(3, -9223372036854775808)), false);
-    assert_eq!(call!(lt_si64(3, -9223372036854775807)), false);
-    assert_eq!(call!(lt_si64(3, -1741927215160008704)), false);
-    assert_eq!(call!(lt_si64(3, -1328271339354574848)), false);
-    assert_eq!(call!(lt_si64(3, 0)), false);
-    assert_eq!(call!(lt_si64(3, 1)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_405() {
-    assert_eq!(call!(lt_si64(3, 2)), false);
-    assert_eq!(call!(lt_si64(3, 3)), false);
-    assert_eq!(call!(lt_si64(4, -9223372036854775808)), false);
-    assert_eq!(call!(lt_si64(4, -9223372036854775807)), false);
-    assert_eq!(call!(lt_si64(4, -1741927215160008704)), false);
-    assert_eq!(call!(lt_si64(4, -1328271339354574848)), false);
-    assert_eq!(call!(lt_si64(4, 0)), false);
-    assert_eq!(call!(lt_si64(4, 1)), false);
-    assert_eq!(call!(lt_si64(4, 2)), false);
-    assert_eq!(call!(lt_si64(4, 3)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_406() {
-    assert_eq!(call!(lt_si64(4, 4)), false);
-    assert_eq!(call!(lt_si64(5577148965131116544, -9223372036854775808)), false);
-    assert_eq!(call!(lt_si64(5577148965131116544, -9223372036854775807)), false);
-    assert_eq!(call!(lt_si64(5577148965131116544, -1741927215160008704)), false);
-    assert_eq!(call!(lt_si64(5577148965131116544, -1328271339354574848)), false);
-    assert_eq!(call!(lt_si64(5577148965131116544, 0)), false);
-    assert_eq!(call!(lt_si64(5577148965131116544, 1)), false);
-    assert_eq!(call!(lt_si64(5577148965131116544, 2)), false);
-    assert_eq!(call!(lt_si64(5577148965131116544, 3)), false);
-    assert_eq!(call!(lt_si64(5577148965131116544, 4)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_407() {
-    assert_eq!(call!(lt_si64(5577148965131116544, 5577148965131116544)), false);
-    assert_eq!(call!(lt_si64(9223372036854775806, -9223372036854775808)), false);
-    assert_eq!(call!(lt_si64(9223372036854775806, -9223372036854775807)), false);
-    assert_eq!(call!(lt_si64(9223372036854775806, -1741927215160008704)), false);
-    assert_eq!(call!(lt_si64(9223372036854775806, -1328271339354574848)), false);
-    assert_eq!(call!(lt_si64(9223372036854775806, 0)), false);
-    assert_eq!(call!(lt_si64(9223372036854775806, 1)), false);
-    assert_eq!(call!(lt_si64(9223372036854775806, 2)), false);
-    assert_eq!(call!(lt_si64(9223372036854775806, 3)), false);
-    assert_eq!(call!(lt_si64(9223372036854775806, 4)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_408() {
-    assert_eq!(call!(lt_si64(9223372036854775806, 5577148965131116544)), false);
-    assert_eq!(call!(lt_si64(9223372036854775806, 9223372036854775806)), false);
-    assert_eq!(call!(lt_si64(9223372036854775807, -9223372036854775808)), false);
-    assert_eq!(call!(lt_si64(9223372036854775807, -9223372036854775807)), false);
-    assert_eq!(call!(lt_si64(9223372036854775807, -1741927215160008704)), false);
-    assert_eq!(call!(lt_si64(9223372036854775807, -1328271339354574848)), false);
-    assert_eq!(call!(lt_si64(9223372036854775807, 0)), false);
-    assert_eq!(call!(lt_si64(9223372036854775807, 1)), false);
-    assert_eq!(call!(lt_si64(9223372036854775807, 2)), false);
-    assert_eq!(call!(lt_si64(9223372036854775807, 3)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_409() {
-    assert_eq!(call!(lt_si64(9223372036854775807, 4)), false);
-    assert_eq!(call!(lt_si64(9223372036854775807, 5577148965131116544)), false);
-    assert_eq!(call!(lt_si64(9223372036854775807, 9223372036854775806)), false);
-    assert_eq!(call!(lt_si64(9223372036854775807, 9223372036854775807)), false);
-    assert_eq!(call!(lt_si64(-9223372036854775808, -9223372036854775807)), true);
-    assert_eq!(call!(lt_si64(-9223372036854775808, -1741927215160008704)), true);
-    assert_eq!(call!(lt_si64(-9223372036854775808, -1328271339354574848)), true);
-    assert_eq!(call!(lt_si64(-9223372036854775808, 0)), true);
-    assert_eq!(call!(lt_si64(-9223372036854775808, 1)), true);
-    assert_eq!(call!(lt_si64(-9223372036854775808, 2)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_410() {
-    assert_eq!(call!(lt_si64(-9223372036854775808, 3)), true);
-    assert_eq!(call!(lt_si64(-9223372036854775808, 4)), true);
-    assert_eq!(call!(lt_si64(-9223372036854775808, 5577148965131116544)), true);
-    assert_eq!(call!(lt_si64(-9223372036854775808, 9223372036854775806)), true);
-    assert_eq!(call!(lt_si64(-9223372036854775808, 9223372036854775807)), true);
-    assert_eq!(call!(lt_si64(-9223372036854775807, -1741927215160008704)), true);
-    assert_eq!(call!(lt_si64(-9223372036854775807, -1328271339354574848)), true);
-    assert_eq!(call!(lt_si64(-9223372036854775807, 0)), true);
-    assert_eq!(call!(lt_si64(-9223372036854775807, 1)), true);
-    assert_eq!(call!(lt_si64(-9223372036854775807, 2)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_411() {
-    assert_eq!(call!(lt_si64(-9223372036854775807, 3)), true);
-    assert_eq!(call!(lt_si64(-9223372036854775807, 4)), true);
-    assert_eq!(call!(lt_si64(-9223372036854775807, 5577148965131116544)), true);
-    assert_eq!(call!(lt_si64(-9223372036854775807, 9223372036854775806)), true);
-    assert_eq!(call!(lt_si64(-9223372036854775807, 9223372036854775807)), true);
-    assert_eq!(call!(lt_si64(-1741927215160008704, -1328271339354574848)), true);
-    assert_eq!(call!(lt_si64(-1741927215160008704, 0)), true);
-    assert_eq!(call!(lt_si64(-1741927215160008704, 1)), true);
-    assert_eq!(call!(lt_si64(-1741927215160008704, 2)), true);
-    assert_eq!(call!(lt_si64(-1741927215160008704, 3)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_412() {
-    assert_eq!(call!(lt_si64(-1741927215160008704, 4)), true);
-    assert_eq!(call!(lt_si64(-1741927215160008704, 5577148965131116544)), true);
-    assert_eq!(call!(lt_si64(-1741927215160008704, 9223372036854775806)), true);
-    assert_eq!(call!(lt_si64(-1741927215160008704, 9223372036854775807)), true);
-    assert_eq!(call!(lt_si64(-1328271339354574848, 0)), true);
-    assert_eq!(call!(lt_si64(-1328271339354574848, 1)), true);
-    assert_eq!(call!(lt_si64(-1328271339354574848, 2)), true);
-    assert_eq!(call!(lt_si64(-1328271339354574848, 3)), true);
-    assert_eq!(call!(lt_si64(-1328271339354574848, 4)), true);
-    assert_eq!(call!(lt_si64(-1328271339354574848, 5577148965131116544)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_413() {
-    assert_eq!(call!(lt_si64(-1328271339354574848, 9223372036854775806)), true);
-    assert_eq!(call!(lt_si64(-1328271339354574848, 9223372036854775807)), true);
-    assert_eq!(call!(lt_si64(0, 1)), true);
-    assert_eq!(call!(lt_si64(0, 2)), true);
-    assert_eq!(call!(lt_si64(0, 3)), true);
-    assert_eq!(call!(lt_si64(0, 4)), true);
-    assert_eq!(call!(lt_si64(0, 5577148965131116544)), true);
-    assert_eq!(call!(lt_si64(0, 9223372036854775806)), true);
-    assert_eq!(call!(lt_si64(0, 9223372036854775807)), true);
-    assert_eq!(call!(lt_si64(1, 2)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_414() {
-    assert_eq!(call!(lt_si64(1, 3)), true);
-    assert_eq!(call!(lt_si64(1, 4)), true);
-    assert_eq!(call!(lt_si64(1, 5577148965131116544)), true);
-    assert_eq!(call!(lt_si64(1, 9223372036854775806)), true);
-    assert_eq!(call!(lt_si64(1, 9223372036854775807)), true);
-    assert_eq!(call!(lt_si64(2, 3)), true);
-    assert_eq!(call!(lt_si64(2, 4)), true);
-    assert_eq!(call!(lt_si64(2, 5577148965131116544)), true);
-    assert_eq!(call!(lt_si64(2, 9223372036854775806)), true);
-    assert_eq!(call!(lt_si64(2, 9223372036854775807)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_415() {
-    assert_eq!(call!(lt_si64(3, 4)), true);
-    assert_eq!(call!(lt_si64(3, 5577148965131116544)), true);
-    assert_eq!(call!(lt_si64(3, 9223372036854775806)), true);
-    assert_eq!(call!(lt_si64(3, 9223372036854775807)), true);
-    assert_eq!(call!(lt_si64(4, 5577148965131116544)), true);
-    assert_eq!(call!(lt_si64(4, 9223372036854775806)), true);
-    assert_eq!(call!(lt_si64(4, 9223372036854775807)), true);
-    assert_eq!(call!(lt_si64(5577148965131116544, 9223372036854775806)), true);
-    assert_eq!(call!(lt_si64(5577148965131116544, 9223372036854775807)), true);
-    assert_eq!(call!(lt_si64(9223372036854775806, 9223372036854775807)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_416() {
-    assert_eq!(call!(lt_si8(-128, -128)), false);
-    assert_eq!(call!(lt_si8(-127, -128)), false);
-    assert_eq!(call!(lt_si8(-127, -127)), false);
-    assert_eq!(call!(lt_si8(0, -128)), false);
-    assert_eq!(call!(lt_si8(0, -127)), false);
-    assert_eq!(call!(lt_si8(0, 0)), false);
-    assert_eq!(call!(lt_si8(1, -128)), false);
-    assert_eq!(call!(lt_si8(1, -127)), false);
-    assert_eq!(call!(lt_si8(1, 0)), false);
-    assert_eq!(call!(lt_si8(1, 1)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_417() {
-    assert_eq!(call!(lt_si8(2, -128)), false);
-    assert_eq!(call!(lt_si8(2, -127)), false);
-    assert_eq!(call!(lt_si8(2, 0)), false);
-    assert_eq!(call!(lt_si8(2, 1)), false);
-    assert_eq!(call!(lt_si8(2, 2)), false);
-    assert_eq!(call!(lt_si8(3, -128)), false);
-    assert_eq!(call!(lt_si8(3, -127)), false);
-    assert_eq!(call!(lt_si8(3, 0)), false);
-    assert_eq!(call!(lt_si8(3, 1)), false);
-    assert_eq!(call!(lt_si8(3, 2)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_418() {
-    assert_eq!(call!(lt_si8(3, 3)), false);
-    assert_eq!(call!(lt_si8(4, -128)), false);
-    assert_eq!(call!(lt_si8(4, -127)), false);
-    assert_eq!(call!(lt_si8(4, 0)), false);
-    assert_eq!(call!(lt_si8(4, 1)), false);
-    assert_eq!(call!(lt_si8(4, 2)), false);
-    assert_eq!(call!(lt_si8(4, 3)), false);
-    assert_eq!(call!(lt_si8(4, 4)), false);
-    assert_eq!(call!(lt_si8(16, -128)), false);
-    assert_eq!(call!(lt_si8(16, -127)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_419() {
-    assert_eq!(call!(lt_si8(16, 0)), false);
-    assert_eq!(call!(lt_si8(16, 1)), false);
-    assert_eq!(call!(lt_si8(16, 2)), false);
-    assert_eq!(call!(lt_si8(16, 3)), false);
-    assert_eq!(call!(lt_si8(16, 4)), false);
-    assert_eq!(call!(lt_si8(16, 16)), false);
-    assert_eq!(call!(lt_si8(126, -128)), false);
-    assert_eq!(call!(lt_si8(126, -127)), false);
-    assert_eq!(call!(lt_si8(126, 0)), false);
-    assert_eq!(call!(lt_si8(126, 1)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_420() {
-    assert_eq!(call!(lt_si8(126, 2)), false);
-    assert_eq!(call!(lt_si8(126, 3)), false);
-    assert_eq!(call!(lt_si8(126, 4)), false);
-    assert_eq!(call!(lt_si8(126, 16)), false);
-    assert_eq!(call!(lt_si8(126, 126)), false);
-    assert_eq!(call!(lt_si8(127, -128)), false);
-    assert_eq!(call!(lt_si8(127, -127)), false);
-    assert_eq!(call!(lt_si8(127, 0)), false);
-    assert_eq!(call!(lt_si8(127, 1)), false);
-    assert_eq!(call!(lt_si8(127, 2)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_421() {
-    assert_eq!(call!(lt_si8(127, 3)), false);
-    assert_eq!(call!(lt_si8(127, 4)), false);
-    assert_eq!(call!(lt_si8(127, 16)), false);
-    assert_eq!(call!(lt_si8(127, 126)), false);
-    assert_eq!(call!(lt_si8(127, 127)), false);
-    assert_eq!(call!(lt_si8(-128, -127)), true);
-    assert_eq!(call!(lt_si8(-128, 0)), true);
-    assert_eq!(call!(lt_si8(-128, 1)), true);
-    assert_eq!(call!(lt_si8(-128, 2)), true);
-    assert_eq!(call!(lt_si8(-128, 3)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_422() {
-    assert_eq!(call!(lt_si8(-128, 4)), true);
-    assert_eq!(call!(lt_si8(-128, 16)), true);
-    assert_eq!(call!(lt_si8(-128, 126)), true);
-    assert_eq!(call!(lt_si8(-128, 127)), true);
-    assert_eq!(call!(lt_si8(-127, 0)), true);
-    assert_eq!(call!(lt_si8(-127, 1)), true);
-    assert_eq!(call!(lt_si8(-127, 2)), true);
-    assert_eq!(call!(lt_si8(-127, 3)), true);
-    assert_eq!(call!(lt_si8(-127, 4)), true);
-    assert_eq!(call!(lt_si8(-127, 16)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_423() {
-    assert_eq!(call!(lt_si8(-127, 126)), true);
-    assert_eq!(call!(lt_si8(-127, 127)), true);
-    assert_eq!(call!(lt_si8(0, 1)), true);
-    assert_eq!(call!(lt_si8(0, 2)), true);
-    assert_eq!(call!(lt_si8(0, 3)), true);
-    assert_eq!(call!(lt_si8(0, 4)), true);
-    assert_eq!(call!(lt_si8(0, 16)), true);
-    assert_eq!(call!(lt_si8(0, 126)), true);
-    assert_eq!(call!(lt_si8(0, 127)), true);
-    assert_eq!(call!(lt_si8(1, 2)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_424() {
-    assert_eq!(call!(lt_si8(1, 3)), true);
-    assert_eq!(call!(lt_si8(1, 4)), true);
-    assert_eq!(call!(lt_si8(1, 16)), true);
-    assert_eq!(call!(lt_si8(1, 126)), true);
-    assert_eq!(call!(lt_si8(1, 127)), true);
-    assert_eq!(call!(lt_si8(2, 3)), true);
-    assert_eq!(call!(lt_si8(2, 4)), true);
-    assert_eq!(call!(lt_si8(2, 16)), true);
-    assert_eq!(call!(lt_si8(2, 126)), true);
-    assert_eq!(call!(lt_si8(2, 127)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_425() {
-    assert_eq!(call!(lt_si8(3, 4)), true);
-    assert_eq!(call!(lt_si8(3, 16)), true);
-    assert_eq!(call!(lt_si8(3, 126)), true);
-    assert_eq!(call!(lt_si8(3, 127)), true);
-    assert_eq!(call!(lt_si8(4, 16)), true);
-    assert_eq!(call!(lt_si8(4, 126)), true);
-    assert_eq!(call!(lt_si8(4, 127)), true);
-    assert_eq!(call!(lt_si8(16, 126)), true);
-    assert_eq!(call!(lt_si8(16, 127)), true);
-    assert_eq!(call!(lt_si8(126, 127)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_426() {
-    assert_eq!(call!(lt_ui16(0, 0)), false);
-    assert_eq!(call!(lt_ui16(1, 0)), false);
-    assert_eq!(call!(lt_ui16(1, 1)), false);
-    assert_eq!(call!(lt_ui16(2, 0)), false);
-    assert_eq!(call!(lt_ui16(2, 1)), false);
-    assert_eq!(call!(lt_ui16(2, 2)), false);
-    assert_eq!(call!(lt_ui16(3, 0)), false);
-    assert_eq!(call!(lt_ui16(3, 1)), false);
-    assert_eq!(call!(lt_ui16(3, 2)), false);
-    assert_eq!(call!(lt_ui16(3, 3)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_427() {
-    assert_eq!(call!(lt_ui16(4, 0)), false);
-    assert_eq!(call!(lt_ui16(4, 1)), false);
-    assert_eq!(call!(lt_ui16(4, 2)), false);
-    assert_eq!(call!(lt_ui16(4, 3)), false);
-    assert_eq!(call!(lt_ui16(4, 4)), false);
-    assert_eq!(call!(lt_ui16(1717, 0)), false);
-    assert_eq!(call!(lt_ui16(1717, 1)), false);
-    assert_eq!(call!(lt_ui16(1717, 2)), false);
-    assert_eq!(call!(lt_ui16(1717, 3)), false);
-    assert_eq!(call!(lt_ui16(1717, 4)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_428() {
-    assert_eq!(call!(lt_ui16(1717, 1717)), false);
-    assert_eq!(call!(lt_ui16(17988, 0)), false);
-    assert_eq!(call!(lt_ui16(17988, 1)), false);
-    assert_eq!(call!(lt_ui16(17988, 2)), false);
-    assert_eq!(call!(lt_ui16(17988, 3)), false);
-    assert_eq!(call!(lt_ui16(17988, 4)), false);
-    assert_eq!(call!(lt_ui16(17988, 1717)), false);
-    assert_eq!(call!(lt_ui16(17988, 17988)), false);
-    assert_eq!(call!(lt_ui16(65096, 0)), false);
-    assert_eq!(call!(lt_ui16(65096, 1)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_429() {
-    assert_eq!(call!(lt_ui16(65096, 2)), false);
-    assert_eq!(call!(lt_ui16(65096, 3)), false);
-    assert_eq!(call!(lt_ui16(65096, 4)), false);
-    assert_eq!(call!(lt_ui16(65096, 1717)), false);
-    assert_eq!(call!(lt_ui16(65096, 17988)), false);
-    assert_eq!(call!(lt_ui16(65096, 65096)), false);
-    assert_eq!(call!(lt_ui16(65534, 0)), false);
-    assert_eq!(call!(lt_ui16(65534, 1)), false);
-    assert_eq!(call!(lt_ui16(65534, 2)), false);
-    assert_eq!(call!(lt_ui16(65534, 3)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_430() {
-    assert_eq!(call!(lt_ui16(65534, 4)), false);
-    assert_eq!(call!(lt_ui16(65534, 1717)), false);
-    assert_eq!(call!(lt_ui16(65534, 17988)), false);
-    assert_eq!(call!(lt_ui16(65534, 65096)), false);
-    assert_eq!(call!(lt_ui16(65534, 65534)), false);
-    assert_eq!(call!(lt_ui16(65535, 0)), false);
-    assert_eq!(call!(lt_ui16(65535, 1)), false);
-    assert_eq!(call!(lt_ui16(65535, 2)), false);
-    assert_eq!(call!(lt_ui16(65535, 3)), false);
-    assert_eq!(call!(lt_ui16(65535, 4)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_431() {
-    assert_eq!(call!(lt_ui16(65535, 1717)), false);
-    assert_eq!(call!(lt_ui16(65535, 17988)), false);
-    assert_eq!(call!(lt_ui16(65535, 65096)), false);
-    assert_eq!(call!(lt_ui16(65535, 65534)), false);
-    assert_eq!(call!(lt_ui16(65535, 65535)), false);
-    assert_eq!(call!(lt_ui16(0, 1)), true);
-    assert_eq!(call!(lt_ui16(0, 2)), true);
-    assert_eq!(call!(lt_ui16(0, 3)), true);
-    assert_eq!(call!(lt_ui16(0, 4)), true);
-    assert_eq!(call!(lt_ui16(0, 1717)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_432() {
-    assert_eq!(call!(lt_ui16(0, 17988)), true);
-    assert_eq!(call!(lt_ui16(0, 65096)), true);
-    assert_eq!(call!(lt_ui16(0, 65534)), true);
-    assert_eq!(call!(lt_ui16(0, 65535)), true);
-    assert_eq!(call!(lt_ui16(1, 2)), true);
-    assert_eq!(call!(lt_ui16(1, 3)), true);
-    assert_eq!(call!(lt_ui16(1, 4)), true);
-    assert_eq!(call!(lt_ui16(1, 1717)), true);
-    assert_eq!(call!(lt_ui16(1, 17988)), true);
-    assert_eq!(call!(lt_ui16(1, 65096)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_433() {
-    assert_eq!(call!(lt_ui16(1, 65534)), true);
-    assert_eq!(call!(lt_ui16(1, 65535)), true);
-    assert_eq!(call!(lt_ui16(2, 3)), true);
-    assert_eq!(call!(lt_ui16(2, 4)), true);
-    assert_eq!(call!(lt_ui16(2, 1717)), true);
-    assert_eq!(call!(lt_ui16(2, 17988)), true);
-    assert_eq!(call!(lt_ui16(2, 65096)), true);
-    assert_eq!(call!(lt_ui16(2, 65534)), true);
-    assert_eq!(call!(lt_ui16(2, 65535)), true);
-    assert_eq!(call!(lt_ui16(3, 4)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_434() {
-    assert_eq!(call!(lt_ui16(3, 1717)), true);
-    assert_eq!(call!(lt_ui16(3, 17988)), true);
-    assert_eq!(call!(lt_ui16(3, 65096)), true);
-    assert_eq!(call!(lt_ui16(3, 65534)), true);
-    assert_eq!(call!(lt_ui16(3, 65535)), true);
-    assert_eq!(call!(lt_ui16(4, 1717)), true);
-    assert_eq!(call!(lt_ui16(4, 17988)), true);
-    assert_eq!(call!(lt_ui16(4, 65096)), true);
-    assert_eq!(call!(lt_ui16(4, 65534)), true);
-    assert_eq!(call!(lt_ui16(4, 65535)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_435() {
-    assert_eq!(call!(lt_ui16(1717, 17988)), true);
-    assert_eq!(call!(lt_ui16(1717, 65096)), true);
-    assert_eq!(call!(lt_ui16(1717, 65534)), true);
-    assert_eq!(call!(lt_ui16(1717, 65535)), true);
-    assert_eq!(call!(lt_ui16(17988, 65096)), true);
-    assert_eq!(call!(lt_ui16(17988, 65534)), true);
-    assert_eq!(call!(lt_ui16(17988, 65535)), true);
-    assert_eq!(call!(lt_ui16(65096, 65534)), true);
-    assert_eq!(call!(lt_ui16(65096, 65535)), true);
-    assert_eq!(call!(lt_ui16(65534, 65535)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_436() {
-    assert_eq!(call!(lt_ui32(0, 0)), false);
-    assert_eq!(call!(lt_ui32(1, 0)), false);
-    assert_eq!(call!(lt_ui32(1, 1)), false);
-    assert_eq!(call!(lt_ui32(2, 0)), false);
-    assert_eq!(call!(lt_ui32(2, 1)), false);
-    assert_eq!(call!(lt_ui32(2, 2)), false);
-    assert_eq!(call!(lt_ui32(3, 0)), false);
-    assert_eq!(call!(lt_ui32(3, 1)), false);
-    assert_eq!(call!(lt_ui32(3, 2)), false);
-    assert_eq!(call!(lt_ui32(3, 3)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_437() {
-    assert_eq!(call!(lt_ui32(4, 0)), false);
-    assert_eq!(call!(lt_ui32(4, 1)), false);
-    assert_eq!(call!(lt_ui32(4, 2)), false);
-    assert_eq!(call!(lt_ui32(4, 3)), false);
-    assert_eq!(call!(lt_ui32(4, 4)), false);
-    assert_eq!(call!(lt_ui32(2119154652, 0)), false);
-    assert_eq!(call!(lt_ui32(2119154652, 1)), false);
-    assert_eq!(call!(lt_ui32(2119154652, 2)), false);
-    assert_eq!(call!(lt_ui32(2119154652, 3)), false);
-    assert_eq!(call!(lt_ui32(2119154652, 4)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_438() {
-    assert_eq!(call!(lt_ui32(2119154652, 2119154652)), false);
-    assert_eq!(call!(lt_ui32(3002788344, 0)), false);
-    assert_eq!(call!(lt_ui32(3002788344, 1)), false);
-    assert_eq!(call!(lt_ui32(3002788344, 2)), false);
-    assert_eq!(call!(lt_ui32(3002788344, 3)), false);
-    assert_eq!(call!(lt_ui32(3002788344, 4)), false);
-    assert_eq!(call!(lt_ui32(3002788344, 2119154652)), false);
-    assert_eq!(call!(lt_ui32(3002788344, 3002788344)), false);
-    assert_eq!(call!(lt_ui32(3482297128, 0)), false);
-    assert_eq!(call!(lt_ui32(3482297128, 1)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_439() {
-    assert_eq!(call!(lt_ui32(3482297128, 2)), false);
-    assert_eq!(call!(lt_ui32(3482297128, 3)), false);
-    assert_eq!(call!(lt_ui32(3482297128, 4)), false);
-    assert_eq!(call!(lt_ui32(3482297128, 2119154652)), false);
-    assert_eq!(call!(lt_ui32(3482297128, 3002788344)), false);
-    assert_eq!(call!(lt_ui32(3482297128, 3482297128)), false);
-    assert_eq!(call!(lt_ui32(4294967294, 0)), false);
-    assert_eq!(call!(lt_ui32(4294967294, 1)), false);
-    assert_eq!(call!(lt_ui32(4294967294, 2)), false);
-    assert_eq!(call!(lt_ui32(4294967294, 3)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_440() {
-    assert_eq!(call!(lt_ui32(4294967294, 4)), false);
-    assert_eq!(call!(lt_ui32(4294967294, 2119154652)), false);
-    assert_eq!(call!(lt_ui32(4294967294, 3002788344)), false);
-    assert_eq!(call!(lt_ui32(4294967294, 3482297128)), false);
-    assert_eq!(call!(lt_ui32(4294967294, 4294967294)), false);
-    assert_eq!(call!(lt_ui32(4294967295, 0)), false);
-    assert_eq!(call!(lt_ui32(4294967295, 1)), false);
-    assert_eq!(call!(lt_ui32(4294967295, 2)), false);
-    assert_eq!(call!(lt_ui32(4294967295, 3)), false);
-    assert_eq!(call!(lt_ui32(4294967295, 4)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_441() {
-    assert_eq!(call!(lt_ui32(4294967295, 2119154652)), false);
-    assert_eq!(call!(lt_ui32(4294967295, 3002788344)), false);
-    assert_eq!(call!(lt_ui32(4294967295, 3482297128)), false);
-    assert_eq!(call!(lt_ui32(4294967295, 4294967294)), false);
-    assert_eq!(call!(lt_ui32(4294967295, 4294967295)), false);
-    assert_eq!(call!(lt_ui32(0, 1)), true);
-    assert_eq!(call!(lt_ui32(0, 2)), true);
-    assert_eq!(call!(lt_ui32(0, 3)), true);
-    assert_eq!(call!(lt_ui32(0, 4)), true);
-    assert_eq!(call!(lt_ui32(0, 2119154652)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_442() {
-    assert_eq!(call!(lt_ui32(0, 3002788344)), true);
-    assert_eq!(call!(lt_ui32(0, 3482297128)), true);
-    assert_eq!(call!(lt_ui32(0, 4294967294)), true);
-    assert_eq!(call!(lt_ui32(0, 4294967295)), true);
-    assert_eq!(call!(lt_ui32(1, 2)), true);
-    assert_eq!(call!(lt_ui32(1, 3)), true);
-    assert_eq!(call!(lt_ui32(1, 4)), true);
-    assert_eq!(call!(lt_ui32(1, 2119154652)), true);
-    assert_eq!(call!(lt_ui32(1, 3002788344)), true);
-    assert_eq!(call!(lt_ui32(1, 3482297128)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_443() {
-    assert_eq!(call!(lt_ui32(1, 4294967294)), true);
-    assert_eq!(call!(lt_ui32(1, 4294967295)), true);
-    assert_eq!(call!(lt_ui32(2, 3)), true);
-    assert_eq!(call!(lt_ui32(2, 4)), true);
-    assert_eq!(call!(lt_ui32(2, 2119154652)), true);
-    assert_eq!(call!(lt_ui32(2, 3002788344)), true);
-    assert_eq!(call!(lt_ui32(2, 3482297128)), true);
-    assert_eq!(call!(lt_ui32(2, 4294967294)), true);
-    assert_eq!(call!(lt_ui32(2, 4294967295)), true);
-    assert_eq!(call!(lt_ui32(3, 4)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_444() {
-    assert_eq!(call!(lt_ui32(3, 2119154652)), true);
-    assert_eq!(call!(lt_ui32(3, 3002788344)), true);
-    assert_eq!(call!(lt_ui32(3, 3482297128)), true);
-    assert_eq!(call!(lt_ui32(3, 4294967294)), true);
-    assert_eq!(call!(lt_ui32(3, 4294967295)), true);
-    assert_eq!(call!(lt_ui32(4, 2119154652)), true);
-    assert_eq!(call!(lt_ui32(4, 3002788344)), true);
-    assert_eq!(call!(lt_ui32(4, 3482297128)), true);
-    assert_eq!(call!(lt_ui32(4, 4294967294)), true);
-    assert_eq!(call!(lt_ui32(4, 4294967295)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_445() {
-    assert_eq!(call!(lt_ui32(2119154652, 3002788344)), true);
-    assert_eq!(call!(lt_ui32(2119154652, 3482297128)), true);
-    assert_eq!(call!(lt_ui32(2119154652, 4294967294)), true);
-    assert_eq!(call!(lt_ui32(2119154652, 4294967295)), true);
-    assert_eq!(call!(lt_ui32(3002788344, 3482297128)), true);
-    assert_eq!(call!(lt_ui32(3002788344, 4294967294)), true);
-    assert_eq!(call!(lt_ui32(3002788344, 4294967295)), true);
-    assert_eq!(call!(lt_ui32(3482297128, 4294967294)), true);
-    assert_eq!(call!(lt_ui32(3482297128, 4294967295)), true);
-    assert_eq!(call!(lt_ui32(4294967294, 4294967295)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_446() {
-    assert_eq!(call!(lt_ui64(0, 0)), false);
-    assert_eq!(call!(lt_ui64(1, 0)), false);
-    assert_eq!(call!(lt_ui64(1, 1)), false);
-    assert_eq!(call!(lt_ui64(2, 0)), false);
-    assert_eq!(call!(lt_ui64(2, 1)), false);
-    assert_eq!(call!(lt_ui64(2, 2)), false);
-    assert_eq!(call!(lt_ui64(3, 0)), false);
-    assert_eq!(call!(lt_ui64(3, 1)), false);
-    assert_eq!(call!(lt_ui64(3, 2)), false);
-    assert_eq!(call!(lt_ui64(3, 3)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_447() {
-    assert_eq!(call!(lt_ui64(4, 0)), false);
-    assert_eq!(call!(lt_ui64(4, 1)), false);
-    assert_eq!(call!(lt_ui64(4, 2)), false);
-    assert_eq!(call!(lt_ui64(4, 3)), false);
-    assert_eq!(call!(lt_ui64(4, 4)), false);
-    assert_eq!(call!(lt_ui64(191084152064409600, 0)), false);
-    assert_eq!(call!(lt_ui64(191084152064409600, 1)), false);
-    assert_eq!(call!(lt_ui64(191084152064409600, 2)), false);
-    assert_eq!(call!(lt_ui64(191084152064409600, 3)), false);
-    assert_eq!(call!(lt_ui64(191084152064409600, 4)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_448() {
-    assert_eq!(call!(lt_ui64(191084152064409600, 191084152064409600)), false);
-    assert_eq!(call!(lt_ui64(11015955194427482112, 0)), false);
-    assert_eq!(call!(lt_ui64(11015955194427482112, 1)), false);
-    assert_eq!(call!(lt_ui64(11015955194427482112, 2)), false);
-    assert_eq!(call!(lt_ui64(11015955194427482112, 3)), false);
-    assert_eq!(call!(lt_ui64(11015955194427482112, 4)), false);
-    assert_eq!(call!(lt_ui64(11015955194427482112, 191084152064409600)), false);
-    assert_eq!(call!(lt_ui64(11015955194427482112, 11015955194427482112)), false);
-    assert_eq!(call!(lt_ui64(16990600415051759616, 0)), false);
-    assert_eq!(call!(lt_ui64(16990600415051759616, 1)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_449() {
-    assert_eq!(call!(lt_ui64(16990600415051759616, 2)), false);
-    assert_eq!(call!(lt_ui64(16990600415051759616, 3)), false);
-    assert_eq!(call!(lt_ui64(16990600415051759616, 4)), false);
-    assert_eq!(call!(lt_ui64(16990600415051759616, 191084152064409600)), false);
-    assert_eq!(call!(lt_ui64(16990600415051759616, 11015955194427482112)), false);
-    assert_eq!(call!(lt_ui64(16990600415051759616, 16990600415051759616)), false);
-    assert_eq!(call!(lt_ui64(18446744073709551614, 0)), false);
-    assert_eq!(call!(lt_ui64(18446744073709551614, 1)), false);
-    assert_eq!(call!(lt_ui64(18446744073709551614, 2)), false);
-    assert_eq!(call!(lt_ui64(18446744073709551614, 3)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_450() {
-    assert_eq!(call!(lt_ui64(18446744073709551614, 4)), false);
-    assert_eq!(call!(lt_ui64(18446744073709551614, 191084152064409600)), false);
-    assert_eq!(call!(lt_ui64(18446744073709551614, 11015955194427482112)), false);
-    assert_eq!(call!(lt_ui64(18446744073709551614, 16990600415051759616)), false);
-    assert_eq!(call!(lt_ui64(18446744073709551614, 18446744073709551614)), false);
-    assert_eq!(call!(lt_ui64(18446744073709551615, 0)), false);
-    assert_eq!(call!(lt_ui64(18446744073709551615, 1)), false);
-    assert_eq!(call!(lt_ui64(18446744073709551615, 2)), false);
-    assert_eq!(call!(lt_ui64(18446744073709551615, 3)), false);
-    assert_eq!(call!(lt_ui64(18446744073709551615, 4)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_451() {
-    assert_eq!(call!(lt_ui64(18446744073709551615, 191084152064409600)), false);
-    assert_eq!(call!(lt_ui64(18446744073709551615, 11015955194427482112)), false);
-    assert_eq!(call!(lt_ui64(18446744073709551615, 16990600415051759616)), false);
-    assert_eq!(call!(lt_ui64(18446744073709551615, 18446744073709551614)), false);
-    assert_eq!(call!(lt_ui64(18446744073709551615, 18446744073709551615)), false);
-    assert_eq!(call!(lt_ui64(0, 1)), true);
-    assert_eq!(call!(lt_ui64(0, 2)), true);
-    assert_eq!(call!(lt_ui64(0, 3)), true);
-    assert_eq!(call!(lt_ui64(0, 4)), true);
-    assert_eq!(call!(lt_ui64(0, 191084152064409600)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_452() {
-    assert_eq!(call!(lt_ui64(0, 11015955194427482112)), true);
-    assert_eq!(call!(lt_ui64(0, 16990600415051759616)), true);
-    assert_eq!(call!(lt_ui64(0, 18446744073709551614)), true);
-    assert_eq!(call!(lt_ui64(0, 18446744073709551615)), true);
-    assert_eq!(call!(lt_ui64(1, 2)), true);
-    assert_eq!(call!(lt_ui64(1, 3)), true);
-    assert_eq!(call!(lt_ui64(1, 4)), true);
-    assert_eq!(call!(lt_ui64(1, 191084152064409600)), true);
-    assert_eq!(call!(lt_ui64(1, 11015955194427482112)), true);
-    assert_eq!(call!(lt_ui64(1, 16990600415051759616)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_453() {
-    assert_eq!(call!(lt_ui64(1, 18446744073709551614)), true);
-    assert_eq!(call!(lt_ui64(1, 18446744073709551615)), true);
-    assert_eq!(call!(lt_ui64(2, 3)), true);
-    assert_eq!(call!(lt_ui64(2, 4)), true);
-    assert_eq!(call!(lt_ui64(2, 191084152064409600)), true);
-    assert_eq!(call!(lt_ui64(2, 11015955194427482112)), true);
-    assert_eq!(call!(lt_ui64(2, 16990600415051759616)), true);
-    assert_eq!(call!(lt_ui64(2, 18446744073709551614)), true);
-    assert_eq!(call!(lt_ui64(2, 18446744073709551615)), true);
-    assert_eq!(call!(lt_ui64(3, 4)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_454() {
-    assert_eq!(call!(lt_ui64(3, 191084152064409600)), true);
-    assert_eq!(call!(lt_ui64(3, 11015955194427482112)), true);
-    assert_eq!(call!(lt_ui64(3, 16990600415051759616)), true);
-    assert_eq!(call!(lt_ui64(3, 18446744073709551614)), true);
-    assert_eq!(call!(lt_ui64(3, 18446744073709551615)), true);
-    assert_eq!(call!(lt_ui64(4, 191084152064409600)), true);
-    assert_eq!(call!(lt_ui64(4, 11015955194427482112)), true);
-    assert_eq!(call!(lt_ui64(4, 16990600415051759616)), true);
-    assert_eq!(call!(lt_ui64(4, 18446744073709551614)), true);
-    assert_eq!(call!(lt_ui64(4, 18446744073709551615)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_455() {
-    assert_eq!(call!(lt_ui64(191084152064409600, 11015955194427482112)), true);
-    assert_eq!(call!(lt_ui64(191084152064409600, 16990600415051759616)), true);
-    assert_eq!(call!(lt_ui64(191084152064409600, 18446744073709551614)), true);
-    assert_eq!(call!(lt_ui64(191084152064409600, 18446744073709551615)), true);
-    assert_eq!(call!(lt_ui64(11015955194427482112, 16990600415051759616)), true);
-    assert_eq!(call!(lt_ui64(11015955194427482112, 18446744073709551614)), true);
-    assert_eq!(call!(lt_ui64(11015955194427482112, 18446744073709551615)), true);
-    assert_eq!(call!(lt_ui64(16990600415051759616, 18446744073709551614)), true);
-    assert_eq!(call!(lt_ui64(16990600415051759616, 18446744073709551615)), true);
-    assert_eq!(call!(lt_ui64(18446744073709551614, 18446744073709551615)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_456() {
-    assert_eq!(call!(lt_ui8(0, 0)), false);
-    assert_eq!(call!(lt_ui8(1, 0)), false);
-    assert_eq!(call!(lt_ui8(1, 1)), false);
-    assert_eq!(call!(lt_ui8(2, 0)), false);
-    assert_eq!(call!(lt_ui8(2, 1)), false);
-    assert_eq!(call!(lt_ui8(2, 2)), false);
-    assert_eq!(call!(lt_ui8(3, 0)), false);
-    assert_eq!(call!(lt_ui8(3, 1)), false);
-    assert_eq!(call!(lt_ui8(3, 2)), false);
-    assert_eq!(call!(lt_ui8(3, 3)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_457() {
-    assert_eq!(call!(lt_ui8(4, 0)), false);
-    assert_eq!(call!(lt_ui8(4, 1)), false);
-    assert_eq!(call!(lt_ui8(4, 2)), false);
-    assert_eq!(call!(lt_ui8(4, 3)), false);
-    assert_eq!(call!(lt_ui8(4, 4)), false);
-    assert_eq!(call!(lt_ui8(72, 0)), false);
-    assert_eq!(call!(lt_ui8(72, 1)), false);
-    assert_eq!(call!(lt_ui8(72, 2)), false);
-    assert_eq!(call!(lt_ui8(72, 3)), false);
-    assert_eq!(call!(lt_ui8(72, 4)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_458() {
-    assert_eq!(call!(lt_ui8(72, 72)), false);
-    assert_eq!(call!(lt_ui8(100, 0)), false);
-    assert_eq!(call!(lt_ui8(100, 1)), false);
-    assert_eq!(call!(lt_ui8(100, 2)), false);
-    assert_eq!(call!(lt_ui8(100, 3)), false);
-    assert_eq!(call!(lt_ui8(100, 4)), false);
-    assert_eq!(call!(lt_ui8(100, 72)), false);
-    assert_eq!(call!(lt_ui8(100, 100)), false);
-    assert_eq!(call!(lt_ui8(162, 0)), false);
-    assert_eq!(call!(lt_ui8(162, 1)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_459() {
-    assert_eq!(call!(lt_ui8(162, 2)), false);
-    assert_eq!(call!(lt_ui8(162, 3)), false);
-    assert_eq!(call!(lt_ui8(162, 4)), false);
-    assert_eq!(call!(lt_ui8(162, 72)), false);
-    assert_eq!(call!(lt_ui8(162, 100)), false);
-    assert_eq!(call!(lt_ui8(162, 162)), false);
-    assert_eq!(call!(lt_ui8(254, 0)), false);
-    assert_eq!(call!(lt_ui8(254, 1)), false);
-    assert_eq!(call!(lt_ui8(254, 2)), false);
-    assert_eq!(call!(lt_ui8(254, 3)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_460() {
-    assert_eq!(call!(lt_ui8(254, 4)), false);
-    assert_eq!(call!(lt_ui8(254, 72)), false);
-    assert_eq!(call!(lt_ui8(254, 100)), false);
-    assert_eq!(call!(lt_ui8(254, 162)), false);
-    assert_eq!(call!(lt_ui8(254, 254)), false);
-    assert_eq!(call!(lt_ui8(255, 0)), false);
-    assert_eq!(call!(lt_ui8(255, 1)), false);
-    assert_eq!(call!(lt_ui8(255, 2)), false);
-    assert_eq!(call!(lt_ui8(255, 3)), false);
-    assert_eq!(call!(lt_ui8(255, 4)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_461() {
-    assert_eq!(call!(lt_ui8(255, 72)), false);
-    assert_eq!(call!(lt_ui8(255, 100)), false);
-    assert_eq!(call!(lt_ui8(255, 162)), false);
-    assert_eq!(call!(lt_ui8(255, 254)), false);
-    assert_eq!(call!(lt_ui8(255, 255)), false);
-    assert_eq!(call!(lt_ui8(0, 1)), true);
-    assert_eq!(call!(lt_ui8(0, 2)), true);
-    assert_eq!(call!(lt_ui8(0, 3)), true);
-    assert_eq!(call!(lt_ui8(0, 4)), true);
-    assert_eq!(call!(lt_ui8(0, 72)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_462() {
-    assert_eq!(call!(lt_ui8(0, 100)), true);
-    assert_eq!(call!(lt_ui8(0, 162)), true);
-    assert_eq!(call!(lt_ui8(0, 254)), true);
-    assert_eq!(call!(lt_ui8(0, 255)), true);
-    assert_eq!(call!(lt_ui8(1, 2)), true);
-    assert_eq!(call!(lt_ui8(1, 3)), true);
-    assert_eq!(call!(lt_ui8(1, 4)), true);
-    assert_eq!(call!(lt_ui8(1, 72)), true);
-    assert_eq!(call!(lt_ui8(1, 100)), true);
-    assert_eq!(call!(lt_ui8(1, 162)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_463() {
-    assert_eq!(call!(lt_ui8(1, 254)), true);
-    assert_eq!(call!(lt_ui8(1, 255)), true);
-    assert_eq!(call!(lt_ui8(2, 3)), true);
-    assert_eq!(call!(lt_ui8(2, 4)), true);
-    assert_eq!(call!(lt_ui8(2, 72)), true);
-    assert_eq!(call!(lt_ui8(2, 100)), true);
-    assert_eq!(call!(lt_ui8(2, 162)), true);
-    assert_eq!(call!(lt_ui8(2, 254)), true);
-    assert_eq!(call!(lt_ui8(2, 255)), true);
-    assert_eq!(call!(lt_ui8(3, 4)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_464() {
-    assert_eq!(call!(lt_ui8(3, 72)), true);
-    assert_eq!(call!(lt_ui8(3, 100)), true);
-    assert_eq!(call!(lt_ui8(3, 162)), true);
-    assert_eq!(call!(lt_ui8(3, 254)), true);
-    assert_eq!(call!(lt_ui8(3, 255)), true);
-    assert_eq!(call!(lt_ui8(4, 72)), true);
-    assert_eq!(call!(lt_ui8(4, 100)), true);
-    assert_eq!(call!(lt_ui8(4, 162)), true);
-    assert_eq!(call!(lt_ui8(4, 254)), true);
-    assert_eq!(call!(lt_ui8(4, 255)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_465() {
-    assert_eq!(call!(lt_ui8(72, 100)), true);
-    assert_eq!(call!(lt_ui8(72, 162)), true);
-    assert_eq!(call!(lt_ui8(72, 254)), true);
-    assert_eq!(call!(lt_ui8(72, 255)), true);
-    assert_eq!(call!(lt_ui8(100, 162)), true);
-    assert_eq!(call!(lt_ui8(100, 254)), true);
-    assert_eq!(call!(lt_ui8(100, 255)), true);
-    assert_eq!(call!(lt_ui8(162, 254)), true);
-    assert_eq!(call!(lt_ui8(162, 255)), true);
-    assert_eq!(call!(lt_ui8(254, 255)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_466() {
-    assert_eq!(call!(ne_si16(-32768, -32768)), false);
-    assert_eq!(call!(ne_si16(-32767, -32767)), false);
-    assert_eq!(call!(ne_si16(-32547, -32547)), false);
-    assert_eq!(call!(ne_si16(0, 0)), false);
-    assert_eq!(call!(ne_si16(1, 1)), false);
-    assert_eq!(call!(ne_si16(2, 2)), false);
-    assert_eq!(call!(ne_si16(3, 3)), false);
-    assert_eq!(call!(ne_si16(4, 4)), false);
-    assert_eq!(call!(ne_si16(10486, 10486)), false);
-    assert_eq!(call!(ne_si16(16514, 16514)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_467() {
-    assert_eq!(call!(ne_si16(32766, 32766)), false);
-    assert_eq!(call!(ne_si16(32767, 32767)), false);
-    assert_eq!(call!(ne_si16(-32768, -32767)), true);
-    assert_eq!(call!(ne_si16(-32768, -32547)), true);
-    assert_eq!(call!(ne_si16(-32768, 0)), true);
-    assert_eq!(call!(ne_si16(-32768, 1)), true);
-    assert_eq!(call!(ne_si16(-32768, 2)), true);
-    assert_eq!(call!(ne_si16(-32768, 3)), true);
-    assert_eq!(call!(ne_si16(-32768, 4)), true);
-    assert_eq!(call!(ne_si16(-32768, 10486)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_468() {
-    assert_eq!(call!(ne_si16(-32768, 16514)), true);
-    assert_eq!(call!(ne_si16(-32768, 32766)), true);
-    assert_eq!(call!(ne_si16(-32768, 32767)), true);
-    assert_eq!(call!(ne_si16(-32767, -32768)), true);
-    assert_eq!(call!(ne_si16(-32767, -32547)), true);
-    assert_eq!(call!(ne_si16(-32767, 0)), true);
-    assert_eq!(call!(ne_si16(-32767, 1)), true);
-    assert_eq!(call!(ne_si16(-32767, 2)), true);
-    assert_eq!(call!(ne_si16(-32767, 3)), true);
-    assert_eq!(call!(ne_si16(-32767, 4)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_469() {
-    assert_eq!(call!(ne_si16(-32767, 10486)), true);
-    assert_eq!(call!(ne_si16(-32767, 16514)), true);
-    assert_eq!(call!(ne_si16(-32767, 32766)), true);
-    assert_eq!(call!(ne_si16(-32767, 32767)), true);
-    assert_eq!(call!(ne_si16(-32547, -32768)), true);
-    assert_eq!(call!(ne_si16(-32547, -32767)), true);
-    assert_eq!(call!(ne_si16(-32547, 0)), true);
-    assert_eq!(call!(ne_si16(-32547, 1)), true);
-    assert_eq!(call!(ne_si16(-32547, 2)), true);
-    assert_eq!(call!(ne_si16(-32547, 3)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_470() {
-    assert_eq!(call!(ne_si16(-32547, 4)), true);
-    assert_eq!(call!(ne_si16(-32547, 10486)), true);
-    assert_eq!(call!(ne_si16(-32547, 16514)), true);
-    assert_eq!(call!(ne_si16(-32547, 32766)), true);
-    assert_eq!(call!(ne_si16(-32547, 32767)), true);
-    assert_eq!(call!(ne_si16(0, -32768)), true);
-    assert_eq!(call!(ne_si16(0, -32767)), true);
-    assert_eq!(call!(ne_si16(0, -32547)), true);
-    assert_eq!(call!(ne_si16(0, 1)), true);
-    assert_eq!(call!(ne_si16(0, 2)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_471() {
-    assert_eq!(call!(ne_si16(0, 3)), true);
-    assert_eq!(call!(ne_si16(0, 4)), true);
-    assert_eq!(call!(ne_si16(0, 10486)), true);
-    assert_eq!(call!(ne_si16(0, 16514)), true);
-    assert_eq!(call!(ne_si16(0, 32766)), true);
-    assert_eq!(call!(ne_si16(0, 32767)), true);
-    assert_eq!(call!(ne_si16(1, -32768)), true);
-    assert_eq!(call!(ne_si16(1, -32767)), true);
-    assert_eq!(call!(ne_si16(1, -32547)), true);
-    assert_eq!(call!(ne_si16(1, 0)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_472() {
-    assert_eq!(call!(ne_si16(1, 2)), true);
-    assert_eq!(call!(ne_si16(1, 3)), true);
-    assert_eq!(call!(ne_si16(1, 4)), true);
-    assert_eq!(call!(ne_si16(1, 10486)), true);
-    assert_eq!(call!(ne_si16(1, 16514)), true);
-    assert_eq!(call!(ne_si16(1, 32766)), true);
-    assert_eq!(call!(ne_si16(1, 32767)), true);
-    assert_eq!(call!(ne_si16(2, -32768)), true);
-    assert_eq!(call!(ne_si16(2, -32767)), true);
-    assert_eq!(call!(ne_si16(2, -32547)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_473() {
-    assert_eq!(call!(ne_si16(2, 0)), true);
-    assert_eq!(call!(ne_si16(2, 1)), true);
-    assert_eq!(call!(ne_si16(2, 3)), true);
-    assert_eq!(call!(ne_si16(2, 4)), true);
-    assert_eq!(call!(ne_si16(2, 10486)), true);
-    assert_eq!(call!(ne_si16(2, 16514)), true);
-    assert_eq!(call!(ne_si16(2, 32766)), true);
-    assert_eq!(call!(ne_si16(2, 32767)), true);
-    assert_eq!(call!(ne_si16(3, -32768)), true);
-    assert_eq!(call!(ne_si16(3, -32767)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_474() {
-    assert_eq!(call!(ne_si16(3, -32547)), true);
-    assert_eq!(call!(ne_si16(3, 0)), true);
-    assert_eq!(call!(ne_si16(3, 1)), true);
-    assert_eq!(call!(ne_si16(3, 2)), true);
-    assert_eq!(call!(ne_si16(3, 4)), true);
-    assert_eq!(call!(ne_si16(3, 10486)), true);
-    assert_eq!(call!(ne_si16(3, 16514)), true);
-    assert_eq!(call!(ne_si16(3, 32766)), true);
-    assert_eq!(call!(ne_si16(3, 32767)), true);
-    assert_eq!(call!(ne_si16(4, -32768)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_475() {
-    assert_eq!(call!(ne_si16(4, -32767)), true);
-    assert_eq!(call!(ne_si16(4, -32547)), true);
-    assert_eq!(call!(ne_si16(4, 0)), true);
-    assert_eq!(call!(ne_si16(4, 1)), true);
-    assert_eq!(call!(ne_si16(4, 2)), true);
-    assert_eq!(call!(ne_si16(4, 3)), true);
-    assert_eq!(call!(ne_si16(4, 10486)), true);
-    assert_eq!(call!(ne_si16(4, 16514)), true);
-    assert_eq!(call!(ne_si16(4, 32766)), true);
-    assert_eq!(call!(ne_si16(4, 32767)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_476() {
-    assert_eq!(call!(ne_si16(10486, -32768)), true);
-    assert_eq!(call!(ne_si16(10486, -32767)), true);
-    assert_eq!(call!(ne_si16(10486, -32547)), true);
-    assert_eq!(call!(ne_si16(10486, 0)), true);
-    assert_eq!(call!(ne_si16(10486, 1)), true);
-    assert_eq!(call!(ne_si16(10486, 2)), true);
-    assert_eq!(call!(ne_si16(10486, 3)), true);
-    assert_eq!(call!(ne_si16(10486, 4)), true);
-    assert_eq!(call!(ne_si16(10486, 16514)), true);
-    assert_eq!(call!(ne_si16(10486, 32766)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_477() {
-    assert_eq!(call!(ne_si16(10486, 32767)), true);
-    assert_eq!(call!(ne_si16(16514, -32768)), true);
-    assert_eq!(call!(ne_si16(16514, -32767)), true);
-    assert_eq!(call!(ne_si16(16514, -32547)), true);
-    assert_eq!(call!(ne_si16(16514, 0)), true);
-    assert_eq!(call!(ne_si16(16514, 1)), true);
-    assert_eq!(call!(ne_si16(16514, 2)), true);
-    assert_eq!(call!(ne_si16(16514, 3)), true);
-    assert_eq!(call!(ne_si16(16514, 4)), true);
-    assert_eq!(call!(ne_si16(16514, 10486)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_478() {
-    assert_eq!(call!(ne_si16(16514, 32766)), true);
-    assert_eq!(call!(ne_si16(16514, 32767)), true);
-    assert_eq!(call!(ne_si16(32766, -32768)), true);
-    assert_eq!(call!(ne_si16(32766, -32767)), true);
-    assert_eq!(call!(ne_si16(32766, -32547)), true);
-    assert_eq!(call!(ne_si16(32766, 0)), true);
-    assert_eq!(call!(ne_si16(32766, 1)), true);
-    assert_eq!(call!(ne_si16(32766, 2)), true);
-    assert_eq!(call!(ne_si16(32766, 3)), true);
-    assert_eq!(call!(ne_si16(32766, 4)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_479() {
-    assert_eq!(call!(ne_si16(32766, 10486)), true);
-    assert_eq!(call!(ne_si16(32766, 16514)), true);
-    assert_eq!(call!(ne_si16(32766, 32767)), true);
-    assert_eq!(call!(ne_si16(32767, -32768)), true);
-    assert_eq!(call!(ne_si16(32767, -32767)), true);
-    assert_eq!(call!(ne_si16(32767, -32547)), true);
-    assert_eq!(call!(ne_si16(32767, 0)), true);
-    assert_eq!(call!(ne_si16(32767, 1)), true);
-    assert_eq!(call!(ne_si16(32767, 2)), true);
-    assert_eq!(call!(ne_si16(32767, 3)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_480() {
-    assert_eq!(call!(ne_si16(32767, 4)), true);
-    assert_eq!(call!(ne_si16(32767, 10486)), true);
-    assert_eq!(call!(ne_si16(32767, 16514)), true);
-    assert_eq!(call!(ne_si16(32767, 32766)), true);
-    assert_eq!(call!(ne_si32(-2147483648, -2147483648)), false);
-    assert_eq!(call!(ne_si32(-2147483647, -2147483647)), false);
-    assert_eq!(call!(ne_si32(-1713183800, -1713183800)), false);
-    assert_eq!(call!(ne_si32(-1252582164, -1252582164)), false);
-    assert_eq!(call!(ne_si32(-1035405763, -1035405763)), false);
-    assert_eq!(call!(ne_si32(0, 0)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_481() {
-    assert_eq!(call!(ne_si32(1, 1)), false);
-    assert_eq!(call!(ne_si32(2, 2)), false);
-    assert_eq!(call!(ne_si32(3, 3)), false);
-    assert_eq!(call!(ne_si32(4, 4)), false);
-    assert_eq!(call!(ne_si32(2147483646, 2147483646)), false);
-    assert_eq!(call!(ne_si32(2147483647, 2147483647)), false);
-    assert_eq!(call!(ne_si32(-2147483648, -2147483647)), true);
-    assert_eq!(call!(ne_si32(-2147483648, -1713183800)), true);
-    assert_eq!(call!(ne_si32(-2147483648, -1252582164)), true);
-    assert_eq!(call!(ne_si32(-2147483648, -1035405763)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_482() {
-    assert_eq!(call!(ne_si32(-2147483648, 0)), true);
-    assert_eq!(call!(ne_si32(-2147483648, 1)), true);
-    assert_eq!(call!(ne_si32(-2147483648, 2)), true);
-    assert_eq!(call!(ne_si32(-2147483648, 3)), true);
-    assert_eq!(call!(ne_si32(-2147483648, 4)), true);
-    assert_eq!(call!(ne_si32(-2147483648, 2147483646)), true);
-    assert_eq!(call!(ne_si32(-2147483648, 2147483647)), true);
-    assert_eq!(call!(ne_si32(-2147483647, -2147483648)), true);
-    assert_eq!(call!(ne_si32(-2147483647, -1713183800)), true);
-    assert_eq!(call!(ne_si32(-2147483647, -1252582164)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_483() {
-    assert_eq!(call!(ne_si32(-2147483647, -1035405763)), true);
-    assert_eq!(call!(ne_si32(-2147483647, 0)), true);
-    assert_eq!(call!(ne_si32(-2147483647, 1)), true);
-    assert_eq!(call!(ne_si32(-2147483647, 2)), true);
-    assert_eq!(call!(ne_si32(-2147483647, 3)), true);
-    assert_eq!(call!(ne_si32(-2147483647, 4)), true);
-    assert_eq!(call!(ne_si32(-2147483647, 2147483646)), true);
-    assert_eq!(call!(ne_si32(-2147483647, 2147483647)), true);
-    assert_eq!(call!(ne_si32(-1713183800, -2147483648)), true);
-    assert_eq!(call!(ne_si32(-1713183800, -2147483647)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_484() {
-    assert_eq!(call!(ne_si32(-1713183800, -1252582164)), true);
-    assert_eq!(call!(ne_si32(-1713183800, -1035405763)), true);
-    assert_eq!(call!(ne_si32(-1713183800, 0)), true);
-    assert_eq!(call!(ne_si32(-1713183800, 1)), true);
-    assert_eq!(call!(ne_si32(-1713183800, 2)), true);
-    assert_eq!(call!(ne_si32(-1713183800, 3)), true);
-    assert_eq!(call!(ne_si32(-1713183800, 4)), true);
-    assert_eq!(call!(ne_si32(-1713183800, 2147483646)), true);
-    assert_eq!(call!(ne_si32(-1713183800, 2147483647)), true);
-    assert_eq!(call!(ne_si32(-1252582164, -2147483648)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_485() {
-    assert_eq!(call!(ne_si32(-1252582164, -2147483647)), true);
-    assert_eq!(call!(ne_si32(-1252582164, -1713183800)), true);
-    assert_eq!(call!(ne_si32(-1252582164, -1035405763)), true);
-    assert_eq!(call!(ne_si32(-1252582164, 0)), true);
-    assert_eq!(call!(ne_si32(-1252582164, 1)), true);
-    assert_eq!(call!(ne_si32(-1252582164, 2)), true);
-    assert_eq!(call!(ne_si32(-1252582164, 3)), true);
-    assert_eq!(call!(ne_si32(-1252582164, 4)), true);
-    assert_eq!(call!(ne_si32(-1252582164, 2147483646)), true);
-    assert_eq!(call!(ne_si32(-1252582164, 2147483647)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_486() {
-    assert_eq!(call!(ne_si32(-1035405763, -2147483648)), true);
-    assert_eq!(call!(ne_si32(-1035405763, -2147483647)), true);
-    assert_eq!(call!(ne_si32(-1035405763, -1713183800)), true);
-    assert_eq!(call!(ne_si32(-1035405763, -1252582164)), true);
-    assert_eq!(call!(ne_si32(-1035405763, 0)), true);
-    assert_eq!(call!(ne_si32(-1035405763, 1)), true);
-    assert_eq!(call!(ne_si32(-1035405763, 2)), true);
-    assert_eq!(call!(ne_si32(-1035405763, 3)), true);
-    assert_eq!(call!(ne_si32(-1035405763, 4)), true);
-    assert_eq!(call!(ne_si32(-1035405763, 2147483646)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_487() {
-    assert_eq!(call!(ne_si32(-1035405763, 2147483647)), true);
-    assert_eq!(call!(ne_si32(0, -2147483648)), true);
-    assert_eq!(call!(ne_si32(0, -2147483647)), true);
-    assert_eq!(call!(ne_si32(0, -1713183800)), true);
-    assert_eq!(call!(ne_si32(0, -1252582164)), true);
-    assert_eq!(call!(ne_si32(0, -1035405763)), true);
-    assert_eq!(call!(ne_si32(0, 1)), true);
-    assert_eq!(call!(ne_si32(0, 2)), true);
-    assert_eq!(call!(ne_si32(0, 3)), true);
-    assert_eq!(call!(ne_si32(0, 4)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_488() {
-    assert_eq!(call!(ne_si32(0, 2147483646)), true);
-    assert_eq!(call!(ne_si32(0, 2147483647)), true);
-    assert_eq!(call!(ne_si32(1, -2147483648)), true);
-    assert_eq!(call!(ne_si32(1, -2147483647)), true);
-    assert_eq!(call!(ne_si32(1, -1713183800)), true);
-    assert_eq!(call!(ne_si32(1, -1252582164)), true);
-    assert_eq!(call!(ne_si32(1, -1035405763)), true);
-    assert_eq!(call!(ne_si32(1, 0)), true);
-    assert_eq!(call!(ne_si32(1, 2)), true);
-    assert_eq!(call!(ne_si32(1, 3)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_489() {
-    assert_eq!(call!(ne_si32(1, 4)), true);
-    assert_eq!(call!(ne_si32(1, 2147483646)), true);
-    assert_eq!(call!(ne_si32(1, 2147483647)), true);
-    assert_eq!(call!(ne_si32(2, -2147483648)), true);
-    assert_eq!(call!(ne_si32(2, -2147483647)), true);
-    assert_eq!(call!(ne_si32(2, -1713183800)), true);
-    assert_eq!(call!(ne_si32(2, -1252582164)), true);
-    assert_eq!(call!(ne_si32(2, -1035405763)), true);
-    assert_eq!(call!(ne_si32(2, 0)), true);
-    assert_eq!(call!(ne_si32(2, 1)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_490() {
-    assert_eq!(call!(ne_si32(2, 3)), true);
-    assert_eq!(call!(ne_si32(2, 4)), true);
-    assert_eq!(call!(ne_si32(2, 2147483646)), true);
-    assert_eq!(call!(ne_si32(2, 2147483647)), true);
-    assert_eq!(call!(ne_si32(3, -2147483648)), true);
-    assert_eq!(call!(ne_si32(3, -2147483647)), true);
-    assert_eq!(call!(ne_si32(3, -1713183800)), true);
-    assert_eq!(call!(ne_si32(3, -1252582164)), true);
-    assert_eq!(call!(ne_si32(3, -1035405763)), true);
-    assert_eq!(call!(ne_si32(3, 0)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_491() {
-    assert_eq!(call!(ne_si32(3, 1)), true);
-    assert_eq!(call!(ne_si32(3, 2)), true);
-    assert_eq!(call!(ne_si32(3, 4)), true);
-    assert_eq!(call!(ne_si32(3, 2147483646)), true);
-    assert_eq!(call!(ne_si32(3, 2147483647)), true);
-    assert_eq!(call!(ne_si32(4, -2147483648)), true);
-    assert_eq!(call!(ne_si32(4, -2147483647)), true);
-    assert_eq!(call!(ne_si32(4, -1713183800)), true);
-    assert_eq!(call!(ne_si32(4, -1252582164)), true);
-    assert_eq!(call!(ne_si32(4, -1035405763)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_492() {
-    assert_eq!(call!(ne_si32(4, 0)), true);
-    assert_eq!(call!(ne_si32(4, 1)), true);
-    assert_eq!(call!(ne_si32(4, 2)), true);
-    assert_eq!(call!(ne_si32(4, 3)), true);
-    assert_eq!(call!(ne_si32(4, 2147483646)), true);
-    assert_eq!(call!(ne_si32(4, 2147483647)), true);
-    assert_eq!(call!(ne_si32(2147483646, -2147483648)), true);
-    assert_eq!(call!(ne_si32(2147483646, -2147483647)), true);
-    assert_eq!(call!(ne_si32(2147483646, -1713183800)), true);
-    assert_eq!(call!(ne_si32(2147483646, -1252582164)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_493() {
-    assert_eq!(call!(ne_si32(2147483646, -1035405763)), true);
-    assert_eq!(call!(ne_si32(2147483646, 0)), true);
-    assert_eq!(call!(ne_si32(2147483646, 1)), true);
-    assert_eq!(call!(ne_si32(2147483646, 2)), true);
-    assert_eq!(call!(ne_si32(2147483646, 3)), true);
-    assert_eq!(call!(ne_si32(2147483646, 4)), true);
-    assert_eq!(call!(ne_si32(2147483646, 2147483647)), true);
-    assert_eq!(call!(ne_si32(2147483647, -2147483648)), true);
-    assert_eq!(call!(ne_si32(2147483647, -2147483647)), true);
-    assert_eq!(call!(ne_si32(2147483647, -1713183800)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_494() {
-    assert_eq!(call!(ne_si32(2147483647, -1252582164)), true);
-    assert_eq!(call!(ne_si32(2147483647, -1035405763)), true);
-    assert_eq!(call!(ne_si32(2147483647, 0)), true);
-    assert_eq!(call!(ne_si32(2147483647, 1)), true);
-    assert_eq!(call!(ne_si32(2147483647, 2)), true);
-    assert_eq!(call!(ne_si32(2147483647, 3)), true);
-    assert_eq!(call!(ne_si32(2147483647, 4)), true);
-    assert_eq!(call!(ne_si32(2147483647, 2147483646)), true);
-    assert_eq!(call!(ne_si64(-9223372036854775808, -9223372036854775808)), false);
-    assert_eq!(call!(ne_si64(-9223372036854775807, -9223372036854775807)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_495() {
-    assert_eq!(call!(ne_si64(-1741927215160008704, -1741927215160008704)), false);
-    assert_eq!(call!(ne_si64(-1328271339354574848, -1328271339354574848)), false);
-    assert_eq!(call!(ne_si64(0, 0)), false);
-    assert_eq!(call!(ne_si64(1, 1)), false);
-    assert_eq!(call!(ne_si64(2, 2)), false);
-    assert_eq!(call!(ne_si64(3, 3)), false);
-    assert_eq!(call!(ne_si64(4, 4)), false);
-    assert_eq!(call!(ne_si64(5577148965131116544, 5577148965131116544)), false);
-    assert_eq!(call!(ne_si64(9223372036854775806, 9223372036854775806)), false);
-    assert_eq!(call!(ne_si64(9223372036854775807, 9223372036854775807)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_496() {
-    assert_eq!(call!(ne_si64(-9223372036854775808, -9223372036854775807)), true);
-    assert_eq!(call!(ne_si64(-9223372036854775808, -1741927215160008704)), true);
-    assert_eq!(call!(ne_si64(-9223372036854775808, -1328271339354574848)), true);
-    assert_eq!(call!(ne_si64(-9223372036854775808, 0)), true);
-    assert_eq!(call!(ne_si64(-9223372036854775808, 1)), true);
-    assert_eq!(call!(ne_si64(-9223372036854775808, 2)), true);
-    assert_eq!(call!(ne_si64(-9223372036854775808, 3)), true);
-    assert_eq!(call!(ne_si64(-9223372036854775808, 4)), true);
-    assert_eq!(call!(ne_si64(-9223372036854775808, 5577148965131116544)), true);
-    assert_eq!(call!(ne_si64(-9223372036854775808, 9223372036854775806)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_497() {
-    assert_eq!(call!(ne_si64(-9223372036854775808, 9223372036854775807)), true);
-    assert_eq!(call!(ne_si64(-9223372036854775807, -9223372036854775808)), true);
-    assert_eq!(call!(ne_si64(-9223372036854775807, -1741927215160008704)), true);
-    assert_eq!(call!(ne_si64(-9223372036854775807, -1328271339354574848)), true);
-    assert_eq!(call!(ne_si64(-9223372036854775807, 0)), true);
-    assert_eq!(call!(ne_si64(-9223372036854775807, 1)), true);
-    assert_eq!(call!(ne_si64(-9223372036854775807, 2)), true);
-    assert_eq!(call!(ne_si64(-9223372036854775807, 3)), true);
-    assert_eq!(call!(ne_si64(-9223372036854775807, 4)), true);
-    assert_eq!(call!(ne_si64(-9223372036854775807, 5577148965131116544)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_498() {
-    assert_eq!(call!(ne_si64(-9223372036854775807, 9223372036854775806)), true);
-    assert_eq!(call!(ne_si64(-9223372036854775807, 9223372036854775807)), true);
-    assert_eq!(call!(ne_si64(-1741927215160008704, -9223372036854775808)), true);
-    assert_eq!(call!(ne_si64(-1741927215160008704, -9223372036854775807)), true);
-    assert_eq!(call!(ne_si64(-1741927215160008704, -1328271339354574848)), true);
-    assert_eq!(call!(ne_si64(-1741927215160008704, 0)), true);
-    assert_eq!(call!(ne_si64(-1741927215160008704, 1)), true);
-    assert_eq!(call!(ne_si64(-1741927215160008704, 2)), true);
-    assert_eq!(call!(ne_si64(-1741927215160008704, 3)), true);
-    assert_eq!(call!(ne_si64(-1741927215160008704, 4)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_499() {
-    assert_eq!(call!(ne_si64(-1741927215160008704, 5577148965131116544)), true);
-    assert_eq!(call!(ne_si64(-1741927215160008704, 9223372036854775806)), true);
-    assert_eq!(call!(ne_si64(-1741927215160008704, 9223372036854775807)), true);
-    assert_eq!(call!(ne_si64(-1328271339354574848, -9223372036854775808)), true);
-    assert_eq!(call!(ne_si64(-1328271339354574848, -9223372036854775807)), true);
-    assert_eq!(call!(ne_si64(-1328271339354574848, -1741927215160008704)), true);
-    assert_eq!(call!(ne_si64(-1328271339354574848, 0)), true);
-    assert_eq!(call!(ne_si64(-1328271339354574848, 1)), true);
-    assert_eq!(call!(ne_si64(-1328271339354574848, 2)), true);
-    assert_eq!(call!(ne_si64(-1328271339354574848, 3)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_500() {
-    assert_eq!(call!(ne_si64(-1328271339354574848, 4)), true);
-    assert_eq!(call!(ne_si64(-1328271339354574848, 5577148965131116544)), true);
-    assert_eq!(call!(ne_si64(-1328271339354574848, 9223372036854775806)), true);
-    assert_eq!(call!(ne_si64(-1328271339354574848, 9223372036854775807)), true);
-    assert_eq!(call!(ne_si64(0, -9223372036854775808)), true);
-    assert_eq!(call!(ne_si64(0, -9223372036854775807)), true);
-    assert_eq!(call!(ne_si64(0, -1741927215160008704)), true);
-    assert_eq!(call!(ne_si64(0, -1328271339354574848)), true);
-    assert_eq!(call!(ne_si64(0, 1)), true);
-    assert_eq!(call!(ne_si64(0, 2)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_501() {
-    assert_eq!(call!(ne_si64(0, 3)), true);
-    assert_eq!(call!(ne_si64(0, 4)), true);
-    assert_eq!(call!(ne_si64(0, 5577148965131116544)), true);
-    assert_eq!(call!(ne_si64(0, 9223372036854775806)), true);
-    assert_eq!(call!(ne_si64(0, 9223372036854775807)), true);
-    assert_eq!(call!(ne_si64(1, -9223372036854775808)), true);
-    assert_eq!(call!(ne_si64(1, -9223372036854775807)), true);
-    assert_eq!(call!(ne_si64(1, -1741927215160008704)), true);
-    assert_eq!(call!(ne_si64(1, -1328271339354574848)), true);
-    assert_eq!(call!(ne_si64(1, 0)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_502() {
-    assert_eq!(call!(ne_si64(1, 2)), true);
-    assert_eq!(call!(ne_si64(1, 3)), true);
-    assert_eq!(call!(ne_si64(1, 4)), true);
-    assert_eq!(call!(ne_si64(1, 5577148965131116544)), true);
-    assert_eq!(call!(ne_si64(1, 9223372036854775806)), true);
-    assert_eq!(call!(ne_si64(1, 9223372036854775807)), true);
-    assert_eq!(call!(ne_si64(2, -9223372036854775808)), true);
-    assert_eq!(call!(ne_si64(2, -9223372036854775807)), true);
-    assert_eq!(call!(ne_si64(2, -1741927215160008704)), true);
-    assert_eq!(call!(ne_si64(2, -1328271339354574848)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_503() {
-    assert_eq!(call!(ne_si64(2, 0)), true);
-    assert_eq!(call!(ne_si64(2, 1)), true);
-    assert_eq!(call!(ne_si64(2, 3)), true);
-    assert_eq!(call!(ne_si64(2, 4)), true);
-    assert_eq!(call!(ne_si64(2, 5577148965131116544)), true);
-    assert_eq!(call!(ne_si64(2, 9223372036854775806)), true);
-    assert_eq!(call!(ne_si64(2, 9223372036854775807)), true);
-    assert_eq!(call!(ne_si64(3, -9223372036854775808)), true);
-    assert_eq!(call!(ne_si64(3, -9223372036854775807)), true);
-    assert_eq!(call!(ne_si64(3, -1741927215160008704)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_504() {
-    assert_eq!(call!(ne_si64(3, -1328271339354574848)), true);
-    assert_eq!(call!(ne_si64(3, 0)), true);
-    assert_eq!(call!(ne_si64(3, 1)), true);
-    assert_eq!(call!(ne_si64(3, 2)), true);
-    assert_eq!(call!(ne_si64(3, 4)), true);
-    assert_eq!(call!(ne_si64(3, 5577148965131116544)), true);
-    assert_eq!(call!(ne_si64(3, 9223372036854775806)), true);
-    assert_eq!(call!(ne_si64(3, 9223372036854775807)), true);
-    assert_eq!(call!(ne_si64(4, -9223372036854775808)), true);
-    assert_eq!(call!(ne_si64(4, -9223372036854775807)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_505() {
-    assert_eq!(call!(ne_si64(4, -1741927215160008704)), true);
-    assert_eq!(call!(ne_si64(4, -1328271339354574848)), true);
-    assert_eq!(call!(ne_si64(4, 0)), true);
-    assert_eq!(call!(ne_si64(4, 1)), true);
-    assert_eq!(call!(ne_si64(4, 2)), true);
-    assert_eq!(call!(ne_si64(4, 3)), true);
-    assert_eq!(call!(ne_si64(4, 5577148965131116544)), true);
-    assert_eq!(call!(ne_si64(4, 9223372036854775806)), true);
-    assert_eq!(call!(ne_si64(4, 9223372036854775807)), true);
-    assert_eq!(call!(ne_si64(5577148965131116544, -9223372036854775808)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_506() {
-    assert_eq!(call!(ne_si64(5577148965131116544, -9223372036854775807)), true);
-    assert_eq!(call!(ne_si64(5577148965131116544, -1741927215160008704)), true);
-    assert_eq!(call!(ne_si64(5577148965131116544, -1328271339354574848)), true);
-    assert_eq!(call!(ne_si64(5577148965131116544, 0)), true);
-    assert_eq!(call!(ne_si64(5577148965131116544, 1)), true);
-    assert_eq!(call!(ne_si64(5577148965131116544, 2)), true);
-    assert_eq!(call!(ne_si64(5577148965131116544, 3)), true);
-    assert_eq!(call!(ne_si64(5577148965131116544, 4)), true);
-    assert_eq!(call!(ne_si64(5577148965131116544, 9223372036854775806)), true);
-    assert_eq!(call!(ne_si64(5577148965131116544, 9223372036854775807)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_507() {
-    assert_eq!(call!(ne_si64(9223372036854775806, -9223372036854775808)), true);
-    assert_eq!(call!(ne_si64(9223372036854775806, -9223372036854775807)), true);
-    assert_eq!(call!(ne_si64(9223372036854775806, -1741927215160008704)), true);
-    assert_eq!(call!(ne_si64(9223372036854775806, -1328271339354574848)), true);
-    assert_eq!(call!(ne_si64(9223372036854775806, 0)), true);
-    assert_eq!(call!(ne_si64(9223372036854775806, 1)), true);
-    assert_eq!(call!(ne_si64(9223372036854775806, 2)), true);
-    assert_eq!(call!(ne_si64(9223372036854775806, 3)), true);
-    assert_eq!(call!(ne_si64(9223372036854775806, 4)), true);
-    assert_eq!(call!(ne_si64(9223372036854775806, 5577148965131116544)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_508() {
-    assert_eq!(call!(ne_si64(9223372036854775806, 9223372036854775807)), true);
-    assert_eq!(call!(ne_si64(9223372036854775807, -9223372036854775808)), true);
-    assert_eq!(call!(ne_si64(9223372036854775807, -9223372036854775807)), true);
-    assert_eq!(call!(ne_si64(9223372036854775807, -1741927215160008704)), true);
-    assert_eq!(call!(ne_si64(9223372036854775807, -1328271339354574848)), true);
-    assert_eq!(call!(ne_si64(9223372036854775807, 0)), true);
-    assert_eq!(call!(ne_si64(9223372036854775807, 1)), true);
-    assert_eq!(call!(ne_si64(9223372036854775807, 2)), true);
-    assert_eq!(call!(ne_si64(9223372036854775807, 3)), true);
-    assert_eq!(call!(ne_si64(9223372036854775807, 4)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_509() {
-    assert_eq!(call!(ne_si64(9223372036854775807, 5577148965131116544)), true);
-    assert_eq!(call!(ne_si64(9223372036854775807, 9223372036854775806)), true);
-    assert_eq!(call!(ne_si8(-128, -128)), false);
-    assert_eq!(call!(ne_si8(-127, -127)), false);
-    assert_eq!(call!(ne_si8(0, 0)), false);
-    assert_eq!(call!(ne_si8(1, 1)), false);
-    assert_eq!(call!(ne_si8(2, 2)), false);
-    assert_eq!(call!(ne_si8(3, 3)), false);
-    assert_eq!(call!(ne_si8(4, 4)), false);
-    assert_eq!(call!(ne_si8(16, 16)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_510() {
-    assert_eq!(call!(ne_si8(126, 126)), false);
-    assert_eq!(call!(ne_si8(127, 127)), false);
-    assert_eq!(call!(ne_si8(-128, -127)), true);
-    assert_eq!(call!(ne_si8(-128, 0)), true);
-    assert_eq!(call!(ne_si8(-128, 1)), true);
-    assert_eq!(call!(ne_si8(-128, 2)), true);
-    assert_eq!(call!(ne_si8(-128, 3)), true);
-    assert_eq!(call!(ne_si8(-128, 4)), true);
-    assert_eq!(call!(ne_si8(-128, 16)), true);
-    assert_eq!(call!(ne_si8(-128, 126)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_511() {
-    assert_eq!(call!(ne_si8(-128, 127)), true);
-    assert_eq!(call!(ne_si8(-127, -128)), true);
-    assert_eq!(call!(ne_si8(-127, 0)), true);
-    assert_eq!(call!(ne_si8(-127, 1)), true);
-    assert_eq!(call!(ne_si8(-127, 2)), true);
-    assert_eq!(call!(ne_si8(-127, 3)), true);
-    assert_eq!(call!(ne_si8(-127, 4)), true);
-    assert_eq!(call!(ne_si8(-127, 16)), true);
-    assert_eq!(call!(ne_si8(-127, 126)), true);
-    assert_eq!(call!(ne_si8(-127, 127)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_512() {
-    assert_eq!(call!(ne_si8(0, -128)), true);
-    assert_eq!(call!(ne_si8(0, -127)), true);
-    assert_eq!(call!(ne_si8(0, 1)), true);
-    assert_eq!(call!(ne_si8(0, 2)), true);
-    assert_eq!(call!(ne_si8(0, 3)), true);
-    assert_eq!(call!(ne_si8(0, 4)), true);
-    assert_eq!(call!(ne_si8(0, 16)), true);
-    assert_eq!(call!(ne_si8(0, 126)), true);
-    assert_eq!(call!(ne_si8(0, 127)), true);
-    assert_eq!(call!(ne_si8(1, -128)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_513() {
-    assert_eq!(call!(ne_si8(1, -127)), true);
-    assert_eq!(call!(ne_si8(1, 0)), true);
-    assert_eq!(call!(ne_si8(1, 2)), true);
-    assert_eq!(call!(ne_si8(1, 3)), true);
-    assert_eq!(call!(ne_si8(1, 4)), true);
-    assert_eq!(call!(ne_si8(1, 16)), true);
-    assert_eq!(call!(ne_si8(1, 126)), true);
-    assert_eq!(call!(ne_si8(1, 127)), true);
-    assert_eq!(call!(ne_si8(2, -128)), true);
-    assert_eq!(call!(ne_si8(2, -127)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_514() {
-    assert_eq!(call!(ne_si8(2, 0)), true);
-    assert_eq!(call!(ne_si8(2, 1)), true);
-    assert_eq!(call!(ne_si8(2, 3)), true);
-    assert_eq!(call!(ne_si8(2, 4)), true);
-    assert_eq!(call!(ne_si8(2, 16)), true);
-    assert_eq!(call!(ne_si8(2, 126)), true);
-    assert_eq!(call!(ne_si8(2, 127)), true);
-    assert_eq!(call!(ne_si8(3, -128)), true);
-    assert_eq!(call!(ne_si8(3, -127)), true);
-    assert_eq!(call!(ne_si8(3, 0)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_515() {
-    assert_eq!(call!(ne_si8(3, 1)), true);
-    assert_eq!(call!(ne_si8(3, 2)), true);
-    assert_eq!(call!(ne_si8(3, 4)), true);
-    assert_eq!(call!(ne_si8(3, 16)), true);
-    assert_eq!(call!(ne_si8(3, 126)), true);
-    assert_eq!(call!(ne_si8(3, 127)), true);
-    assert_eq!(call!(ne_si8(4, -128)), true);
-    assert_eq!(call!(ne_si8(4, -127)), true);
-    assert_eq!(call!(ne_si8(4, 0)), true);
-    assert_eq!(call!(ne_si8(4, 1)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_516() {
-    assert_eq!(call!(ne_si8(4, 2)), true);
-    assert_eq!(call!(ne_si8(4, 3)), true);
-    assert_eq!(call!(ne_si8(4, 16)), true);
-    assert_eq!(call!(ne_si8(4, 126)), true);
-    assert_eq!(call!(ne_si8(4, 127)), true);
-    assert_eq!(call!(ne_si8(16, -128)), true);
-    assert_eq!(call!(ne_si8(16, -127)), true);
-    assert_eq!(call!(ne_si8(16, 0)), true);
-    assert_eq!(call!(ne_si8(16, 1)), true);
-    assert_eq!(call!(ne_si8(16, 2)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_517() {
-    assert_eq!(call!(ne_si8(16, 3)), true);
-    assert_eq!(call!(ne_si8(16, 4)), true);
-    assert_eq!(call!(ne_si8(16, 126)), true);
-    assert_eq!(call!(ne_si8(16, 127)), true);
-    assert_eq!(call!(ne_si8(126, -128)), true);
-    assert_eq!(call!(ne_si8(126, -127)), true);
-    assert_eq!(call!(ne_si8(126, 0)), true);
-    assert_eq!(call!(ne_si8(126, 1)), true);
-    assert_eq!(call!(ne_si8(126, 2)), true);
-    assert_eq!(call!(ne_si8(126, 3)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_518() {
-    assert_eq!(call!(ne_si8(126, 4)), true);
-    assert_eq!(call!(ne_si8(126, 16)), true);
-    assert_eq!(call!(ne_si8(126, 127)), true);
-    assert_eq!(call!(ne_si8(127, -128)), true);
-    assert_eq!(call!(ne_si8(127, -127)), true);
-    assert_eq!(call!(ne_si8(127, 0)), true);
-    assert_eq!(call!(ne_si8(127, 1)), true);
-    assert_eq!(call!(ne_si8(127, 2)), true);
-    assert_eq!(call!(ne_si8(127, 3)), true);
-    assert_eq!(call!(ne_si8(127, 4)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_519() {
-    assert_eq!(call!(ne_si8(127, 16)), true);
-    assert_eq!(call!(ne_si8(127, 126)), true);
-    assert_eq!(call!(ne_ui16(0, 0)), false);
-    assert_eq!(call!(ne_ui16(1, 1)), false);
-    assert_eq!(call!(ne_ui16(2, 2)), false);
-    assert_eq!(call!(ne_ui16(3, 3)), false);
-    assert_eq!(call!(ne_ui16(4, 4)), false);
-    assert_eq!(call!(ne_ui16(1717, 1717)), false);
-    assert_eq!(call!(ne_ui16(17988, 17988)), false);
-    assert_eq!(call!(ne_ui16(65096, 65096)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_520() {
-    assert_eq!(call!(ne_ui16(65534, 65534)), false);
-    assert_eq!(call!(ne_ui16(65535, 65535)), false);
-    assert_eq!(call!(ne_ui16(0, 1)), true);
-    assert_eq!(call!(ne_ui16(0, 2)), true);
-    assert_eq!(call!(ne_ui16(0, 3)), true);
-    assert_eq!(call!(ne_ui16(0, 4)), true);
-    assert_eq!(call!(ne_ui16(0, 1717)), true);
-    assert_eq!(call!(ne_ui16(0, 17988)), true);
-    assert_eq!(call!(ne_ui16(0, 65096)), true);
-    assert_eq!(call!(ne_ui16(0, 65534)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_521() {
-    assert_eq!(call!(ne_ui16(0, 65535)), true);
-    assert_eq!(call!(ne_ui16(1, 0)), true);
-    assert_eq!(call!(ne_ui16(1, 2)), true);
-    assert_eq!(call!(ne_ui16(1, 3)), true);
-    assert_eq!(call!(ne_ui16(1, 4)), true);
-    assert_eq!(call!(ne_ui16(1, 1717)), true);
-    assert_eq!(call!(ne_ui16(1, 17988)), true);
-    assert_eq!(call!(ne_ui16(1, 65096)), true);
-    assert_eq!(call!(ne_ui16(1, 65534)), true);
-    assert_eq!(call!(ne_ui16(1, 65535)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_522() {
-    assert_eq!(call!(ne_ui16(2, 0)), true);
-    assert_eq!(call!(ne_ui16(2, 1)), true);
-    assert_eq!(call!(ne_ui16(2, 3)), true);
-    assert_eq!(call!(ne_ui16(2, 4)), true);
-    assert_eq!(call!(ne_ui16(2, 1717)), true);
-    assert_eq!(call!(ne_ui16(2, 17988)), true);
-    assert_eq!(call!(ne_ui16(2, 65096)), true);
-    assert_eq!(call!(ne_ui16(2, 65534)), true);
-    assert_eq!(call!(ne_ui16(2, 65535)), true);
-    assert_eq!(call!(ne_ui16(3, 0)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_523() {
-    assert_eq!(call!(ne_ui16(3, 1)), true);
-    assert_eq!(call!(ne_ui16(3, 2)), true);
-    assert_eq!(call!(ne_ui16(3, 4)), true);
-    assert_eq!(call!(ne_ui16(3, 1717)), true);
-    assert_eq!(call!(ne_ui16(3, 17988)), true);
-    assert_eq!(call!(ne_ui16(3, 65096)), true);
-    assert_eq!(call!(ne_ui16(3, 65534)), true);
-    assert_eq!(call!(ne_ui16(3, 65535)), true);
-    assert_eq!(call!(ne_ui16(4, 0)), true);
-    assert_eq!(call!(ne_ui16(4, 1)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_524() {
-    assert_eq!(call!(ne_ui16(4, 2)), true);
-    assert_eq!(call!(ne_ui16(4, 3)), true);
-    assert_eq!(call!(ne_ui16(4, 1717)), true);
-    assert_eq!(call!(ne_ui16(4, 17988)), true);
-    assert_eq!(call!(ne_ui16(4, 65096)), true);
-    assert_eq!(call!(ne_ui16(4, 65534)), true);
-    assert_eq!(call!(ne_ui16(4, 65535)), true);
-    assert_eq!(call!(ne_ui16(1717, 0)), true);
-    assert_eq!(call!(ne_ui16(1717, 1)), true);
-    assert_eq!(call!(ne_ui16(1717, 2)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_525() {
-    assert_eq!(call!(ne_ui16(1717, 3)), true);
-    assert_eq!(call!(ne_ui16(1717, 4)), true);
-    assert_eq!(call!(ne_ui16(1717, 17988)), true);
-    assert_eq!(call!(ne_ui16(1717, 65096)), true);
-    assert_eq!(call!(ne_ui16(1717, 65534)), true);
-    assert_eq!(call!(ne_ui16(1717, 65535)), true);
-    assert_eq!(call!(ne_ui16(17988, 0)), true);
-    assert_eq!(call!(ne_ui16(17988, 1)), true);
-    assert_eq!(call!(ne_ui16(17988, 2)), true);
-    assert_eq!(call!(ne_ui16(17988, 3)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_526() {
-    assert_eq!(call!(ne_ui16(17988, 4)), true);
-    assert_eq!(call!(ne_ui16(17988, 1717)), true);
-    assert_eq!(call!(ne_ui16(17988, 65096)), true);
-    assert_eq!(call!(ne_ui16(17988, 65534)), true);
-    assert_eq!(call!(ne_ui16(17988, 65535)), true);
-    assert_eq!(call!(ne_ui16(65096, 0)), true);
-    assert_eq!(call!(ne_ui16(65096, 1)), true);
-    assert_eq!(call!(ne_ui16(65096, 2)), true);
-    assert_eq!(call!(ne_ui16(65096, 3)), true);
-    assert_eq!(call!(ne_ui16(65096, 4)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_527() {
-    assert_eq!(call!(ne_ui16(65096, 1717)), true);
-    assert_eq!(call!(ne_ui16(65096, 17988)), true);
-    assert_eq!(call!(ne_ui16(65096, 65534)), true);
-    assert_eq!(call!(ne_ui16(65096, 65535)), true);
-    assert_eq!(call!(ne_ui16(65534, 0)), true);
-    assert_eq!(call!(ne_ui16(65534, 1)), true);
-    assert_eq!(call!(ne_ui16(65534, 2)), true);
-    assert_eq!(call!(ne_ui16(65534, 3)), true);
-    assert_eq!(call!(ne_ui16(65534, 4)), true);
-    assert_eq!(call!(ne_ui16(65534, 1717)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_528() {
-    assert_eq!(call!(ne_ui16(65534, 17988)), true);
-    assert_eq!(call!(ne_ui16(65534, 65096)), true);
-    assert_eq!(call!(ne_ui16(65534, 65535)), true);
-    assert_eq!(call!(ne_ui16(65535, 0)), true);
-    assert_eq!(call!(ne_ui16(65535, 1)), true);
-    assert_eq!(call!(ne_ui16(65535, 2)), true);
-    assert_eq!(call!(ne_ui16(65535, 3)), true);
-    assert_eq!(call!(ne_ui16(65535, 4)), true);
-    assert_eq!(call!(ne_ui16(65535, 1717)), true);
-    assert_eq!(call!(ne_ui16(65535, 17988)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_529() {
-    assert_eq!(call!(ne_ui16(65535, 65096)), true);
-    assert_eq!(call!(ne_ui16(65535, 65534)), true);
-    assert_eq!(call!(ne_ui32(0, 0)), false);
-    assert_eq!(call!(ne_ui32(1, 1)), false);
-    assert_eq!(call!(ne_ui32(2, 2)), false);
-    assert_eq!(call!(ne_ui32(3, 3)), false);
-    assert_eq!(call!(ne_ui32(4, 4)), false);
-    assert_eq!(call!(ne_ui32(2119154652, 2119154652)), false);
-    assert_eq!(call!(ne_ui32(3002788344, 3002788344)), false);
-    assert_eq!(call!(ne_ui32(3482297128, 3482297128)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_530() {
-    assert_eq!(call!(ne_ui32(4294967294, 4294967294)), false);
-    assert_eq!(call!(ne_ui32(4294967295, 4294967295)), false);
-    assert_eq!(call!(ne_ui32(0, 1)), true);
-    assert_eq!(call!(ne_ui32(0, 2)), true);
-    assert_eq!(call!(ne_ui32(0, 3)), true);
-    assert_eq!(call!(ne_ui32(0, 4)), true);
-    assert_eq!(call!(ne_ui32(0, 2119154652)), true);
-    assert_eq!(call!(ne_ui32(0, 3002788344)), true);
-    assert_eq!(call!(ne_ui32(0, 3482297128)), true);
-    assert_eq!(call!(ne_ui32(0, 4294967294)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_531() {
-    assert_eq!(call!(ne_ui32(0, 4294967295)), true);
-    assert_eq!(call!(ne_ui32(1, 0)), true);
-    assert_eq!(call!(ne_ui32(1, 2)), true);
-    assert_eq!(call!(ne_ui32(1, 3)), true);
-    assert_eq!(call!(ne_ui32(1, 4)), true);
-    assert_eq!(call!(ne_ui32(1, 2119154652)), true);
-    assert_eq!(call!(ne_ui32(1, 3002788344)), true);
-    assert_eq!(call!(ne_ui32(1, 3482297128)), true);
-    assert_eq!(call!(ne_ui32(1, 4294967294)), true);
-    assert_eq!(call!(ne_ui32(1, 4294967295)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_532() {
-    assert_eq!(call!(ne_ui32(2, 0)), true);
-    assert_eq!(call!(ne_ui32(2, 1)), true);
-    assert_eq!(call!(ne_ui32(2, 3)), true);
-    assert_eq!(call!(ne_ui32(2, 4)), true);
-    assert_eq!(call!(ne_ui32(2, 2119154652)), true);
-    assert_eq!(call!(ne_ui32(2, 3002788344)), true);
-    assert_eq!(call!(ne_ui32(2, 3482297128)), true);
-    assert_eq!(call!(ne_ui32(2, 4294967294)), true);
-    assert_eq!(call!(ne_ui32(2, 4294967295)), true);
-    assert_eq!(call!(ne_ui32(3, 0)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_533() {
-    assert_eq!(call!(ne_ui32(3, 1)), true);
-    assert_eq!(call!(ne_ui32(3, 2)), true);
-    assert_eq!(call!(ne_ui32(3, 4)), true);
-    assert_eq!(call!(ne_ui32(3, 2119154652)), true);
-    assert_eq!(call!(ne_ui32(3, 3002788344)), true);
-    assert_eq!(call!(ne_ui32(3, 3482297128)), true);
-    assert_eq!(call!(ne_ui32(3, 4294967294)), true);
-    assert_eq!(call!(ne_ui32(3, 4294967295)), true);
-    assert_eq!(call!(ne_ui32(4, 0)), true);
-    assert_eq!(call!(ne_ui32(4, 1)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_534() {
-    assert_eq!(call!(ne_ui32(4, 2)), true);
-    assert_eq!(call!(ne_ui32(4, 3)), true);
-    assert_eq!(call!(ne_ui32(4, 2119154652)), true);
-    assert_eq!(call!(ne_ui32(4, 3002788344)), true);
-    assert_eq!(call!(ne_ui32(4, 3482297128)), true);
-    assert_eq!(call!(ne_ui32(4, 4294967294)), true);
-    assert_eq!(call!(ne_ui32(4, 4294967295)), true);
-    assert_eq!(call!(ne_ui32(2119154652, 0)), true);
-    assert_eq!(call!(ne_ui32(2119154652, 1)), true);
-    assert_eq!(call!(ne_ui32(2119154652, 2)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_535() {
-    assert_eq!(call!(ne_ui32(2119154652, 3)), true);
-    assert_eq!(call!(ne_ui32(2119154652, 4)), true);
-    assert_eq!(call!(ne_ui32(2119154652, 3002788344)), true);
-    assert_eq!(call!(ne_ui32(2119154652, 3482297128)), true);
-    assert_eq!(call!(ne_ui32(2119154652, 4294967294)), true);
-    assert_eq!(call!(ne_ui32(2119154652, 4294967295)), true);
-    assert_eq!(call!(ne_ui32(3002788344, 0)), true);
-    assert_eq!(call!(ne_ui32(3002788344, 1)), true);
-    assert_eq!(call!(ne_ui32(3002788344, 2)), true);
-    assert_eq!(call!(ne_ui32(3002788344, 3)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_536() {
-    assert_eq!(call!(ne_ui32(3002788344, 4)), true);
-    assert_eq!(call!(ne_ui32(3002788344, 2119154652)), true);
-    assert_eq!(call!(ne_ui32(3002788344, 3482297128)), true);
-    assert_eq!(call!(ne_ui32(3002788344, 4294967294)), true);
-    assert_eq!(call!(ne_ui32(3002788344, 4294967295)), true);
-    assert_eq!(call!(ne_ui32(3482297128, 0)), true);
-    assert_eq!(call!(ne_ui32(3482297128, 1)), true);
-    assert_eq!(call!(ne_ui32(3482297128, 2)), true);
-    assert_eq!(call!(ne_ui32(3482297128, 3)), true);
-    assert_eq!(call!(ne_ui32(3482297128, 4)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_537() {
-    assert_eq!(call!(ne_ui32(3482297128, 2119154652)), true);
-    assert_eq!(call!(ne_ui32(3482297128, 3002788344)), true);
-    assert_eq!(call!(ne_ui32(3482297128, 4294967294)), true);
-    assert_eq!(call!(ne_ui32(3482297128, 4294967295)), true);
-    assert_eq!(call!(ne_ui32(4294967294, 0)), true);
-    assert_eq!(call!(ne_ui32(4294967294, 1)), true);
-    assert_eq!(call!(ne_ui32(4294967294, 2)), true);
-    assert_eq!(call!(ne_ui32(4294967294, 3)), true);
-    assert_eq!(call!(ne_ui32(4294967294, 4)), true);
-    assert_eq!(call!(ne_ui32(4294967294, 2119154652)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_538() {
-    assert_eq!(call!(ne_ui32(4294967294, 3002788344)), true);
-    assert_eq!(call!(ne_ui32(4294967294, 3482297128)), true);
-    assert_eq!(call!(ne_ui32(4294967294, 4294967295)), true);
-    assert_eq!(call!(ne_ui32(4294967295, 0)), true);
-    assert_eq!(call!(ne_ui32(4294967295, 1)), true);
-    assert_eq!(call!(ne_ui32(4294967295, 2)), true);
-    assert_eq!(call!(ne_ui32(4294967295, 3)), true);
-    assert_eq!(call!(ne_ui32(4294967295, 4)), true);
-    assert_eq!(call!(ne_ui32(4294967295, 2119154652)), true);
-    assert_eq!(call!(ne_ui32(4294967295, 3002788344)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_539() {
-    assert_eq!(call!(ne_ui32(4294967295, 3482297128)), true);
-    assert_eq!(call!(ne_ui32(4294967295, 4294967294)), true);
-    assert_eq!(call!(ne_ui64(0, 0)), false);
-    assert_eq!(call!(ne_ui64(1, 1)), false);
-    assert_eq!(call!(ne_ui64(2, 2)), false);
-    assert_eq!(call!(ne_ui64(3, 3)), false);
-    assert_eq!(call!(ne_ui64(4, 4)), false);
-    assert_eq!(call!(ne_ui64(191084152064409600, 191084152064409600)), false);
-    assert_eq!(call!(ne_ui64(11015955194427482112, 11015955194427482112)), false);
-    assert_eq!(call!(ne_ui64(16990600415051759616, 16990600415051759616)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_540() {
-    assert_eq!(call!(ne_ui64(18446744073709551614, 18446744073709551614)), false);
-    assert_eq!(call!(ne_ui64(18446744073709551615, 18446744073709551615)), false);
-    assert_eq!(call!(ne_ui64(0, 1)), true);
-    assert_eq!(call!(ne_ui64(0, 2)), true);
-    assert_eq!(call!(ne_ui64(0, 3)), true);
-    assert_eq!(call!(ne_ui64(0, 4)), true);
-    assert_eq!(call!(ne_ui64(0, 191084152064409600)), true);
-    assert_eq!(call!(ne_ui64(0, 11015955194427482112)), true);
-    assert_eq!(call!(ne_ui64(0, 16990600415051759616)), true);
-    assert_eq!(call!(ne_ui64(0, 18446744073709551614)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_541() {
-    assert_eq!(call!(ne_ui64(0, 18446744073709551615)), true);
-    assert_eq!(call!(ne_ui64(1, 0)), true);
-    assert_eq!(call!(ne_ui64(1, 2)), true);
-    assert_eq!(call!(ne_ui64(1, 3)), true);
-    assert_eq!(call!(ne_ui64(1, 4)), true);
-    assert_eq!(call!(ne_ui64(1, 191084152064409600)), true);
-    assert_eq!(call!(ne_ui64(1, 11015955194427482112)), true);
-    assert_eq!(call!(ne_ui64(1, 16990600415051759616)), true);
-    assert_eq!(call!(ne_ui64(1, 18446744073709551614)), true);
-    assert_eq!(call!(ne_ui64(1, 18446744073709551615)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_542() {
-    assert_eq!(call!(ne_ui64(2, 0)), true);
-    assert_eq!(call!(ne_ui64(2, 1)), true);
-    assert_eq!(call!(ne_ui64(2, 3)), true);
-    assert_eq!(call!(ne_ui64(2, 4)), true);
-    assert_eq!(call!(ne_ui64(2, 191084152064409600)), true);
-    assert_eq!(call!(ne_ui64(2, 11015955194427482112)), true);
-    assert_eq!(call!(ne_ui64(2, 16990600415051759616)), true);
-    assert_eq!(call!(ne_ui64(2, 18446744073709551614)), true);
-    assert_eq!(call!(ne_ui64(2, 18446744073709551615)), true);
-    assert_eq!(call!(ne_ui64(3, 0)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_543() {
-    assert_eq!(call!(ne_ui64(3, 1)), true);
-    assert_eq!(call!(ne_ui64(3, 2)), true);
-    assert_eq!(call!(ne_ui64(3, 4)), true);
-    assert_eq!(call!(ne_ui64(3, 191084152064409600)), true);
-    assert_eq!(call!(ne_ui64(3, 11015955194427482112)), true);
-    assert_eq!(call!(ne_ui64(3, 16990600415051759616)), true);
-    assert_eq!(call!(ne_ui64(3, 18446744073709551614)), true);
-    assert_eq!(call!(ne_ui64(3, 18446744073709551615)), true);
-    assert_eq!(call!(ne_ui64(4, 0)), true);
-    assert_eq!(call!(ne_ui64(4, 1)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_544() {
-    assert_eq!(call!(ne_ui64(4, 2)), true);
-    assert_eq!(call!(ne_ui64(4, 3)), true);
-    assert_eq!(call!(ne_ui64(4, 191084152064409600)), true);
-    assert_eq!(call!(ne_ui64(4, 11015955194427482112)), true);
-    assert_eq!(call!(ne_ui64(4, 16990600415051759616)), true);
-    assert_eq!(call!(ne_ui64(4, 18446744073709551614)), true);
-    assert_eq!(call!(ne_ui64(4, 18446744073709551615)), true);
-    assert_eq!(call!(ne_ui64(191084152064409600, 0)), true);
-    assert_eq!(call!(ne_ui64(191084152064409600, 1)), true);
-    assert_eq!(call!(ne_ui64(191084152064409600, 2)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_545() {
-    assert_eq!(call!(ne_ui64(191084152064409600, 3)), true);
-    assert_eq!(call!(ne_ui64(191084152064409600, 4)), true);
-    assert_eq!(call!(ne_ui64(191084152064409600, 11015955194427482112)), true);
-    assert_eq!(call!(ne_ui64(191084152064409600, 16990600415051759616)), true);
-    assert_eq!(call!(ne_ui64(191084152064409600, 18446744073709551614)), true);
-    assert_eq!(call!(ne_ui64(191084152064409600, 18446744073709551615)), true);
-    assert_eq!(call!(ne_ui64(11015955194427482112, 0)), true);
-    assert_eq!(call!(ne_ui64(11015955194427482112, 1)), true);
-    assert_eq!(call!(ne_ui64(11015955194427482112, 2)), true);
-    assert_eq!(call!(ne_ui64(11015955194427482112, 3)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_546() {
-    assert_eq!(call!(ne_ui64(11015955194427482112, 4)), true);
-    assert_eq!(call!(ne_ui64(11015955194427482112, 191084152064409600)), true);
-    assert_eq!(call!(ne_ui64(11015955194427482112, 16990600415051759616)), true);
-    assert_eq!(call!(ne_ui64(11015955194427482112, 18446744073709551614)), true);
-    assert_eq!(call!(ne_ui64(11015955194427482112, 18446744073709551615)), true);
-    assert_eq!(call!(ne_ui64(16990600415051759616, 0)), true);
-    assert_eq!(call!(ne_ui64(16990600415051759616, 1)), true);
-    assert_eq!(call!(ne_ui64(16990600415051759616, 2)), true);
-    assert_eq!(call!(ne_ui64(16990600415051759616, 3)), true);
-    assert_eq!(call!(ne_ui64(16990600415051759616, 4)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_547() {
-    assert_eq!(call!(ne_ui64(16990600415051759616, 191084152064409600)), true);
-    assert_eq!(call!(ne_ui64(16990600415051759616, 11015955194427482112)), true);
-    assert_eq!(call!(ne_ui64(16990600415051759616, 18446744073709551614)), true);
-    assert_eq!(call!(ne_ui64(16990600415051759616, 18446744073709551615)), true);
-    assert_eq!(call!(ne_ui64(18446744073709551614, 0)), true);
-    assert_eq!(call!(ne_ui64(18446744073709551614, 1)), true);
-    assert_eq!(call!(ne_ui64(18446744073709551614, 2)), true);
-    assert_eq!(call!(ne_ui64(18446744073709551614, 3)), true);
-    assert_eq!(call!(ne_ui64(18446744073709551614, 4)), true);
-    assert_eq!(call!(ne_ui64(18446744073709551614, 191084152064409600)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_548() {
-    assert_eq!(call!(ne_ui64(18446744073709551614, 11015955194427482112)), true);
-    assert_eq!(call!(ne_ui64(18446744073709551614, 16990600415051759616)), true);
-    assert_eq!(call!(ne_ui64(18446744073709551614, 18446744073709551615)), true);
-    assert_eq!(call!(ne_ui64(18446744073709551615, 0)), true);
-    assert_eq!(call!(ne_ui64(18446744073709551615, 1)), true);
-    assert_eq!(call!(ne_ui64(18446744073709551615, 2)), true);
-    assert_eq!(call!(ne_ui64(18446744073709551615, 3)), true);
-    assert_eq!(call!(ne_ui64(18446744073709551615, 4)), true);
-    assert_eq!(call!(ne_ui64(18446744073709551615, 191084152064409600)), true);
-    assert_eq!(call!(ne_ui64(18446744073709551615, 11015955194427482112)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_549() {
-    assert_eq!(call!(ne_ui64(18446744073709551615, 16990600415051759616)), true);
-    assert_eq!(call!(ne_ui64(18446744073709551615, 18446744073709551614)), true);
-    assert_eq!(call!(ne_ui8(0, 0)), false);
-    assert_eq!(call!(ne_ui8(1, 1)), false);
-    assert_eq!(call!(ne_ui8(2, 2)), false);
-    assert_eq!(call!(ne_ui8(3, 3)), false);
-    assert_eq!(call!(ne_ui8(4, 4)), false);
-    assert_eq!(call!(ne_ui8(72, 72)), false);
-    assert_eq!(call!(ne_ui8(100, 100)), false);
-    assert_eq!(call!(ne_ui8(162, 162)), false);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_550() {
-    assert_eq!(call!(ne_ui8(254, 254)), false);
-    assert_eq!(call!(ne_ui8(255, 255)), false);
-    assert_eq!(call!(ne_ui8(0, 1)), true);
-    assert_eq!(call!(ne_ui8(0, 2)), true);
-    assert_eq!(call!(ne_ui8(0, 3)), true);
-    assert_eq!(call!(ne_ui8(0, 4)), true);
-    assert_eq!(call!(ne_ui8(0, 72)), true);
-    assert_eq!(call!(ne_ui8(0, 100)), true);
-    assert_eq!(call!(ne_ui8(0, 162)), true);
-    assert_eq!(call!(ne_ui8(0, 254)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_551() {
-    assert_eq!(call!(ne_ui8(0, 255)), true);
-    assert_eq!(call!(ne_ui8(1, 0)), true);
-    assert_eq!(call!(ne_ui8(1, 2)), true);
-    assert_eq!(call!(ne_ui8(1, 3)), true);
-    assert_eq!(call!(ne_ui8(1, 4)), true);
-    assert_eq!(call!(ne_ui8(1, 72)), true);
-    assert_eq!(call!(ne_ui8(1, 100)), true);
-    assert_eq!(call!(ne_ui8(1, 162)), true);
-    assert_eq!(call!(ne_ui8(1, 254)), true);
-    assert_eq!(call!(ne_ui8(1, 255)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_552() {
-    assert_eq!(call!(ne_ui8(2, 0)), true);
-    assert_eq!(call!(ne_ui8(2, 1)), true);
-    assert_eq!(call!(ne_ui8(2, 3)), true);
-    assert_eq!(call!(ne_ui8(2, 4)), true);
-    assert_eq!(call!(ne_ui8(2, 72)), true);
-    assert_eq!(call!(ne_ui8(2, 100)), true);
-    assert_eq!(call!(ne_ui8(2, 162)), true);
-    assert_eq!(call!(ne_ui8(2, 254)), true);
-    assert_eq!(call!(ne_ui8(2, 255)), true);
-    assert_eq!(call!(ne_ui8(3, 0)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_553() {
-    assert_eq!(call!(ne_ui8(3, 1)), true);
-    assert_eq!(call!(ne_ui8(3, 2)), true);
-    assert_eq!(call!(ne_ui8(3, 4)), true);
-    assert_eq!(call!(ne_ui8(3, 72)), true);
-    assert_eq!(call!(ne_ui8(3, 100)), true);
-    assert_eq!(call!(ne_ui8(3, 162)), true);
-    assert_eq!(call!(ne_ui8(3, 254)), true);
-    assert_eq!(call!(ne_ui8(3, 255)), true);
-    assert_eq!(call!(ne_ui8(4, 0)), true);
-    assert_eq!(call!(ne_ui8(4, 1)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_554() {
-    assert_eq!(call!(ne_ui8(4, 2)), true);
-    assert_eq!(call!(ne_ui8(4, 3)), true);
-    assert_eq!(call!(ne_ui8(4, 72)), true);
-    assert_eq!(call!(ne_ui8(4, 100)), true);
-    assert_eq!(call!(ne_ui8(4, 162)), true);
-    assert_eq!(call!(ne_ui8(4, 254)), true);
-    assert_eq!(call!(ne_ui8(4, 255)), true);
-    assert_eq!(call!(ne_ui8(72, 0)), true);
-    assert_eq!(call!(ne_ui8(72, 1)), true);
-    assert_eq!(call!(ne_ui8(72, 2)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_555() {
-    assert_eq!(call!(ne_ui8(72, 3)), true);
-    assert_eq!(call!(ne_ui8(72, 4)), true);
-    assert_eq!(call!(ne_ui8(72, 100)), true);
-    assert_eq!(call!(ne_ui8(72, 162)), true);
-    assert_eq!(call!(ne_ui8(72, 254)), true);
-    assert_eq!(call!(ne_ui8(72, 255)), true);
-    assert_eq!(call!(ne_ui8(100, 0)), true);
-    assert_eq!(call!(ne_ui8(100, 1)), true);
-    assert_eq!(call!(ne_ui8(100, 2)), true);
-    assert_eq!(call!(ne_ui8(100, 3)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_556() {
-    assert_eq!(call!(ne_ui8(100, 4)), true);
-    assert_eq!(call!(ne_ui8(100, 72)), true);
-    assert_eq!(call!(ne_ui8(100, 162)), true);
-    assert_eq!(call!(ne_ui8(100, 254)), true);
-    assert_eq!(call!(ne_ui8(100, 255)), true);
-    assert_eq!(call!(ne_ui8(162, 0)), true);
-    assert_eq!(call!(ne_ui8(162, 1)), true);
-    assert_eq!(call!(ne_ui8(162, 2)), true);
-    assert_eq!(call!(ne_ui8(162, 3)), true);
-    assert_eq!(call!(ne_ui8(162, 4)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_557() {
-    assert_eq!(call!(ne_ui8(162, 72)), true);
-    assert_eq!(call!(ne_ui8(162, 100)), true);
-    assert_eq!(call!(ne_ui8(162, 254)), true);
-    assert_eq!(call!(ne_ui8(162, 255)), true);
-    assert_eq!(call!(ne_ui8(254, 0)), true);
-    assert_eq!(call!(ne_ui8(254, 1)), true);
-    assert_eq!(call!(ne_ui8(254, 2)), true);
-    assert_eq!(call!(ne_ui8(254, 3)), true);
-    assert_eq!(call!(ne_ui8(254, 4)), true);
-    assert_eq!(call!(ne_ui8(254, 72)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_558() {
-    assert_eq!(call!(ne_ui8(254, 100)), true);
-    assert_eq!(call!(ne_ui8(254, 162)), true);
-    assert_eq!(call!(ne_ui8(254, 255)), true);
-    assert_eq!(call!(ne_ui8(255, 0)), true);
-    assert_eq!(call!(ne_ui8(255, 1)), true);
-    assert_eq!(call!(ne_ui8(255, 2)), true);
-    assert_eq!(call!(ne_ui8(255, 3)), true);
-    assert_eq!(call!(ne_ui8(255, 4)), true);
-    assert_eq!(call!(ne_ui8(255, 72)), true);
-    assert_eq!(call!(ne_ui8(255, 100)), true);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_559() {
-    assert_eq!(call!(ne_ui8(255, 162)), true);
-    assert_eq!(call!(ne_ui8(255, 254)), true);
-  }
+    use crate::arctorustcmpi::*;
+    #[test]
+    fn test_0() {
+        assert_eq!(eq_si16(-32768, -32767), false);
+        assert_eq!(eq_si16(-32768, -32547), false);
+        assert_eq!(eq_si16(-32768, 0), false);
+        assert_eq!(eq_si16(-32768, 1), false);
+        assert_eq!(eq_si16(-32768, 2), false);
+        assert_eq!(eq_si16(-32768, 3), false);
+        assert_eq!(eq_si16(-32768, 4), false);
+        assert_eq!(eq_si16(-32768, 10486), false);
+        assert_eq!(eq_si16(-32768, 16514), false);
+        assert_eq!(eq_si16(-32768, 32766), false);
+    }
+    #[test]
+    fn test_1() {
+        assert_eq!(eq_si16(-32768, 32767), false);
+        assert_eq!(eq_si16(-32767, -32768), false);
+        assert_eq!(eq_si16(-32767, -32547), false);
+        assert_eq!(eq_si16(-32767, 0), false);
+        assert_eq!(eq_si16(-32767, 1), false);
+        assert_eq!(eq_si16(-32767, 2), false);
+        assert_eq!(eq_si16(-32767, 3), false);
+        assert_eq!(eq_si16(-32767, 4), false);
+        assert_eq!(eq_si16(-32767, 10486), false);
+        assert_eq!(eq_si16(-32767, 16514), false);
+    }
+    #[test]
+    fn test_2() {
+        assert_eq!(eq_si16(-32767, 32766), false);
+        assert_eq!(eq_si16(-32767, 32767), false);
+        assert_eq!(eq_si16(-32547, -32768), false);
+        assert_eq!(eq_si16(-32547, -32767), false);
+        assert_eq!(eq_si16(-32547, 0), false);
+        assert_eq!(eq_si16(-32547, 1), false);
+        assert_eq!(eq_si16(-32547, 2), false);
+        assert_eq!(eq_si16(-32547, 3), false);
+        assert_eq!(eq_si16(-32547, 4), false);
+        assert_eq!(eq_si16(-32547, 10486), false);
+    }
+    #[test]
+    fn test_3() {
+        assert_eq!(eq_si16(-32547, 16514), false);
+        assert_eq!(eq_si16(-32547, 32766), false);
+        assert_eq!(eq_si16(-32547, 32767), false);
+        assert_eq!(eq_si16(0, -32768), false);
+        assert_eq!(eq_si16(0, -32767), false);
+        assert_eq!(eq_si16(0, -32547), false);
+        assert_eq!(eq_si16(0, 1), false);
+        assert_eq!(eq_si16(0, 2), false);
+        assert_eq!(eq_si16(0, 3), false);
+        assert_eq!(eq_si16(0, 4), false);
+    }
+    #[test]
+    fn test_4() {
+        assert_eq!(eq_si16(0, 10486), false);
+        assert_eq!(eq_si16(0, 16514), false);
+        assert_eq!(eq_si16(0, 32766), false);
+        assert_eq!(eq_si16(0, 32767), false);
+        assert_eq!(eq_si16(1, -32768), false);
+        assert_eq!(eq_si16(1, -32767), false);
+        assert_eq!(eq_si16(1, -32547), false);
+        assert_eq!(eq_si16(1, 0), false);
+        assert_eq!(eq_si16(1, 2), false);
+        assert_eq!(eq_si16(1, 3), false);
+    }
+    #[test]
+    fn test_5() {
+        assert_eq!(eq_si16(1, 4), false);
+        assert_eq!(eq_si16(1, 10486), false);
+        assert_eq!(eq_si16(1, 16514), false);
+        assert_eq!(eq_si16(1, 32766), false);
+        assert_eq!(eq_si16(1, 32767), false);
+        assert_eq!(eq_si16(2, -32768), false);
+        assert_eq!(eq_si16(2, -32767), false);
+        assert_eq!(eq_si16(2, -32547), false);
+        assert_eq!(eq_si16(2, 0), false);
+        assert_eq!(eq_si16(2, 1), false);
+    }
+    #[test]
+    fn test_6() {
+        assert_eq!(eq_si16(2, 3), false);
+        assert_eq!(eq_si16(2, 4), false);
+        assert_eq!(eq_si16(2, 10486), false);
+        assert_eq!(eq_si16(2, 16514), false);
+        assert_eq!(eq_si16(2, 32766), false);
+        assert_eq!(eq_si16(2, 32767), false);
+        assert_eq!(eq_si16(3, -32768), false);
+        assert_eq!(eq_si16(3, -32767), false);
+        assert_eq!(eq_si16(3, -32547), false);
+        assert_eq!(eq_si16(3, 0), false);
+    }
+    #[test]
+    fn test_7() {
+        assert_eq!(eq_si16(3, 1), false);
+        assert_eq!(eq_si16(3, 2), false);
+        assert_eq!(eq_si16(3, 4), false);
+        assert_eq!(eq_si16(3, 10486), false);
+        assert_eq!(eq_si16(3, 16514), false);
+        assert_eq!(eq_si16(3, 32766), false);
+        assert_eq!(eq_si16(3, 32767), false);
+        assert_eq!(eq_si16(4, -32768), false);
+        assert_eq!(eq_si16(4, -32767), false);
+        assert_eq!(eq_si16(4, -32547), false);
+    }
+    #[test]
+    fn test_8() {
+        assert_eq!(eq_si16(4, 0), false);
+        assert_eq!(eq_si16(4, 1), false);
+        assert_eq!(eq_si16(4, 2), false);
+        assert_eq!(eq_si16(4, 3), false);
+        assert_eq!(eq_si16(4, 10486), false);
+        assert_eq!(eq_si16(4, 16514), false);
+        assert_eq!(eq_si16(4, 32766), false);
+        assert_eq!(eq_si16(4, 32767), false);
+        assert_eq!(eq_si16(10486, -32768), false);
+        assert_eq!(eq_si16(10486, -32767), false);
+    }
+    #[test]
+    fn test_9() {
+        assert_eq!(eq_si16(10486, -32547), false);
+        assert_eq!(eq_si16(10486, 0), false);
+        assert_eq!(eq_si16(10486, 1), false);
+        assert_eq!(eq_si16(10486, 2), false);
+        assert_eq!(eq_si16(10486, 3), false);
+        assert_eq!(eq_si16(10486, 4), false);
+        assert_eq!(eq_si16(10486, 16514), false);
+        assert_eq!(eq_si16(10486, 32766), false);
+        assert_eq!(eq_si16(10486, 32767), false);
+        assert_eq!(eq_si16(16514, -32768), false);
+    }
+    #[test]
+    fn test_10() {
+        assert_eq!(eq_si16(16514, -32767), false);
+        assert_eq!(eq_si16(16514, -32547), false);
+        assert_eq!(eq_si16(16514, 0), false);
+        assert_eq!(eq_si16(16514, 1), false);
+        assert_eq!(eq_si16(16514, 2), false);
+        assert_eq!(eq_si16(16514, 3), false);
+        assert_eq!(eq_si16(16514, 4), false);
+        assert_eq!(eq_si16(16514, 10486), false);
+        assert_eq!(eq_si16(16514, 32766), false);
+        assert_eq!(eq_si16(16514, 32767), false);
+    }
+    #[test]
+    fn test_11() {
+        assert_eq!(eq_si16(32766, -32768), false);
+        assert_eq!(eq_si16(32766, -32767), false);
+        assert_eq!(eq_si16(32766, -32547), false);
+        assert_eq!(eq_si16(32766, 0), false);
+        assert_eq!(eq_si16(32766, 1), false);
+        assert_eq!(eq_si16(32766, 2), false);
+        assert_eq!(eq_si16(32766, 3), false);
+        assert_eq!(eq_si16(32766, 4), false);
+        assert_eq!(eq_si16(32766, 10486), false);
+        assert_eq!(eq_si16(32766, 16514), false);
+    }
+    #[test]
+    fn test_12() {
+        assert_eq!(eq_si16(32766, 32767), false);
+        assert_eq!(eq_si16(32767, -32768), false);
+        assert_eq!(eq_si16(32767, -32767), false);
+        assert_eq!(eq_si16(32767, -32547), false);
+        assert_eq!(eq_si16(32767, 0), false);
+        assert_eq!(eq_si16(32767, 1), false);
+        assert_eq!(eq_si16(32767, 2), false);
+        assert_eq!(eq_si16(32767, 3), false);
+        assert_eq!(eq_si16(32767, 4), false);
+        assert_eq!(eq_si16(32767, 10486), false);
+    }
+    #[test]
+    fn test_13() {
+        assert_eq!(eq_si16(32767, 16514), false);
+        assert_eq!(eq_si16(32767, 32766), false);
+        assert_eq!(eq_si16(-32768, -32768), true);
+        assert_eq!(eq_si16(-32767, -32767), true);
+        assert_eq!(eq_si16(-32547, -32547), true);
+        assert_eq!(eq_si16(0, 0), true);
+        assert_eq!(eq_si16(1, 1), true);
+        assert_eq!(eq_si16(2, 2), true);
+        assert_eq!(eq_si16(3, 3), true);
+        assert_eq!(eq_si16(4, 4), true);
+    }
+    #[test]
+    fn test_14() {
+        assert_eq!(eq_si16(10486, 10486), true);
+        assert_eq!(eq_si16(16514, 16514), true);
+        assert_eq!(eq_si16(32766, 32766), true);
+        assert_eq!(eq_si16(32767, 32767), true);
+        assert_eq!(eq_si32(-2147483648, -2147483647), false);
+        assert_eq!(eq_si32(-2147483648, -1713183800), false);
+        assert_eq!(eq_si32(-2147483648, -1252582164), false);
+        assert_eq!(eq_si32(-2147483648, -1035405763), false);
+        assert_eq!(eq_si32(-2147483648, 0), false);
+        assert_eq!(eq_si32(-2147483648, 1), false);
+    }
+    #[test]
+    fn test_15() {
+        assert_eq!(eq_si32(-2147483648, 2), false);
+        assert_eq!(eq_si32(-2147483648, 3), false);
+        assert_eq!(eq_si32(-2147483648, 4), false);
+        assert_eq!(eq_si32(-2147483648, 2147483646), false);
+        assert_eq!(eq_si32(-2147483648, 2147483647), false);
+        assert_eq!(eq_si32(-2147483647, -2147483648), false);
+        assert_eq!(eq_si32(-2147483647, -1713183800), false);
+        assert_eq!(eq_si32(-2147483647, -1252582164), false);
+        assert_eq!(eq_si32(-2147483647, -1035405763), false);
+        assert_eq!(eq_si32(-2147483647, 0), false);
+    }
+    #[test]
+    fn test_16() {
+        assert_eq!(eq_si32(-2147483647, 1), false);
+        assert_eq!(eq_si32(-2147483647, 2), false);
+        assert_eq!(eq_si32(-2147483647, 3), false);
+        assert_eq!(eq_si32(-2147483647, 4), false);
+        assert_eq!(eq_si32(-2147483647, 2147483646), false);
+        assert_eq!(eq_si32(-2147483647, 2147483647), false);
+        assert_eq!(eq_si32(-1713183800, -2147483648), false);
+        assert_eq!(eq_si32(-1713183800, -2147483647), false);
+        assert_eq!(eq_si32(-1713183800, -1252582164), false);
+        assert_eq!(eq_si32(-1713183800, -1035405763), false);
+    }
+    #[test]
+    fn test_17() {
+        assert_eq!(eq_si32(-1713183800, 0), false);
+        assert_eq!(eq_si32(-1713183800, 1), false);
+        assert_eq!(eq_si32(-1713183800, 2), false);
+        assert_eq!(eq_si32(-1713183800, 3), false);
+        assert_eq!(eq_si32(-1713183800, 4), false);
+        assert_eq!(eq_si32(-1713183800, 2147483646), false);
+        assert_eq!(eq_si32(-1713183800, 2147483647), false);
+        assert_eq!(eq_si32(-1252582164, -2147483648), false);
+        assert_eq!(eq_si32(-1252582164, -2147483647), false);
+        assert_eq!(eq_si32(-1252582164, -1713183800), false);
+    }
+    #[test]
+    fn test_18() {
+        assert_eq!(eq_si32(-1252582164, -1035405763), false);
+        assert_eq!(eq_si32(-1252582164, 0), false);
+        assert_eq!(eq_si32(-1252582164, 1), false);
+        assert_eq!(eq_si32(-1252582164, 2), false);
+        assert_eq!(eq_si32(-1252582164, 3), false);
+        assert_eq!(eq_si32(-1252582164, 4), false);
+        assert_eq!(eq_si32(-1252582164, 2147483646), false);
+        assert_eq!(eq_si32(-1252582164, 2147483647), false);
+        assert_eq!(eq_si32(-1035405763, -2147483648), false);
+        assert_eq!(eq_si32(-1035405763, -2147483647), false);
+    }
+    #[test]
+    fn test_19() {
+        assert_eq!(eq_si32(-1035405763, -1713183800), false);
+        assert_eq!(eq_si32(-1035405763, -1252582164), false);
+        assert_eq!(eq_si32(-1035405763, 0), false);
+        assert_eq!(eq_si32(-1035405763, 1), false);
+        assert_eq!(eq_si32(-1035405763, 2), false);
+        assert_eq!(eq_si32(-1035405763, 3), false);
+        assert_eq!(eq_si32(-1035405763, 4), false);
+        assert_eq!(eq_si32(-1035405763, 2147483646), false);
+        assert_eq!(eq_si32(-1035405763, 2147483647), false);
+        assert_eq!(eq_si32(0, -2147483648), false);
+    }
+    #[test]
+    fn test_20() {
+        assert_eq!(eq_si32(0, -2147483647), false);
+        assert_eq!(eq_si32(0, -1713183800), false);
+        assert_eq!(eq_si32(0, -1252582164), false);
+        assert_eq!(eq_si32(0, -1035405763), false);
+        assert_eq!(eq_si32(0, 1), false);
+        assert_eq!(eq_si32(0, 2), false);
+        assert_eq!(eq_si32(0, 3), false);
+        assert_eq!(eq_si32(0, 4), false);
+        assert_eq!(eq_si32(0, 2147483646), false);
+        assert_eq!(eq_si32(0, 2147483647), false);
+    }
+    #[test]
+    fn test_21() {
+        assert_eq!(eq_si32(1, -2147483648), false);
+        assert_eq!(eq_si32(1, -2147483647), false);
+        assert_eq!(eq_si32(1, -1713183800), false);
+        assert_eq!(eq_si32(1, -1252582164), false);
+        assert_eq!(eq_si32(1, -1035405763), false);
+        assert_eq!(eq_si32(1, 0), false);
+        assert_eq!(eq_si32(1, 2), false);
+        assert_eq!(eq_si32(1, 3), false);
+        assert_eq!(eq_si32(1, 4), false);
+        assert_eq!(eq_si32(1, 2147483646), false);
+    }
+    #[test]
+    fn test_22() {
+        assert_eq!(eq_si32(1, 2147483647), false);
+        assert_eq!(eq_si32(2, -2147483648), false);
+        assert_eq!(eq_si32(2, -2147483647), false);
+        assert_eq!(eq_si32(2, -1713183800), false);
+        assert_eq!(eq_si32(2, -1252582164), false);
+        assert_eq!(eq_si32(2, -1035405763), false);
+        assert_eq!(eq_si32(2, 0), false);
+        assert_eq!(eq_si32(2, 1), false);
+        assert_eq!(eq_si32(2, 3), false);
+        assert_eq!(eq_si32(2, 4), false);
+    }
+    #[test]
+    fn test_23() {
+        assert_eq!(eq_si32(2, 2147483646), false);
+        assert_eq!(eq_si32(2, 2147483647), false);
+        assert_eq!(eq_si32(3, -2147483648), false);
+        assert_eq!(eq_si32(3, -2147483647), false);
+        assert_eq!(eq_si32(3, -1713183800), false);
+        assert_eq!(eq_si32(3, -1252582164), false);
+        assert_eq!(eq_si32(3, -1035405763), false);
+        assert_eq!(eq_si32(3, 0), false);
+        assert_eq!(eq_si32(3, 1), false);
+        assert_eq!(eq_si32(3, 2), false);
+    }
+    #[test]
+    fn test_24() {
+        assert_eq!(eq_si32(3, 4), false);
+        assert_eq!(eq_si32(3, 2147483646), false);
+        assert_eq!(eq_si32(3, 2147483647), false);
+        assert_eq!(eq_si32(4, -2147483648), false);
+        assert_eq!(eq_si32(4, -2147483647), false);
+        assert_eq!(eq_si32(4, -1713183800), false);
+        assert_eq!(eq_si32(4, -1252582164), false);
+        assert_eq!(eq_si32(4, -1035405763), false);
+        assert_eq!(eq_si32(4, 0), false);
+        assert_eq!(eq_si32(4, 1), false);
+    }
+    #[test]
+    fn test_25() {
+        assert_eq!(eq_si32(4, 2), false);
+        assert_eq!(eq_si32(4, 3), false);
+        assert_eq!(eq_si32(4, 2147483646), false);
+        assert_eq!(eq_si32(4, 2147483647), false);
+        assert_eq!(eq_si32(2147483646, -2147483648), false);
+        assert_eq!(eq_si32(2147483646, -2147483647), false);
+        assert_eq!(eq_si32(2147483646, -1713183800), false);
+        assert_eq!(eq_si32(2147483646, -1252582164), false);
+        assert_eq!(eq_si32(2147483646, -1035405763), false);
+        assert_eq!(eq_si32(2147483646, 0), false);
+    }
+    #[test]
+    fn test_26() {
+        assert_eq!(eq_si32(2147483646, 1), false);
+        assert_eq!(eq_si32(2147483646, 2), false);
+        assert_eq!(eq_si32(2147483646, 3), false);
+        assert_eq!(eq_si32(2147483646, 4), false);
+        assert_eq!(eq_si32(2147483646, 2147483647), false);
+        assert_eq!(eq_si32(2147483647, -2147483648), false);
+        assert_eq!(eq_si32(2147483647, -2147483647), false);
+        assert_eq!(eq_si32(2147483647, -1713183800), false);
+        assert_eq!(eq_si32(2147483647, -1252582164), false);
+        assert_eq!(eq_si32(2147483647, -1035405763), false);
+    }
+    #[test]
+    fn test_27() {
+        assert_eq!(eq_si32(2147483647, 0), false);
+        assert_eq!(eq_si32(2147483647, 1), false);
+        assert_eq!(eq_si32(2147483647, 2), false);
+        assert_eq!(eq_si32(2147483647, 3), false);
+        assert_eq!(eq_si32(2147483647, 4), false);
+        assert_eq!(eq_si32(2147483647, 2147483646), false);
+        assert_eq!(eq_si32(-2147483648, -2147483648), true);
+        assert_eq!(eq_si32(-2147483647, -2147483647), true);
+        assert_eq!(eq_si32(-1713183800, -1713183800), true);
+        assert_eq!(eq_si32(-1252582164, -1252582164), true);
+    }
+    #[test]
+    fn test_28() {
+        assert_eq!(eq_si32(-1035405763, -1035405763), true);
+        assert_eq!(eq_si32(0, 0), true);
+        assert_eq!(eq_si32(1, 1), true);
+        assert_eq!(eq_si32(2, 2), true);
+        assert_eq!(eq_si32(3, 3), true);
+        assert_eq!(eq_si32(4, 4), true);
+        assert_eq!(eq_si32(2147483646, 2147483646), true);
+        assert_eq!(eq_si32(2147483647, 2147483647), true);
+        assert_eq!(eq_si64(-9223372036854775808, -9223372036854775807), false);
+        assert_eq!(eq_si64(-9223372036854775808, -1741927215160008704), false);
+    }
+    #[test]
+    fn test_29() {
+        assert_eq!(eq_si64(-9223372036854775808, -1328271339354574848), false);
+        assert_eq!(eq_si64(-9223372036854775808, 0), false);
+        assert_eq!(eq_si64(-9223372036854775808, 1), false);
+        assert_eq!(eq_si64(-9223372036854775808, 2), false);
+        assert_eq!(eq_si64(-9223372036854775808, 3), false);
+        assert_eq!(eq_si64(-9223372036854775808, 4), false);
+        assert_eq!(eq_si64(-9223372036854775808, 5577148965131116544), false);
+        assert_eq!(eq_si64(-9223372036854775808, 9223372036854775806), false);
+        assert_eq!(eq_si64(-9223372036854775808, 9223372036854775807), false);
+        assert_eq!(eq_si64(-9223372036854775807, -9223372036854775808), false);
+    }
+    #[test]
+    fn test_30() {
+        assert_eq!(eq_si64(-9223372036854775807, -1741927215160008704), false);
+        assert_eq!(eq_si64(-9223372036854775807, -1328271339354574848), false);
+        assert_eq!(eq_si64(-9223372036854775807, 0), false);
+        assert_eq!(eq_si64(-9223372036854775807, 1), false);
+        assert_eq!(eq_si64(-9223372036854775807, 2), false);
+        assert_eq!(eq_si64(-9223372036854775807, 3), false);
+        assert_eq!(eq_si64(-9223372036854775807, 4), false);
+        assert_eq!(eq_si64(-9223372036854775807, 5577148965131116544), false);
+        assert_eq!(eq_si64(-9223372036854775807, 9223372036854775806), false);
+        assert_eq!(eq_si64(-9223372036854775807, 9223372036854775807), false);
+    }
+    #[test]
+    fn test_31() {
+        assert_eq!(eq_si64(-1741927215160008704, -9223372036854775808), false);
+        assert_eq!(eq_si64(-1741927215160008704, -9223372036854775807), false);
+        assert_eq!(eq_si64(-1741927215160008704, -1328271339354574848), false);
+        assert_eq!(eq_si64(-1741927215160008704, 0), false);
+        assert_eq!(eq_si64(-1741927215160008704, 1), false);
+        assert_eq!(eq_si64(-1741927215160008704, 2), false);
+        assert_eq!(eq_si64(-1741927215160008704, 3), false);
+        assert_eq!(eq_si64(-1741927215160008704, 4), false);
+        assert_eq!(eq_si64(-1741927215160008704, 5577148965131116544), false);
+        assert_eq!(eq_si64(-1741927215160008704, 9223372036854775806), false);
+    }
+    #[test]
+    fn test_32() {
+        assert_eq!(eq_si64(-1741927215160008704, 9223372036854775807), false);
+        assert_eq!(eq_si64(-1328271339354574848, -9223372036854775808), false);
+        assert_eq!(eq_si64(-1328271339354574848, -9223372036854775807), false);
+        assert_eq!(eq_si64(-1328271339354574848, -1741927215160008704), false);
+        assert_eq!(eq_si64(-1328271339354574848, 0), false);
+        assert_eq!(eq_si64(-1328271339354574848, 1), false);
+        assert_eq!(eq_si64(-1328271339354574848, 2), false);
+        assert_eq!(eq_si64(-1328271339354574848, 3), false);
+        assert_eq!(eq_si64(-1328271339354574848, 4), false);
+        assert_eq!(eq_si64(-1328271339354574848, 5577148965131116544), false);
+    }
+    #[test]
+    fn test_33() {
+        assert_eq!(eq_si64(-1328271339354574848, 9223372036854775806), false);
+        assert_eq!(eq_si64(-1328271339354574848, 9223372036854775807), false);
+        assert_eq!(eq_si64(0, -9223372036854775808), false);
+        assert_eq!(eq_si64(0, -9223372036854775807), false);
+        assert_eq!(eq_si64(0, -1741927215160008704), false);
+        assert_eq!(eq_si64(0, -1328271339354574848), false);
+        assert_eq!(eq_si64(0, 1), false);
+        assert_eq!(eq_si64(0, 2), false);
+        assert_eq!(eq_si64(0, 3), false);
+        assert_eq!(eq_si64(0, 4), false);
+    }
+    #[test]
+    fn test_34() {
+        assert_eq!(eq_si64(0, 5577148965131116544), false);
+        assert_eq!(eq_si64(0, 9223372036854775806), false);
+        assert_eq!(eq_si64(0, 9223372036854775807), false);
+        assert_eq!(eq_si64(1, -9223372036854775808), false);
+        assert_eq!(eq_si64(1, -9223372036854775807), false);
+        assert_eq!(eq_si64(1, -1741927215160008704), false);
+        assert_eq!(eq_si64(1, -1328271339354574848), false);
+        assert_eq!(eq_si64(1, 0), false);
+        assert_eq!(eq_si64(1, 2), false);
+        assert_eq!(eq_si64(1, 3), false);
+    }
+    #[test]
+    fn test_35() {
+        assert_eq!(eq_si64(1, 4), false);
+        assert_eq!(eq_si64(1, 5577148965131116544), false);
+        assert_eq!(eq_si64(1, 9223372036854775806), false);
+        assert_eq!(eq_si64(1, 9223372036854775807), false);
+        assert_eq!(eq_si64(2, -9223372036854775808), false);
+        assert_eq!(eq_si64(2, -9223372036854775807), false);
+        assert_eq!(eq_si64(2, -1741927215160008704), false);
+        assert_eq!(eq_si64(2, -1328271339354574848), false);
+        assert_eq!(eq_si64(2, 0), false);
+        assert_eq!(eq_si64(2, 1), false);
+    }
+    #[test]
+    fn test_36() {
+        assert_eq!(eq_si64(2, 3), false);
+        assert_eq!(eq_si64(2, 4), false);
+        assert_eq!(eq_si64(2, 5577148965131116544), false);
+        assert_eq!(eq_si64(2, 9223372036854775806), false);
+        assert_eq!(eq_si64(2, 9223372036854775807), false);
+        assert_eq!(eq_si64(3, -9223372036854775808), false);
+        assert_eq!(eq_si64(3, -9223372036854775807), false);
+        assert_eq!(eq_si64(3, -1741927215160008704), false);
+        assert_eq!(eq_si64(3, -1328271339354574848), false);
+        assert_eq!(eq_si64(3, 0), false);
+    }
+    #[test]
+    fn test_37() {
+        assert_eq!(eq_si64(3, 1), false);
+        assert_eq!(eq_si64(3, 2), false);
+        assert_eq!(eq_si64(3, 4), false);
+        assert_eq!(eq_si64(3, 5577148965131116544), false);
+        assert_eq!(eq_si64(3, 9223372036854775806), false);
+        assert_eq!(eq_si64(3, 9223372036854775807), false);
+        assert_eq!(eq_si64(4, -9223372036854775808), false);
+        assert_eq!(eq_si64(4, -9223372036854775807), false);
+        assert_eq!(eq_si64(4, -1741927215160008704), false);
+        assert_eq!(eq_si64(4, -1328271339354574848), false);
+    }
+    #[test]
+    fn test_38() {
+        assert_eq!(eq_si64(4, 0), false);
+        assert_eq!(eq_si64(4, 1), false);
+        assert_eq!(eq_si64(4, 2), false);
+        assert_eq!(eq_si64(4, 3), false);
+        assert_eq!(eq_si64(4, 5577148965131116544), false);
+        assert_eq!(eq_si64(4, 9223372036854775806), false);
+        assert_eq!(eq_si64(4, 9223372036854775807), false);
+        assert_eq!(eq_si64(5577148965131116544, -9223372036854775808), false);
+        assert_eq!(eq_si64(5577148965131116544, -9223372036854775807), false);
+        assert_eq!(eq_si64(5577148965131116544, -1741927215160008704), false);
+    }
+    #[test]
+    fn test_39() {
+        assert_eq!(eq_si64(5577148965131116544, -1328271339354574848), false);
+        assert_eq!(eq_si64(5577148965131116544, 0), false);
+        assert_eq!(eq_si64(5577148965131116544, 1), false);
+        assert_eq!(eq_si64(5577148965131116544, 2), false);
+        assert_eq!(eq_si64(5577148965131116544, 3), false);
+        assert_eq!(eq_si64(5577148965131116544, 4), false);
+        assert_eq!(eq_si64(5577148965131116544, 9223372036854775806), false);
+        assert_eq!(eq_si64(5577148965131116544, 9223372036854775807), false);
+        assert_eq!(eq_si64(9223372036854775806, -9223372036854775808), false);
+        assert_eq!(eq_si64(9223372036854775806, -9223372036854775807), false);
+    }
+    #[test]
+    fn test_40() {
+        assert_eq!(eq_si64(9223372036854775806, -1741927215160008704), false);
+        assert_eq!(eq_si64(9223372036854775806, -1328271339354574848), false);
+        assert_eq!(eq_si64(9223372036854775806, 0), false);
+        assert_eq!(eq_si64(9223372036854775806, 1), false);
+        assert_eq!(eq_si64(9223372036854775806, 2), false);
+        assert_eq!(eq_si64(9223372036854775806, 3), false);
+        assert_eq!(eq_si64(9223372036854775806, 4), false);
+        assert_eq!(eq_si64(9223372036854775806, 5577148965131116544), false);
+        assert_eq!(eq_si64(9223372036854775806, 9223372036854775807), false);
+        assert_eq!(eq_si64(9223372036854775807, -9223372036854775808), false);
+    }
+    #[test]
+    fn test_41() {
+        assert_eq!(eq_si64(9223372036854775807, -9223372036854775807), false);
+        assert_eq!(eq_si64(9223372036854775807, -1741927215160008704), false);
+        assert_eq!(eq_si64(9223372036854775807, -1328271339354574848), false);
+        assert_eq!(eq_si64(9223372036854775807, 0), false);
+        assert_eq!(eq_si64(9223372036854775807, 1), false);
+        assert_eq!(eq_si64(9223372036854775807, 2), false);
+        assert_eq!(eq_si64(9223372036854775807, 3), false);
+        assert_eq!(eq_si64(9223372036854775807, 4), false);
+        assert_eq!(eq_si64(9223372036854775807, 5577148965131116544), false);
+        assert_eq!(eq_si64(9223372036854775807, 9223372036854775806), false);
+    }
+    #[test]
+    fn test_42() {
+        assert_eq!(eq_si64(-9223372036854775808, -9223372036854775808), true);
+        assert_eq!(eq_si64(-9223372036854775807, -9223372036854775807), true);
+        assert_eq!(eq_si64(-1741927215160008704, -1741927215160008704), true);
+        assert_eq!(eq_si64(-1328271339354574848, -1328271339354574848), true);
+        assert_eq!(eq_si64(0, 0), true);
+        assert_eq!(eq_si64(1, 1), true);
+        assert_eq!(eq_si64(2, 2), true);
+        assert_eq!(eq_si64(3, 3), true);
+        assert_eq!(eq_si64(4, 4), true);
+        assert_eq!(eq_si64(5577148965131116544, 5577148965131116544), true);
+    }
+    #[test]
+    fn test_43() {
+        assert_eq!(eq_si64(9223372036854775806, 9223372036854775806), true);
+        assert_eq!(eq_si64(9223372036854775807, 9223372036854775807), true);
+        assert_eq!(eq_si8(-128, -127), false);
+        assert_eq!(eq_si8(-128, 0), false);
+        assert_eq!(eq_si8(-128, 1), false);
+        assert_eq!(eq_si8(-128, 2), false);
+        assert_eq!(eq_si8(-128, 3), false);
+        assert_eq!(eq_si8(-128, 4), false);
+        assert_eq!(eq_si8(-128, 16), false);
+        assert_eq!(eq_si8(-128, 126), false);
+    }
+    #[test]
+    fn test_44() {
+        assert_eq!(eq_si8(-128, 127), false);
+        assert_eq!(eq_si8(-127, -128), false);
+        assert_eq!(eq_si8(-127, 0), false);
+        assert_eq!(eq_si8(-127, 1), false);
+        assert_eq!(eq_si8(-127, 2), false);
+        assert_eq!(eq_si8(-127, 3), false);
+        assert_eq!(eq_si8(-127, 4), false);
+        assert_eq!(eq_si8(-127, 16), false);
+        assert_eq!(eq_si8(-127, 126), false);
+        assert_eq!(eq_si8(-127, 127), false);
+    }
+    #[test]
+    fn test_45() {
+        assert_eq!(eq_si8(0, -128), false);
+        assert_eq!(eq_si8(0, -127), false);
+        assert_eq!(eq_si8(0, 1), false);
+        assert_eq!(eq_si8(0, 2), false);
+        assert_eq!(eq_si8(0, 3), false);
+        assert_eq!(eq_si8(0, 4), false);
+        assert_eq!(eq_si8(0, 16), false);
+        assert_eq!(eq_si8(0, 126), false);
+        assert_eq!(eq_si8(0, 127), false);
+        assert_eq!(eq_si8(1, -128), false);
+    }
+    #[test]
+    fn test_46() {
+        assert_eq!(eq_si8(1, -127), false);
+        assert_eq!(eq_si8(1, 0), false);
+        assert_eq!(eq_si8(1, 2), false);
+        assert_eq!(eq_si8(1, 3), false);
+        assert_eq!(eq_si8(1, 4), false);
+        assert_eq!(eq_si8(1, 16), false);
+        assert_eq!(eq_si8(1, 126), false);
+        assert_eq!(eq_si8(1, 127), false);
+        assert_eq!(eq_si8(2, -128), false);
+        assert_eq!(eq_si8(2, -127), false);
+    }
+    #[test]
+    fn test_47() {
+        assert_eq!(eq_si8(2, 0), false);
+        assert_eq!(eq_si8(2, 1), false);
+        assert_eq!(eq_si8(2, 3), false);
+        assert_eq!(eq_si8(2, 4), false);
+        assert_eq!(eq_si8(2, 16), false);
+        assert_eq!(eq_si8(2, 126), false);
+        assert_eq!(eq_si8(2, 127), false);
+        assert_eq!(eq_si8(3, -128), false);
+        assert_eq!(eq_si8(3, -127), false);
+        assert_eq!(eq_si8(3, 0), false);
+    }
+    #[test]
+    fn test_48() {
+        assert_eq!(eq_si8(3, 1), false);
+        assert_eq!(eq_si8(3, 2), false);
+        assert_eq!(eq_si8(3, 4), false);
+        assert_eq!(eq_si8(3, 16), false);
+        assert_eq!(eq_si8(3, 126), false);
+        assert_eq!(eq_si8(3, 127), false);
+        assert_eq!(eq_si8(4, -128), false);
+        assert_eq!(eq_si8(4, -127), false);
+        assert_eq!(eq_si8(4, 0), false);
+        assert_eq!(eq_si8(4, 1), false);
+    }
+    #[test]
+    fn test_49() {
+        assert_eq!(eq_si8(4, 2), false);
+        assert_eq!(eq_si8(4, 3), false);
+        assert_eq!(eq_si8(4, 16), false);
+        assert_eq!(eq_si8(4, 126), false);
+        assert_eq!(eq_si8(4, 127), false);
+        assert_eq!(eq_si8(16, -128), false);
+        assert_eq!(eq_si8(16, -127), false);
+        assert_eq!(eq_si8(16, 0), false);
+        assert_eq!(eq_si8(16, 1), false);
+        assert_eq!(eq_si8(16, 2), false);
+    }
+    #[test]
+    fn test_50() {
+        assert_eq!(eq_si8(16, 3), false);
+        assert_eq!(eq_si8(16, 4), false);
+        assert_eq!(eq_si8(16, 126), false);
+        assert_eq!(eq_si8(16, 127), false);
+        assert_eq!(eq_si8(126, -128), false);
+        assert_eq!(eq_si8(126, -127), false);
+        assert_eq!(eq_si8(126, 0), false);
+        assert_eq!(eq_si8(126, 1), false);
+        assert_eq!(eq_si8(126, 2), false);
+        assert_eq!(eq_si8(126, 3), false);
+    }
+    #[test]
+    fn test_51() {
+        assert_eq!(eq_si8(126, 4), false);
+        assert_eq!(eq_si8(126, 16), false);
+        assert_eq!(eq_si8(126, 127), false);
+        assert_eq!(eq_si8(127, -128), false);
+        assert_eq!(eq_si8(127, -127), false);
+        assert_eq!(eq_si8(127, 0), false);
+        assert_eq!(eq_si8(127, 1), false);
+        assert_eq!(eq_si8(127, 2), false);
+        assert_eq!(eq_si8(127, 3), false);
+        assert_eq!(eq_si8(127, 4), false);
+    }
+    #[test]
+    fn test_52() {
+        assert_eq!(eq_si8(127, 16), false);
+        assert_eq!(eq_si8(127, 126), false);
+        assert_eq!(eq_si8(-128, -128), true);
+        assert_eq!(eq_si8(-127, -127), true);
+        assert_eq!(eq_si8(0, 0), true);
+        assert_eq!(eq_si8(1, 1), true);
+        assert_eq!(eq_si8(2, 2), true);
+        assert_eq!(eq_si8(3, 3), true);
+        assert_eq!(eq_si8(4, 4), true);
+        assert_eq!(eq_si8(16, 16), true);
+    }
+    #[test]
+    fn test_53() {
+        assert_eq!(eq_si8(126, 126), true);
+        assert_eq!(eq_si8(127, 127), true);
+        assert_eq!(eq_ui16(0, 1), false);
+        assert_eq!(eq_ui16(0, 2), false);
+        assert_eq!(eq_ui16(0, 3), false);
+        assert_eq!(eq_ui16(0, 4), false);
+        assert_eq!(eq_ui16(0, 1717), false);
+        assert_eq!(eq_ui16(0, 17988), false);
+        assert_eq!(eq_ui16(0, 65096), false);
+        assert_eq!(eq_ui16(0, 65534), false);
+    }
+    #[test]
+    fn test_54() {
+        assert_eq!(eq_ui16(0, 65535), false);
+        assert_eq!(eq_ui16(1, 0), false);
+        assert_eq!(eq_ui16(1, 2), false);
+        assert_eq!(eq_ui16(1, 3), false);
+        assert_eq!(eq_ui16(1, 4), false);
+        assert_eq!(eq_ui16(1, 1717), false);
+        assert_eq!(eq_ui16(1, 17988), false);
+        assert_eq!(eq_ui16(1, 65096), false);
+        assert_eq!(eq_ui16(1, 65534), false);
+        assert_eq!(eq_ui16(1, 65535), false);
+    }
+    #[test]
+    fn test_55() {
+        assert_eq!(eq_ui16(2, 0), false);
+        assert_eq!(eq_ui16(2, 1), false);
+        assert_eq!(eq_ui16(2, 3), false);
+        assert_eq!(eq_ui16(2, 4), false);
+        assert_eq!(eq_ui16(2, 1717), false);
+        assert_eq!(eq_ui16(2, 17988), false);
+        assert_eq!(eq_ui16(2, 65096), false);
+        assert_eq!(eq_ui16(2, 65534), false);
+        assert_eq!(eq_ui16(2, 65535), false);
+        assert_eq!(eq_ui16(3, 0), false);
+    }
+    #[test]
+    fn test_56() {
+        assert_eq!(eq_ui16(3, 1), false);
+        assert_eq!(eq_ui16(3, 2), false);
+        assert_eq!(eq_ui16(3, 4), false);
+        assert_eq!(eq_ui16(3, 1717), false);
+        assert_eq!(eq_ui16(3, 17988), false);
+        assert_eq!(eq_ui16(3, 65096), false);
+        assert_eq!(eq_ui16(3, 65534), false);
+        assert_eq!(eq_ui16(3, 65535), false);
+        assert_eq!(eq_ui16(4, 0), false);
+        assert_eq!(eq_ui16(4, 1), false);
+    }
+    #[test]
+    fn test_57() {
+        assert_eq!(eq_ui16(4, 2), false);
+        assert_eq!(eq_ui16(4, 3), false);
+        assert_eq!(eq_ui16(4, 1717), false);
+        assert_eq!(eq_ui16(4, 17988), false);
+        assert_eq!(eq_ui16(4, 65096), false);
+        assert_eq!(eq_ui16(4, 65534), false);
+        assert_eq!(eq_ui16(4, 65535), false);
+        assert_eq!(eq_ui16(1717, 0), false);
+        assert_eq!(eq_ui16(1717, 1), false);
+        assert_eq!(eq_ui16(1717, 2), false);
+    }
+    #[test]
+    fn test_58() {
+        assert_eq!(eq_ui16(1717, 3), false);
+        assert_eq!(eq_ui16(1717, 4), false);
+        assert_eq!(eq_ui16(1717, 17988), false);
+        assert_eq!(eq_ui16(1717, 65096), false);
+        assert_eq!(eq_ui16(1717, 65534), false);
+        assert_eq!(eq_ui16(1717, 65535), false);
+        assert_eq!(eq_ui16(17988, 0), false);
+        assert_eq!(eq_ui16(17988, 1), false);
+        assert_eq!(eq_ui16(17988, 2), false);
+        assert_eq!(eq_ui16(17988, 3), false);
+    }
+    #[test]
+    fn test_59() {
+        assert_eq!(eq_ui16(17988, 4), false);
+        assert_eq!(eq_ui16(17988, 1717), false);
+        assert_eq!(eq_ui16(17988, 65096), false);
+        assert_eq!(eq_ui16(17988, 65534), false);
+        assert_eq!(eq_ui16(17988, 65535), false);
+        assert_eq!(eq_ui16(65096, 0), false);
+        assert_eq!(eq_ui16(65096, 1), false);
+        assert_eq!(eq_ui16(65096, 2), false);
+        assert_eq!(eq_ui16(65096, 3), false);
+        assert_eq!(eq_ui16(65096, 4), false);
+    }
+    #[test]
+    fn test_60() {
+        assert_eq!(eq_ui16(65096, 1717), false);
+        assert_eq!(eq_ui16(65096, 17988), false);
+        assert_eq!(eq_ui16(65096, 65534), false);
+        assert_eq!(eq_ui16(65096, 65535), false);
+        assert_eq!(eq_ui16(65534, 0), false);
+        assert_eq!(eq_ui16(65534, 1), false);
+        assert_eq!(eq_ui16(65534, 2), false);
+        assert_eq!(eq_ui16(65534, 3), false);
+        assert_eq!(eq_ui16(65534, 4), false);
+        assert_eq!(eq_ui16(65534, 1717), false);
+    }
+    #[test]
+    fn test_61() {
+        assert_eq!(eq_ui16(65534, 17988), false);
+        assert_eq!(eq_ui16(65534, 65096), false);
+        assert_eq!(eq_ui16(65534, 65535), false);
+        assert_eq!(eq_ui16(65535, 0), false);
+        assert_eq!(eq_ui16(65535, 1), false);
+        assert_eq!(eq_ui16(65535, 2), false);
+        assert_eq!(eq_ui16(65535, 3), false);
+        assert_eq!(eq_ui16(65535, 4), false);
+        assert_eq!(eq_ui16(65535, 1717), false);
+        assert_eq!(eq_ui16(65535, 17988), false);
+    }
+    #[test]
+    fn test_62() {
+        assert_eq!(eq_ui16(65535, 65096), false);
+        assert_eq!(eq_ui16(65535, 65534), false);
+        assert_eq!(eq_ui16(0, 0), true);
+        assert_eq!(eq_ui16(1, 1), true);
+        assert_eq!(eq_ui16(2, 2), true);
+        assert_eq!(eq_ui16(3, 3), true);
+        assert_eq!(eq_ui16(4, 4), true);
+        assert_eq!(eq_ui16(1717, 1717), true);
+        assert_eq!(eq_ui16(17988, 17988), true);
+        assert_eq!(eq_ui16(65096, 65096), true);
+    }
+    #[test]
+    fn test_63() {
+        assert_eq!(eq_ui16(65534, 65534), true);
+        assert_eq!(eq_ui16(65535, 65535), true);
+        assert_eq!(eq_ui32(0, 1), false);
+        assert_eq!(eq_ui32(0, 2), false);
+        assert_eq!(eq_ui32(0, 3), false);
+        assert_eq!(eq_ui32(0, 4), false);
+        assert_eq!(eq_ui32(0, 2119154652), false);
+        assert_eq!(eq_ui32(0, 3002788344), false);
+        assert_eq!(eq_ui32(0, 3482297128), false);
+        assert_eq!(eq_ui32(0, 4294967294), false);
+    }
+    #[test]
+    fn test_64() {
+        assert_eq!(eq_ui32(0, 4294967295), false);
+        assert_eq!(eq_ui32(1, 0), false);
+        assert_eq!(eq_ui32(1, 2), false);
+        assert_eq!(eq_ui32(1, 3), false);
+        assert_eq!(eq_ui32(1, 4), false);
+        assert_eq!(eq_ui32(1, 2119154652), false);
+        assert_eq!(eq_ui32(1, 3002788344), false);
+        assert_eq!(eq_ui32(1, 3482297128), false);
+        assert_eq!(eq_ui32(1, 4294967294), false);
+        assert_eq!(eq_ui32(1, 4294967295), false);
+    }
+    #[test]
+    fn test_65() {
+        assert_eq!(eq_ui32(2, 0), false);
+        assert_eq!(eq_ui32(2, 1), false);
+        assert_eq!(eq_ui32(2, 3), false);
+        assert_eq!(eq_ui32(2, 4), false);
+        assert_eq!(eq_ui32(2, 2119154652), false);
+        assert_eq!(eq_ui32(2, 3002788344), false);
+        assert_eq!(eq_ui32(2, 3482297128), false);
+        assert_eq!(eq_ui32(2, 4294967294), false);
+        assert_eq!(eq_ui32(2, 4294967295), false);
+        assert_eq!(eq_ui32(3, 0), false);
+    }
+    #[test]
+    fn test_66() {
+        assert_eq!(eq_ui32(3, 1), false);
+        assert_eq!(eq_ui32(3, 2), false);
+        assert_eq!(eq_ui32(3, 4), false);
+        assert_eq!(eq_ui32(3, 2119154652), false);
+        assert_eq!(eq_ui32(3, 3002788344), false);
+        assert_eq!(eq_ui32(3, 3482297128), false);
+        assert_eq!(eq_ui32(3, 4294967294), false);
+        assert_eq!(eq_ui32(3, 4294967295), false);
+        assert_eq!(eq_ui32(4, 0), false);
+        assert_eq!(eq_ui32(4, 1), false);
+    }
+    #[test]
+    fn test_67() {
+        assert_eq!(eq_ui32(4, 2), false);
+        assert_eq!(eq_ui32(4, 3), false);
+        assert_eq!(eq_ui32(4, 2119154652), false);
+        assert_eq!(eq_ui32(4, 3002788344), false);
+        assert_eq!(eq_ui32(4, 3482297128), false);
+        assert_eq!(eq_ui32(4, 4294967294), false);
+        assert_eq!(eq_ui32(4, 4294967295), false);
+        assert_eq!(eq_ui32(2119154652, 0), false);
+        assert_eq!(eq_ui32(2119154652, 1), false);
+        assert_eq!(eq_ui32(2119154652, 2), false);
+    }
+    #[test]
+    fn test_68() {
+        assert_eq!(eq_ui32(2119154652, 3), false);
+        assert_eq!(eq_ui32(2119154652, 4), false);
+        assert_eq!(eq_ui32(2119154652, 3002788344), false);
+        assert_eq!(eq_ui32(2119154652, 3482297128), false);
+        assert_eq!(eq_ui32(2119154652, 4294967294), false);
+        assert_eq!(eq_ui32(2119154652, 4294967295), false);
+        assert_eq!(eq_ui32(3002788344, 0), false);
+        assert_eq!(eq_ui32(3002788344, 1), false);
+        assert_eq!(eq_ui32(3002788344, 2), false);
+        assert_eq!(eq_ui32(3002788344, 3), false);
+    }
+    #[test]
+    fn test_69() {
+        assert_eq!(eq_ui32(3002788344, 4), false);
+        assert_eq!(eq_ui32(3002788344, 2119154652), false);
+        assert_eq!(eq_ui32(3002788344, 3482297128), false);
+        assert_eq!(eq_ui32(3002788344, 4294967294), false);
+        assert_eq!(eq_ui32(3002788344, 4294967295), false);
+        assert_eq!(eq_ui32(3482297128, 0), false);
+        assert_eq!(eq_ui32(3482297128, 1), false);
+        assert_eq!(eq_ui32(3482297128, 2), false);
+        assert_eq!(eq_ui32(3482297128, 3), false);
+        assert_eq!(eq_ui32(3482297128, 4), false);
+    }
+    #[test]
+    fn test_70() {
+        assert_eq!(eq_ui32(3482297128, 2119154652), false);
+        assert_eq!(eq_ui32(3482297128, 3002788344), false);
+        assert_eq!(eq_ui32(3482297128, 4294967294), false);
+        assert_eq!(eq_ui32(3482297128, 4294967295), false);
+        assert_eq!(eq_ui32(4294967294, 0), false);
+        assert_eq!(eq_ui32(4294967294, 1), false);
+        assert_eq!(eq_ui32(4294967294, 2), false);
+        assert_eq!(eq_ui32(4294967294, 3), false);
+        assert_eq!(eq_ui32(4294967294, 4), false);
+        assert_eq!(eq_ui32(4294967294, 2119154652), false);
+    }
+    #[test]
+    fn test_71() {
+        assert_eq!(eq_ui32(4294967294, 3002788344), false);
+        assert_eq!(eq_ui32(4294967294, 3482297128), false);
+        assert_eq!(eq_ui32(4294967294, 4294967295), false);
+        assert_eq!(eq_ui32(4294967295, 0), false);
+        assert_eq!(eq_ui32(4294967295, 1), false);
+        assert_eq!(eq_ui32(4294967295, 2), false);
+        assert_eq!(eq_ui32(4294967295, 3), false);
+        assert_eq!(eq_ui32(4294967295, 4), false);
+        assert_eq!(eq_ui32(4294967295, 2119154652), false);
+        assert_eq!(eq_ui32(4294967295, 3002788344), false);
+    }
+    #[test]
+    fn test_72() {
+        assert_eq!(eq_ui32(4294967295, 3482297128), false);
+        assert_eq!(eq_ui32(4294967295, 4294967294), false);
+        assert_eq!(eq_ui32(0, 0), true);
+        assert_eq!(eq_ui32(1, 1), true);
+        assert_eq!(eq_ui32(2, 2), true);
+        assert_eq!(eq_ui32(3, 3), true);
+        assert_eq!(eq_ui32(4, 4), true);
+        assert_eq!(eq_ui32(2119154652, 2119154652), true);
+        assert_eq!(eq_ui32(3002788344, 3002788344), true);
+        assert_eq!(eq_ui32(3482297128, 3482297128), true);
+    }
+    #[test]
+    fn test_73() {
+        assert_eq!(eq_ui32(4294967294, 4294967294), true);
+        assert_eq!(eq_ui32(4294967295, 4294967295), true);
+        assert_eq!(eq_ui64(0, 1), false);
+        assert_eq!(eq_ui64(0, 2), false);
+        assert_eq!(eq_ui64(0, 3), false);
+        assert_eq!(eq_ui64(0, 4), false);
+        assert_eq!(eq_ui64(0, 191084152064409600), false);
+        assert_eq!(eq_ui64(0, 11015955194427482112), false);
+        assert_eq!(eq_ui64(0, 16990600415051759616), false);
+        assert_eq!(eq_ui64(0, 18446744073709551614), false);
+    }
+    #[test]
+    fn test_74() {
+        assert_eq!(eq_ui64(0, 18446744073709551615), false);
+        assert_eq!(eq_ui64(1, 0), false);
+        assert_eq!(eq_ui64(1, 2), false);
+        assert_eq!(eq_ui64(1, 3), false);
+        assert_eq!(eq_ui64(1, 4), false);
+        assert_eq!(eq_ui64(1, 191084152064409600), false);
+        assert_eq!(eq_ui64(1, 11015955194427482112), false);
+        assert_eq!(eq_ui64(1, 16990600415051759616), false);
+        assert_eq!(eq_ui64(1, 18446744073709551614), false);
+        assert_eq!(eq_ui64(1, 18446744073709551615), false);
+    }
+    #[test]
+    fn test_75() {
+        assert_eq!(eq_ui64(2, 0), false);
+        assert_eq!(eq_ui64(2, 1), false);
+        assert_eq!(eq_ui64(2, 3), false);
+        assert_eq!(eq_ui64(2, 4), false);
+        assert_eq!(eq_ui64(2, 191084152064409600), false);
+        assert_eq!(eq_ui64(2, 11015955194427482112), false);
+        assert_eq!(eq_ui64(2, 16990600415051759616), false);
+        assert_eq!(eq_ui64(2, 18446744073709551614), false);
+        assert_eq!(eq_ui64(2, 18446744073709551615), false);
+        assert_eq!(eq_ui64(3, 0), false);
+    }
+    #[test]
+    fn test_76() {
+        assert_eq!(eq_ui64(3, 1), false);
+        assert_eq!(eq_ui64(3, 2), false);
+        assert_eq!(eq_ui64(3, 4), false);
+        assert_eq!(eq_ui64(3, 191084152064409600), false);
+        assert_eq!(eq_ui64(3, 11015955194427482112), false);
+        assert_eq!(eq_ui64(3, 16990600415051759616), false);
+        assert_eq!(eq_ui64(3, 18446744073709551614), false);
+        assert_eq!(eq_ui64(3, 18446744073709551615), false);
+        assert_eq!(eq_ui64(4, 0), false);
+        assert_eq!(eq_ui64(4, 1), false);
+    }
+    #[test]
+    fn test_77() {
+        assert_eq!(eq_ui64(4, 2), false);
+        assert_eq!(eq_ui64(4, 3), false);
+        assert_eq!(eq_ui64(4, 191084152064409600), false);
+        assert_eq!(eq_ui64(4, 11015955194427482112), false);
+        assert_eq!(eq_ui64(4, 16990600415051759616), false);
+        assert_eq!(eq_ui64(4, 18446744073709551614), false);
+        assert_eq!(eq_ui64(4, 18446744073709551615), false);
+        assert_eq!(eq_ui64(191084152064409600, 0), false);
+        assert_eq!(eq_ui64(191084152064409600, 1), false);
+        assert_eq!(eq_ui64(191084152064409600, 2), false);
+    }
+    #[test]
+    fn test_78() {
+        assert_eq!(eq_ui64(191084152064409600, 3), false);
+        assert_eq!(eq_ui64(191084152064409600, 4), false);
+        assert_eq!(eq_ui64(191084152064409600, 11015955194427482112), false);
+        assert_eq!(eq_ui64(191084152064409600, 16990600415051759616), false);
+        assert_eq!(eq_ui64(191084152064409600, 18446744073709551614), false);
+        assert_eq!(eq_ui64(191084152064409600, 18446744073709551615), false);
+        assert_eq!(eq_ui64(11015955194427482112, 0), false);
+        assert_eq!(eq_ui64(11015955194427482112, 1), false);
+        assert_eq!(eq_ui64(11015955194427482112, 2), false);
+        assert_eq!(eq_ui64(11015955194427482112, 3), false);
+    }
+    #[test]
+    fn test_79() {
+        assert_eq!(eq_ui64(11015955194427482112, 4), false);
+        assert_eq!(eq_ui64(11015955194427482112, 191084152064409600), false);
+        assert_eq!(eq_ui64(11015955194427482112, 16990600415051759616), false);
+        assert_eq!(eq_ui64(11015955194427482112, 18446744073709551614), false);
+        assert_eq!(eq_ui64(11015955194427482112, 18446744073709551615), false);
+        assert_eq!(eq_ui64(16990600415051759616, 0), false);
+        assert_eq!(eq_ui64(16990600415051759616, 1), false);
+        assert_eq!(eq_ui64(16990600415051759616, 2), false);
+        assert_eq!(eq_ui64(16990600415051759616, 3), false);
+        assert_eq!(eq_ui64(16990600415051759616, 4), false);
+    }
+    #[test]
+    fn test_80() {
+        assert_eq!(eq_ui64(16990600415051759616, 191084152064409600), false);
+        assert_eq!(eq_ui64(16990600415051759616, 11015955194427482112), false);
+        assert_eq!(eq_ui64(16990600415051759616, 18446744073709551614), false);
+        assert_eq!(eq_ui64(16990600415051759616, 18446744073709551615), false);
+        assert_eq!(eq_ui64(18446744073709551614, 0), false);
+        assert_eq!(eq_ui64(18446744073709551614, 1), false);
+        assert_eq!(eq_ui64(18446744073709551614, 2), false);
+        assert_eq!(eq_ui64(18446744073709551614, 3), false);
+        assert_eq!(eq_ui64(18446744073709551614, 4), false);
+        assert_eq!(eq_ui64(18446744073709551614, 191084152064409600), false);
+    }
+    #[test]
+    fn test_81() {
+        assert_eq!(eq_ui64(18446744073709551614, 11015955194427482112), false);
+        assert_eq!(eq_ui64(18446744073709551614, 16990600415051759616), false);
+        assert_eq!(eq_ui64(18446744073709551614, 18446744073709551615), false);
+        assert_eq!(eq_ui64(18446744073709551615, 0), false);
+        assert_eq!(eq_ui64(18446744073709551615, 1), false);
+        assert_eq!(eq_ui64(18446744073709551615, 2), false);
+        assert_eq!(eq_ui64(18446744073709551615, 3), false);
+        assert_eq!(eq_ui64(18446744073709551615, 4), false);
+        assert_eq!(eq_ui64(18446744073709551615, 191084152064409600), false);
+        assert_eq!(eq_ui64(18446744073709551615, 11015955194427482112), false);
+    }
+    #[test]
+    fn test_82() {
+        assert_eq!(eq_ui64(18446744073709551615, 16990600415051759616), false);
+        assert_eq!(eq_ui64(18446744073709551615, 18446744073709551614), false);
+        assert_eq!(eq_ui64(0, 0), true);
+        assert_eq!(eq_ui64(1, 1), true);
+        assert_eq!(eq_ui64(2, 2), true);
+        assert_eq!(eq_ui64(3, 3), true);
+        assert_eq!(eq_ui64(4, 4), true);
+        assert_eq!(eq_ui64(191084152064409600, 191084152064409600), true);
+        assert_eq!(eq_ui64(11015955194427482112, 11015955194427482112), true);
+        assert_eq!(eq_ui64(16990600415051759616, 16990600415051759616), true);
+    }
+    #[test]
+    fn test_83() {
+        assert_eq!(eq_ui64(18446744073709551614, 18446744073709551614), true);
+        assert_eq!(eq_ui64(18446744073709551615, 18446744073709551615), true);
+        assert_eq!(eq_ui8(0, 1), false);
+        assert_eq!(eq_ui8(0, 2), false);
+        assert_eq!(eq_ui8(0, 3), false);
+        assert_eq!(eq_ui8(0, 4), false);
+        assert_eq!(eq_ui8(0, 72), false);
+        assert_eq!(eq_ui8(0, 100), false);
+        assert_eq!(eq_ui8(0, 162), false);
+        assert_eq!(eq_ui8(0, 254), false);
+    }
+    #[test]
+    fn test_84() {
+        assert_eq!(eq_ui8(0, 255), false);
+        assert_eq!(eq_ui8(1, 0), false);
+        assert_eq!(eq_ui8(1, 2), false);
+        assert_eq!(eq_ui8(1, 3), false);
+        assert_eq!(eq_ui8(1, 4), false);
+        assert_eq!(eq_ui8(1, 72), false);
+        assert_eq!(eq_ui8(1, 100), false);
+        assert_eq!(eq_ui8(1, 162), false);
+        assert_eq!(eq_ui8(1, 254), false);
+        assert_eq!(eq_ui8(1, 255), false);
+    }
+    #[test]
+    fn test_85() {
+        assert_eq!(eq_ui8(2, 0), false);
+        assert_eq!(eq_ui8(2, 1), false);
+        assert_eq!(eq_ui8(2, 3), false);
+        assert_eq!(eq_ui8(2, 4), false);
+        assert_eq!(eq_ui8(2, 72), false);
+        assert_eq!(eq_ui8(2, 100), false);
+        assert_eq!(eq_ui8(2, 162), false);
+        assert_eq!(eq_ui8(2, 254), false);
+        assert_eq!(eq_ui8(2, 255), false);
+        assert_eq!(eq_ui8(3, 0), false);
+    }
+    #[test]
+    fn test_86() {
+        assert_eq!(eq_ui8(3, 1), false);
+        assert_eq!(eq_ui8(3, 2), false);
+        assert_eq!(eq_ui8(3, 4), false);
+        assert_eq!(eq_ui8(3, 72), false);
+        assert_eq!(eq_ui8(3, 100), false);
+        assert_eq!(eq_ui8(3, 162), false);
+        assert_eq!(eq_ui8(3, 254), false);
+        assert_eq!(eq_ui8(3, 255), false);
+        assert_eq!(eq_ui8(4, 0), false);
+        assert_eq!(eq_ui8(4, 1), false);
+    }
+    #[test]
+    fn test_87() {
+        assert_eq!(eq_ui8(4, 2), false);
+        assert_eq!(eq_ui8(4, 3), false);
+        assert_eq!(eq_ui8(4, 72), false);
+        assert_eq!(eq_ui8(4, 100), false);
+        assert_eq!(eq_ui8(4, 162), false);
+        assert_eq!(eq_ui8(4, 254), false);
+        assert_eq!(eq_ui8(4, 255), false);
+        assert_eq!(eq_ui8(72, 0), false);
+        assert_eq!(eq_ui8(72, 1), false);
+        assert_eq!(eq_ui8(72, 2), false);
+    }
+    #[test]
+    fn test_88() {
+        assert_eq!(eq_ui8(72, 3), false);
+        assert_eq!(eq_ui8(72, 4), false);
+        assert_eq!(eq_ui8(72, 100), false);
+        assert_eq!(eq_ui8(72, 162), false);
+        assert_eq!(eq_ui8(72, 254), false);
+        assert_eq!(eq_ui8(72, 255), false);
+        assert_eq!(eq_ui8(100, 0), false);
+        assert_eq!(eq_ui8(100, 1), false);
+        assert_eq!(eq_ui8(100, 2), false);
+        assert_eq!(eq_ui8(100, 3), false);
+    }
+    #[test]
+    fn test_89() {
+        assert_eq!(eq_ui8(100, 4), false);
+        assert_eq!(eq_ui8(100, 72), false);
+        assert_eq!(eq_ui8(100, 162), false);
+        assert_eq!(eq_ui8(100, 254), false);
+        assert_eq!(eq_ui8(100, 255), false);
+        assert_eq!(eq_ui8(162, 0), false);
+        assert_eq!(eq_ui8(162, 1), false);
+        assert_eq!(eq_ui8(162, 2), false);
+        assert_eq!(eq_ui8(162, 3), false);
+        assert_eq!(eq_ui8(162, 4), false);
+    }
+    #[test]
+    fn test_90() {
+        assert_eq!(eq_ui8(162, 72), false);
+        assert_eq!(eq_ui8(162, 100), false);
+        assert_eq!(eq_ui8(162, 254), false);
+        assert_eq!(eq_ui8(162, 255), false);
+        assert_eq!(eq_ui8(254, 0), false);
+        assert_eq!(eq_ui8(254, 1), false);
+        assert_eq!(eq_ui8(254, 2), false);
+        assert_eq!(eq_ui8(254, 3), false);
+        assert_eq!(eq_ui8(254, 4), false);
+        assert_eq!(eq_ui8(254, 72), false);
+    }
+    #[test]
+    fn test_91() {
+        assert_eq!(eq_ui8(254, 100), false);
+        assert_eq!(eq_ui8(254, 162), false);
+        assert_eq!(eq_ui8(254, 255), false);
+        assert_eq!(eq_ui8(255, 0), false);
+        assert_eq!(eq_ui8(255, 1), false);
+        assert_eq!(eq_ui8(255, 2), false);
+        assert_eq!(eq_ui8(255, 3), false);
+        assert_eq!(eq_ui8(255, 4), false);
+        assert_eq!(eq_ui8(255, 72), false);
+        assert_eq!(eq_ui8(255, 100), false);
+    }
+    #[test]
+    fn test_92() {
+        assert_eq!(eq_ui8(255, 162), false);
+        assert_eq!(eq_ui8(255, 254), false);
+        assert_eq!(eq_ui8(0, 0), true);
+        assert_eq!(eq_ui8(1, 1), true);
+        assert_eq!(eq_ui8(2, 2), true);
+        assert_eq!(eq_ui8(3, 3), true);
+        assert_eq!(eq_ui8(4, 4), true);
+        assert_eq!(eq_ui8(72, 72), true);
+        assert_eq!(eq_ui8(100, 100), true);
+        assert_eq!(eq_ui8(162, 162), true);
+    }
+    #[test]
+    fn test_93() {
+        assert_eq!(eq_ui8(254, 254), true);
+        assert_eq!(eq_ui8(255, 255), true);
+        assert_eq!(ge_si16(-32768, -32767), false);
+        assert_eq!(ge_si16(-32768, -32547), false);
+        assert_eq!(ge_si16(-32768, 0), false);
+        assert_eq!(ge_si16(-32768, 1), false);
+        assert_eq!(ge_si16(-32768, 2), false);
+        assert_eq!(ge_si16(-32768, 3), false);
+        assert_eq!(ge_si16(-32768, 4), false);
+        assert_eq!(ge_si16(-32768, 10486), false);
+    }
+    #[test]
+    fn test_94() {
+        assert_eq!(ge_si16(-32768, 16514), false);
+        assert_eq!(ge_si16(-32768, 32766), false);
+        assert_eq!(ge_si16(-32768, 32767), false);
+        assert_eq!(ge_si16(-32767, -32547), false);
+        assert_eq!(ge_si16(-32767, 0), false);
+        assert_eq!(ge_si16(-32767, 1), false);
+        assert_eq!(ge_si16(-32767, 2), false);
+        assert_eq!(ge_si16(-32767, 3), false);
+        assert_eq!(ge_si16(-32767, 4), false);
+        assert_eq!(ge_si16(-32767, 10486), false);
+    }
+    #[test]
+    fn test_95() {
+        assert_eq!(ge_si16(-32767, 16514), false);
+        assert_eq!(ge_si16(-32767, 32766), false);
+        assert_eq!(ge_si16(-32767, 32767), false);
+        assert_eq!(ge_si16(-32547, 0), false);
+        assert_eq!(ge_si16(-32547, 1), false);
+        assert_eq!(ge_si16(-32547, 2), false);
+        assert_eq!(ge_si16(-32547, 3), false);
+        assert_eq!(ge_si16(-32547, 4), false);
+        assert_eq!(ge_si16(-32547, 10486), false);
+        assert_eq!(ge_si16(-32547, 16514), false);
+    }
+    #[test]
+    fn test_96() {
+        assert_eq!(ge_si16(-32547, 32766), false);
+        assert_eq!(ge_si16(-32547, 32767), false);
+        assert_eq!(ge_si16(0, 1), false);
+        assert_eq!(ge_si16(0, 2), false);
+        assert_eq!(ge_si16(0, 3), false);
+        assert_eq!(ge_si16(0, 4), false);
+        assert_eq!(ge_si16(0, 10486), false);
+        assert_eq!(ge_si16(0, 16514), false);
+        assert_eq!(ge_si16(0, 32766), false);
+        assert_eq!(ge_si16(0, 32767), false);
+    }
+    #[test]
+    fn test_97() {
+        assert_eq!(ge_si16(1, 2), false);
+        assert_eq!(ge_si16(1, 3), false);
+        assert_eq!(ge_si16(1, 4), false);
+        assert_eq!(ge_si16(1, 10486), false);
+        assert_eq!(ge_si16(1, 16514), false);
+        assert_eq!(ge_si16(1, 32766), false);
+        assert_eq!(ge_si16(1, 32767), false);
+        assert_eq!(ge_si16(2, 3), false);
+        assert_eq!(ge_si16(2, 4), false);
+        assert_eq!(ge_si16(2, 10486), false);
+    }
+    #[test]
+    fn test_98() {
+        assert_eq!(ge_si16(2, 16514), false);
+        assert_eq!(ge_si16(2, 32766), false);
+        assert_eq!(ge_si16(2, 32767), false);
+        assert_eq!(ge_si16(3, 4), false);
+        assert_eq!(ge_si16(3, 10486), false);
+        assert_eq!(ge_si16(3, 16514), false);
+        assert_eq!(ge_si16(3, 32766), false);
+        assert_eq!(ge_si16(3, 32767), false);
+        assert_eq!(ge_si16(4, 10486), false);
+        assert_eq!(ge_si16(4, 16514), false);
+    }
+    #[test]
+    fn test_99() {
+        assert_eq!(ge_si16(4, 32766), false);
+        assert_eq!(ge_si16(4, 32767), false);
+        assert_eq!(ge_si16(10486, 16514), false);
+        assert_eq!(ge_si16(10486, 32766), false);
+        assert_eq!(ge_si16(10486, 32767), false);
+        assert_eq!(ge_si16(16514, 32766), false);
+        assert_eq!(ge_si16(16514, 32767), false);
+        assert_eq!(ge_si16(32766, 32767), false);
+        assert_eq!(ge_si16(-32768, -32768), true);
+        assert_eq!(ge_si16(-32767, -32768), true);
+    }
+    #[test]
+    fn test_100() {
+        assert_eq!(ge_si16(-32767, -32767), true);
+        assert_eq!(ge_si16(-32547, -32768), true);
+        assert_eq!(ge_si16(-32547, -32767), true);
+        assert_eq!(ge_si16(-32547, -32547), true);
+        assert_eq!(ge_si16(0, -32768), true);
+        assert_eq!(ge_si16(0, -32767), true);
+        assert_eq!(ge_si16(0, -32547), true);
+        assert_eq!(ge_si16(0, 0), true);
+        assert_eq!(ge_si16(1, -32768), true);
+        assert_eq!(ge_si16(1, -32767), true);
+    }
+    #[test]
+    fn test_101() {
+        assert_eq!(ge_si16(1, -32547), true);
+        assert_eq!(ge_si16(1, 0), true);
+        assert_eq!(ge_si16(1, 1), true);
+        assert_eq!(ge_si16(2, -32768), true);
+        assert_eq!(ge_si16(2, -32767), true);
+        assert_eq!(ge_si16(2, -32547), true);
+        assert_eq!(ge_si16(2, 0), true);
+        assert_eq!(ge_si16(2, 1), true);
+        assert_eq!(ge_si16(2, 2), true);
+        assert_eq!(ge_si16(3, -32768), true);
+    }
+    #[test]
+    fn test_102() {
+        assert_eq!(ge_si16(3, -32767), true);
+        assert_eq!(ge_si16(3, -32547), true);
+        assert_eq!(ge_si16(3, 0), true);
+        assert_eq!(ge_si16(3, 1), true);
+        assert_eq!(ge_si16(3, 2), true);
+        assert_eq!(ge_si16(3, 3), true);
+        assert_eq!(ge_si16(4, -32768), true);
+        assert_eq!(ge_si16(4, -32767), true);
+        assert_eq!(ge_si16(4, -32547), true);
+        assert_eq!(ge_si16(4, 0), true);
+    }
+    #[test]
+    fn test_103() {
+        assert_eq!(ge_si16(4, 1), true);
+        assert_eq!(ge_si16(4, 2), true);
+        assert_eq!(ge_si16(4, 3), true);
+        assert_eq!(ge_si16(4, 4), true);
+        assert_eq!(ge_si16(10486, -32768), true);
+        assert_eq!(ge_si16(10486, -32767), true);
+        assert_eq!(ge_si16(10486, -32547), true);
+        assert_eq!(ge_si16(10486, 0), true);
+        assert_eq!(ge_si16(10486, 1), true);
+        assert_eq!(ge_si16(10486, 2), true);
+    }
+    #[test]
+    fn test_104() {
+        assert_eq!(ge_si16(10486, 3), true);
+        assert_eq!(ge_si16(10486, 4), true);
+        assert_eq!(ge_si16(10486, 10486), true);
+        assert_eq!(ge_si16(16514, -32768), true);
+        assert_eq!(ge_si16(16514, -32767), true);
+        assert_eq!(ge_si16(16514, -32547), true);
+        assert_eq!(ge_si16(16514, 0), true);
+        assert_eq!(ge_si16(16514, 1), true);
+        assert_eq!(ge_si16(16514, 2), true);
+        assert_eq!(ge_si16(16514, 3), true);
+    }
+    #[test]
+    fn test_105() {
+        assert_eq!(ge_si16(16514, 4), true);
+        assert_eq!(ge_si16(16514, 10486), true);
+        assert_eq!(ge_si16(16514, 16514), true);
+        assert_eq!(ge_si16(32766, -32768), true);
+        assert_eq!(ge_si16(32766, -32767), true);
+        assert_eq!(ge_si16(32766, -32547), true);
+        assert_eq!(ge_si16(32766, 0), true);
+        assert_eq!(ge_si16(32766, 1), true);
+        assert_eq!(ge_si16(32766, 2), true);
+        assert_eq!(ge_si16(32766, 3), true);
+    }
+    #[test]
+    fn test_106() {
+        assert_eq!(ge_si16(32766, 4), true);
+        assert_eq!(ge_si16(32766, 10486), true);
+        assert_eq!(ge_si16(32766, 16514), true);
+        assert_eq!(ge_si16(32766, 32766), true);
+        assert_eq!(ge_si16(32767, -32768), true);
+        assert_eq!(ge_si16(32767, -32767), true);
+        assert_eq!(ge_si16(32767, -32547), true);
+        assert_eq!(ge_si16(32767, 0), true);
+        assert_eq!(ge_si16(32767, 1), true);
+        assert_eq!(ge_si16(32767, 2), true);
+    }
+    #[test]
+    fn test_107() {
+        assert_eq!(ge_si16(32767, 3), true);
+        assert_eq!(ge_si16(32767, 4), true);
+        assert_eq!(ge_si16(32767, 10486), true);
+        assert_eq!(ge_si16(32767, 16514), true);
+        assert_eq!(ge_si16(32767, 32766), true);
+        assert_eq!(ge_si16(32767, 32767), true);
+        assert_eq!(ge_si32(-2147483648, -2147483647), false);
+        assert_eq!(ge_si32(-2147483648, -1713183800), false);
+        assert_eq!(ge_si32(-2147483648, -1252582164), false);
+        assert_eq!(ge_si32(-2147483648, -1035405763), false);
+    }
+    #[test]
+    fn test_108() {
+        assert_eq!(ge_si32(-2147483648, 0), false);
+        assert_eq!(ge_si32(-2147483648, 1), false);
+        assert_eq!(ge_si32(-2147483648, 2), false);
+        assert_eq!(ge_si32(-2147483648, 3), false);
+        assert_eq!(ge_si32(-2147483648, 4), false);
+        assert_eq!(ge_si32(-2147483648, 2147483646), false);
+        assert_eq!(ge_si32(-2147483648, 2147483647), false);
+        assert_eq!(ge_si32(-2147483647, -1713183800), false);
+        assert_eq!(ge_si32(-2147483647, -1252582164), false);
+        assert_eq!(ge_si32(-2147483647, -1035405763), false);
+    }
+    #[test]
+    fn test_109() {
+        assert_eq!(ge_si32(-2147483647, 0), false);
+        assert_eq!(ge_si32(-2147483647, 1), false);
+        assert_eq!(ge_si32(-2147483647, 2), false);
+        assert_eq!(ge_si32(-2147483647, 3), false);
+        assert_eq!(ge_si32(-2147483647, 4), false);
+        assert_eq!(ge_si32(-2147483647, 2147483646), false);
+        assert_eq!(ge_si32(-2147483647, 2147483647), false);
+        assert_eq!(ge_si32(-1713183800, -1252582164), false);
+        assert_eq!(ge_si32(-1713183800, -1035405763), false);
+        assert_eq!(ge_si32(-1713183800, 0), false);
+    }
+    #[test]
+    fn test_110() {
+        assert_eq!(ge_si32(-1713183800, 1), false);
+        assert_eq!(ge_si32(-1713183800, 2), false);
+        assert_eq!(ge_si32(-1713183800, 3), false);
+        assert_eq!(ge_si32(-1713183800, 4), false);
+        assert_eq!(ge_si32(-1713183800, 2147483646), false);
+        assert_eq!(ge_si32(-1713183800, 2147483647), false);
+        assert_eq!(ge_si32(-1252582164, -1035405763), false);
+        assert_eq!(ge_si32(-1252582164, 0), false);
+        assert_eq!(ge_si32(-1252582164, 1), false);
+        assert_eq!(ge_si32(-1252582164, 2), false);
+    }
+    #[test]
+    fn test_111() {
+        assert_eq!(ge_si32(-1252582164, 3), false);
+        assert_eq!(ge_si32(-1252582164, 4), false);
+        assert_eq!(ge_si32(-1252582164, 2147483646), false);
+        assert_eq!(ge_si32(-1252582164, 2147483647), false);
+        assert_eq!(ge_si32(-1035405763, 0), false);
+        assert_eq!(ge_si32(-1035405763, 1), false);
+        assert_eq!(ge_si32(-1035405763, 2), false);
+        assert_eq!(ge_si32(-1035405763, 3), false);
+        assert_eq!(ge_si32(-1035405763, 4), false);
+        assert_eq!(ge_si32(-1035405763, 2147483646), false);
+    }
+    #[test]
+    fn test_112() {
+        assert_eq!(ge_si32(-1035405763, 2147483647), false);
+        assert_eq!(ge_si32(0, 1), false);
+        assert_eq!(ge_si32(0, 2), false);
+        assert_eq!(ge_si32(0, 3), false);
+        assert_eq!(ge_si32(0, 4), false);
+        assert_eq!(ge_si32(0, 2147483646), false);
+        assert_eq!(ge_si32(0, 2147483647), false);
+        assert_eq!(ge_si32(1, 2), false);
+        assert_eq!(ge_si32(1, 3), false);
+        assert_eq!(ge_si32(1, 4), false);
+    }
+    #[test]
+    fn test_113() {
+        assert_eq!(ge_si32(1, 2147483646), false);
+        assert_eq!(ge_si32(1, 2147483647), false);
+        assert_eq!(ge_si32(2, 3), false);
+        assert_eq!(ge_si32(2, 4), false);
+        assert_eq!(ge_si32(2, 2147483646), false);
+        assert_eq!(ge_si32(2, 2147483647), false);
+        assert_eq!(ge_si32(3, 4), false);
+        assert_eq!(ge_si32(3, 2147483646), false);
+        assert_eq!(ge_si32(3, 2147483647), false);
+        assert_eq!(ge_si32(4, 2147483646), false);
+    }
+    #[test]
+    fn test_114() {
+        assert_eq!(ge_si32(4, 2147483647), false);
+        assert_eq!(ge_si32(2147483646, 2147483647), false);
+        assert_eq!(ge_si32(-2147483648, -2147483648), true);
+        assert_eq!(ge_si32(-2147483647, -2147483648), true);
+        assert_eq!(ge_si32(-2147483647, -2147483647), true);
+        assert_eq!(ge_si32(-1713183800, -2147483648), true);
+        assert_eq!(ge_si32(-1713183800, -2147483647), true);
+        assert_eq!(ge_si32(-1713183800, -1713183800), true);
+        assert_eq!(ge_si32(-1252582164, -2147483648), true);
+        assert_eq!(ge_si32(-1252582164, -2147483647), true);
+    }
+    #[test]
+    fn test_115() {
+        assert_eq!(ge_si32(-1252582164, -1713183800), true);
+        assert_eq!(ge_si32(-1252582164, -1252582164), true);
+        assert_eq!(ge_si32(-1035405763, -2147483648), true);
+        assert_eq!(ge_si32(-1035405763, -2147483647), true);
+        assert_eq!(ge_si32(-1035405763, -1713183800), true);
+        assert_eq!(ge_si32(-1035405763, -1252582164), true);
+        assert_eq!(ge_si32(-1035405763, -1035405763), true);
+        assert_eq!(ge_si32(0, -2147483648), true);
+        assert_eq!(ge_si32(0, -2147483647), true);
+        assert_eq!(ge_si32(0, -1713183800), true);
+    }
+    #[test]
+    fn test_116() {
+        assert_eq!(ge_si32(0, -1252582164), true);
+        assert_eq!(ge_si32(0, -1035405763), true);
+        assert_eq!(ge_si32(0, 0), true);
+        assert_eq!(ge_si32(1, -2147483648), true);
+        assert_eq!(ge_si32(1, -2147483647), true);
+        assert_eq!(ge_si32(1, -1713183800), true);
+        assert_eq!(ge_si32(1, -1252582164), true);
+        assert_eq!(ge_si32(1, -1035405763), true);
+        assert_eq!(ge_si32(1, 0), true);
+        assert_eq!(ge_si32(1, 1), true);
+    }
+    #[test]
+    fn test_117() {
+        assert_eq!(ge_si32(2, -2147483648), true);
+        assert_eq!(ge_si32(2, -2147483647), true);
+        assert_eq!(ge_si32(2, -1713183800), true);
+        assert_eq!(ge_si32(2, -1252582164), true);
+        assert_eq!(ge_si32(2, -1035405763), true);
+        assert_eq!(ge_si32(2, 0), true);
+        assert_eq!(ge_si32(2, 1), true);
+        assert_eq!(ge_si32(2, 2), true);
+        assert_eq!(ge_si32(3, -2147483648), true);
+        assert_eq!(ge_si32(3, -2147483647), true);
+    }
+    #[test]
+    fn test_118() {
+        assert_eq!(ge_si32(3, -1713183800), true);
+        assert_eq!(ge_si32(3, -1252582164), true);
+        assert_eq!(ge_si32(3, -1035405763), true);
+        assert_eq!(ge_si32(3, 0), true);
+        assert_eq!(ge_si32(3, 1), true);
+        assert_eq!(ge_si32(3, 2), true);
+        assert_eq!(ge_si32(3, 3), true);
+        assert_eq!(ge_si32(4, -2147483648), true);
+        assert_eq!(ge_si32(4, -2147483647), true);
+        assert_eq!(ge_si32(4, -1713183800), true);
+    }
+    #[test]
+    fn test_119() {
+        assert_eq!(ge_si32(4, -1252582164), true);
+        assert_eq!(ge_si32(4, -1035405763), true);
+        assert_eq!(ge_si32(4, 0), true);
+        assert_eq!(ge_si32(4, 1), true);
+        assert_eq!(ge_si32(4, 2), true);
+        assert_eq!(ge_si32(4, 3), true);
+        assert_eq!(ge_si32(4, 4), true);
+        assert_eq!(ge_si32(2147483646, -2147483648), true);
+        assert_eq!(ge_si32(2147483646, -2147483647), true);
+        assert_eq!(ge_si32(2147483646, -1713183800), true);
+    }
+    #[test]
+    fn test_120() {
+        assert_eq!(ge_si32(2147483646, -1252582164), true);
+        assert_eq!(ge_si32(2147483646, -1035405763), true);
+        assert_eq!(ge_si32(2147483646, 0), true);
+        assert_eq!(ge_si32(2147483646, 1), true);
+        assert_eq!(ge_si32(2147483646, 2), true);
+        assert_eq!(ge_si32(2147483646, 3), true);
+        assert_eq!(ge_si32(2147483646, 4), true);
+        assert_eq!(ge_si32(2147483646, 2147483646), true);
+        assert_eq!(ge_si32(2147483647, -2147483648), true);
+        assert_eq!(ge_si32(2147483647, -2147483647), true);
+    }
+    #[test]
+    fn test_121() {
+        assert_eq!(ge_si32(2147483647, -1713183800), true);
+        assert_eq!(ge_si32(2147483647, -1252582164), true);
+        assert_eq!(ge_si32(2147483647, -1035405763), true);
+        assert_eq!(ge_si32(2147483647, 0), true);
+        assert_eq!(ge_si32(2147483647, 1), true);
+        assert_eq!(ge_si32(2147483647, 2), true);
+        assert_eq!(ge_si32(2147483647, 3), true);
+        assert_eq!(ge_si32(2147483647, 4), true);
+        assert_eq!(ge_si32(2147483647, 2147483646), true);
+        assert_eq!(ge_si32(2147483647, 2147483647), true);
+    }
+    #[test]
+    fn test_122() {
+        assert_eq!(ge_si64(-9223372036854775808, -9223372036854775807), false);
+        assert_eq!(ge_si64(-9223372036854775808, -1741927215160008704), false);
+        assert_eq!(ge_si64(-9223372036854775808, -1328271339354574848), false);
+        assert_eq!(ge_si64(-9223372036854775808, 0), false);
+        assert_eq!(ge_si64(-9223372036854775808, 1), false);
+        assert_eq!(ge_si64(-9223372036854775808, 2), false);
+        assert_eq!(ge_si64(-9223372036854775808, 3), false);
+        assert_eq!(ge_si64(-9223372036854775808, 4), false);
+        assert_eq!(ge_si64(-9223372036854775808, 5577148965131116544), false);
+        assert_eq!(ge_si64(-9223372036854775808, 9223372036854775806), false);
+    }
+    #[test]
+    fn test_123() {
+        assert_eq!(ge_si64(-9223372036854775808, 9223372036854775807), false);
+        assert_eq!(ge_si64(-9223372036854775807, -1741927215160008704), false);
+        assert_eq!(ge_si64(-9223372036854775807, -1328271339354574848), false);
+        assert_eq!(ge_si64(-9223372036854775807, 0), false);
+        assert_eq!(ge_si64(-9223372036854775807, 1), false);
+        assert_eq!(ge_si64(-9223372036854775807, 2), false);
+        assert_eq!(ge_si64(-9223372036854775807, 3), false);
+        assert_eq!(ge_si64(-9223372036854775807, 4), false);
+        assert_eq!(ge_si64(-9223372036854775807, 5577148965131116544), false);
+        assert_eq!(ge_si64(-9223372036854775807, 9223372036854775806), false);
+    }
+    #[test]
+    fn test_124() {
+        assert_eq!(ge_si64(-9223372036854775807, 9223372036854775807), false);
+        assert_eq!(ge_si64(-1741927215160008704, -1328271339354574848), false);
+        assert_eq!(ge_si64(-1741927215160008704, 0), false);
+        assert_eq!(ge_si64(-1741927215160008704, 1), false);
+        assert_eq!(ge_si64(-1741927215160008704, 2), false);
+        assert_eq!(ge_si64(-1741927215160008704, 3), false);
+        assert_eq!(ge_si64(-1741927215160008704, 4), false);
+        assert_eq!(ge_si64(-1741927215160008704, 5577148965131116544), false);
+        assert_eq!(ge_si64(-1741927215160008704, 9223372036854775806), false);
+        assert_eq!(ge_si64(-1741927215160008704, 9223372036854775807), false);
+    }
+    #[test]
+    fn test_125() {
+        assert_eq!(ge_si64(-1328271339354574848, 0), false);
+        assert_eq!(ge_si64(-1328271339354574848, 1), false);
+        assert_eq!(ge_si64(-1328271339354574848, 2), false);
+        assert_eq!(ge_si64(-1328271339354574848, 3), false);
+        assert_eq!(ge_si64(-1328271339354574848, 4), false);
+        assert_eq!(ge_si64(-1328271339354574848, 5577148965131116544), false);
+        assert_eq!(ge_si64(-1328271339354574848, 9223372036854775806), false);
+        assert_eq!(ge_si64(-1328271339354574848, 9223372036854775807), false);
+        assert_eq!(ge_si64(0, 1), false);
+        assert_eq!(ge_si64(0, 2), false);
+    }
+    #[test]
+    fn test_126() {
+        assert_eq!(ge_si64(0, 3), false);
+        assert_eq!(ge_si64(0, 4), false);
+        assert_eq!(ge_si64(0, 5577148965131116544), false);
+        assert_eq!(ge_si64(0, 9223372036854775806), false);
+        assert_eq!(ge_si64(0, 9223372036854775807), false);
+        assert_eq!(ge_si64(1, 2), false);
+        assert_eq!(ge_si64(1, 3), false);
+        assert_eq!(ge_si64(1, 4), false);
+        assert_eq!(ge_si64(1, 5577148965131116544), false);
+        assert_eq!(ge_si64(1, 9223372036854775806), false);
+    }
+    #[test]
+    fn test_127() {
+        assert_eq!(ge_si64(1, 9223372036854775807), false);
+        assert_eq!(ge_si64(2, 3), false);
+        assert_eq!(ge_si64(2, 4), false);
+        assert_eq!(ge_si64(2, 5577148965131116544), false);
+        assert_eq!(ge_si64(2, 9223372036854775806), false);
+        assert_eq!(ge_si64(2, 9223372036854775807), false);
+        assert_eq!(ge_si64(3, 4), false);
+        assert_eq!(ge_si64(3, 5577148965131116544), false);
+        assert_eq!(ge_si64(3, 9223372036854775806), false);
+        assert_eq!(ge_si64(3, 9223372036854775807), false);
+    }
+    #[test]
+    fn test_128() {
+        assert_eq!(ge_si64(4, 5577148965131116544), false);
+        assert_eq!(ge_si64(4, 9223372036854775806), false);
+        assert_eq!(ge_si64(4, 9223372036854775807), false);
+        assert_eq!(ge_si64(5577148965131116544, 9223372036854775806), false);
+        assert_eq!(ge_si64(5577148965131116544, 9223372036854775807), false);
+        assert_eq!(ge_si64(9223372036854775806, 9223372036854775807), false);
+        assert_eq!(ge_si64(-9223372036854775808, -9223372036854775808), true);
+        assert_eq!(ge_si64(-9223372036854775807, -9223372036854775808), true);
+        assert_eq!(ge_si64(-9223372036854775807, -9223372036854775807), true);
+        assert_eq!(ge_si64(-1741927215160008704, -9223372036854775808), true);
+    }
+    #[test]
+    fn test_129() {
+        assert_eq!(ge_si64(-1741927215160008704, -9223372036854775807), true);
+        assert_eq!(ge_si64(-1741927215160008704, -1741927215160008704), true);
+        assert_eq!(ge_si64(-1328271339354574848, -9223372036854775808), true);
+        assert_eq!(ge_si64(-1328271339354574848, -9223372036854775807), true);
+        assert_eq!(ge_si64(-1328271339354574848, -1741927215160008704), true);
+        assert_eq!(ge_si64(-1328271339354574848, -1328271339354574848), true);
+        assert_eq!(ge_si64(0, -9223372036854775808), true);
+        assert_eq!(ge_si64(0, -9223372036854775807), true);
+        assert_eq!(ge_si64(0, -1741927215160008704), true);
+        assert_eq!(ge_si64(0, -1328271339354574848), true);
+    }
+    #[test]
+    fn test_130() {
+        assert_eq!(ge_si64(0, 0), true);
+        assert_eq!(ge_si64(1, -9223372036854775808), true);
+        assert_eq!(ge_si64(1, -9223372036854775807), true);
+        assert_eq!(ge_si64(1, -1741927215160008704), true);
+        assert_eq!(ge_si64(1, -1328271339354574848), true);
+        assert_eq!(ge_si64(1, 0), true);
+        assert_eq!(ge_si64(1, 1), true);
+        assert_eq!(ge_si64(2, -9223372036854775808), true);
+        assert_eq!(ge_si64(2, -9223372036854775807), true);
+        assert_eq!(ge_si64(2, -1741927215160008704), true);
+    }
+    #[test]
+    fn test_131() {
+        assert_eq!(ge_si64(2, -1328271339354574848), true);
+        assert_eq!(ge_si64(2, 0), true);
+        assert_eq!(ge_si64(2, 1), true);
+        assert_eq!(ge_si64(2, 2), true);
+        assert_eq!(ge_si64(3, -9223372036854775808), true);
+        assert_eq!(ge_si64(3, -9223372036854775807), true);
+        assert_eq!(ge_si64(3, -1741927215160008704), true);
+        assert_eq!(ge_si64(3, -1328271339354574848), true);
+        assert_eq!(ge_si64(3, 0), true);
+        assert_eq!(ge_si64(3, 1), true);
+    }
+    #[test]
+    fn test_132() {
+        assert_eq!(ge_si64(3, 2), true);
+        assert_eq!(ge_si64(3, 3), true);
+        assert_eq!(ge_si64(4, -9223372036854775808), true);
+        assert_eq!(ge_si64(4, -9223372036854775807), true);
+        assert_eq!(ge_si64(4, -1741927215160008704), true);
+        assert_eq!(ge_si64(4, -1328271339354574848), true);
+        assert_eq!(ge_si64(4, 0), true);
+        assert_eq!(ge_si64(4, 1), true);
+        assert_eq!(ge_si64(4, 2), true);
+        assert_eq!(ge_si64(4, 3), true);
+    }
+    #[test]
+    fn test_133() {
+        assert_eq!(ge_si64(4, 4), true);
+        assert_eq!(ge_si64(5577148965131116544, -9223372036854775808), true);
+        assert_eq!(ge_si64(5577148965131116544, -9223372036854775807), true);
+        assert_eq!(ge_si64(5577148965131116544, -1741927215160008704), true);
+        assert_eq!(ge_si64(5577148965131116544, -1328271339354574848), true);
+        assert_eq!(ge_si64(5577148965131116544, 0), true);
+        assert_eq!(ge_si64(5577148965131116544, 1), true);
+        assert_eq!(ge_si64(5577148965131116544, 2), true);
+        assert_eq!(ge_si64(5577148965131116544, 3), true);
+        assert_eq!(ge_si64(5577148965131116544, 4), true);
+    }
+    #[test]
+    fn test_134() {
+        assert_eq!(ge_si64(5577148965131116544, 5577148965131116544), true);
+        assert_eq!(ge_si64(9223372036854775806, -9223372036854775808), true);
+        assert_eq!(ge_si64(9223372036854775806, -9223372036854775807), true);
+        assert_eq!(ge_si64(9223372036854775806, -1741927215160008704), true);
+        assert_eq!(ge_si64(9223372036854775806, -1328271339354574848), true);
+        assert_eq!(ge_si64(9223372036854775806, 0), true);
+        assert_eq!(ge_si64(9223372036854775806, 1), true);
+        assert_eq!(ge_si64(9223372036854775806, 2), true);
+        assert_eq!(ge_si64(9223372036854775806, 3), true);
+        assert_eq!(ge_si64(9223372036854775806, 4), true);
+    }
+    #[test]
+    fn test_135() {
+        assert_eq!(ge_si64(9223372036854775806, 5577148965131116544), true);
+        assert_eq!(ge_si64(9223372036854775806, 9223372036854775806), true);
+        assert_eq!(ge_si64(9223372036854775807, -9223372036854775808), true);
+        assert_eq!(ge_si64(9223372036854775807, -9223372036854775807), true);
+        assert_eq!(ge_si64(9223372036854775807, -1741927215160008704), true);
+        assert_eq!(ge_si64(9223372036854775807, -1328271339354574848), true);
+        assert_eq!(ge_si64(9223372036854775807, 0), true);
+        assert_eq!(ge_si64(9223372036854775807, 1), true);
+        assert_eq!(ge_si64(9223372036854775807, 2), true);
+        assert_eq!(ge_si64(9223372036854775807, 3), true);
+    }
+    #[test]
+    fn test_136() {
+        assert_eq!(ge_si64(9223372036854775807, 4), true);
+        assert_eq!(ge_si64(9223372036854775807, 5577148965131116544), true);
+        assert_eq!(ge_si64(9223372036854775807, 9223372036854775806), true);
+        assert_eq!(ge_si64(9223372036854775807, 9223372036854775807), true);
+        assert_eq!(ge_si8(-128, -127), false);
+        assert_eq!(ge_si8(-128, 0), false);
+        assert_eq!(ge_si8(-128, 1), false);
+        assert_eq!(ge_si8(-128, 2), false);
+        assert_eq!(ge_si8(-128, 3), false);
+        assert_eq!(ge_si8(-128, 4), false);
+    }
+    #[test]
+    fn test_137() {
+        assert_eq!(ge_si8(-128, 16), false);
+        assert_eq!(ge_si8(-128, 126), false);
+        assert_eq!(ge_si8(-128, 127), false);
+        assert_eq!(ge_si8(-127, 0), false);
+        assert_eq!(ge_si8(-127, 1), false);
+        assert_eq!(ge_si8(-127, 2), false);
+        assert_eq!(ge_si8(-127, 3), false);
+        assert_eq!(ge_si8(-127, 4), false);
+        assert_eq!(ge_si8(-127, 16), false);
+        assert_eq!(ge_si8(-127, 126), false);
+    }
+    #[test]
+    fn test_138() {
+        assert_eq!(ge_si8(-127, 127), false);
+        assert_eq!(ge_si8(0, 1), false);
+        assert_eq!(ge_si8(0, 2), false);
+        assert_eq!(ge_si8(0, 3), false);
+        assert_eq!(ge_si8(0, 4), false);
+        assert_eq!(ge_si8(0, 16), false);
+        assert_eq!(ge_si8(0, 126), false);
+        assert_eq!(ge_si8(0, 127), false);
+        assert_eq!(ge_si8(1, 2), false);
+        assert_eq!(ge_si8(1, 3), false);
+    }
+    #[test]
+    fn test_139() {
+        assert_eq!(ge_si8(1, 4), false);
+        assert_eq!(ge_si8(1, 16), false);
+        assert_eq!(ge_si8(1, 126), false);
+        assert_eq!(ge_si8(1, 127), false);
+        assert_eq!(ge_si8(2, 3), false);
+        assert_eq!(ge_si8(2, 4), false);
+        assert_eq!(ge_si8(2, 16), false);
+        assert_eq!(ge_si8(2, 126), false);
+        assert_eq!(ge_si8(2, 127), false);
+        assert_eq!(ge_si8(3, 4), false);
+    }
+    #[test]
+    fn test_140() {
+        assert_eq!(ge_si8(3, 16), false);
+        assert_eq!(ge_si8(3, 126), false);
+        assert_eq!(ge_si8(3, 127), false);
+        assert_eq!(ge_si8(4, 16), false);
+        assert_eq!(ge_si8(4, 126), false);
+        assert_eq!(ge_si8(4, 127), false);
+        assert_eq!(ge_si8(16, 126), false);
+        assert_eq!(ge_si8(16, 127), false);
+        assert_eq!(ge_si8(126, 127), false);
+        assert_eq!(ge_si8(-128, -128), true);
+    }
+    #[test]
+    fn test_141() {
+        assert_eq!(ge_si8(-127, -128), true);
+        assert_eq!(ge_si8(-127, -127), true);
+        assert_eq!(ge_si8(0, -128), true);
+        assert_eq!(ge_si8(0, -127), true);
+        assert_eq!(ge_si8(0, 0), true);
+        assert_eq!(ge_si8(1, -128), true);
+        assert_eq!(ge_si8(1, -127), true);
+        assert_eq!(ge_si8(1, 0), true);
+        assert_eq!(ge_si8(1, 1), true);
+        assert_eq!(ge_si8(2, -128), true);
+    }
+    #[test]
+    fn test_142() {
+        assert_eq!(ge_si8(2, -127), true);
+        assert_eq!(ge_si8(2, 0), true);
+        assert_eq!(ge_si8(2, 1), true);
+        assert_eq!(ge_si8(2, 2), true);
+        assert_eq!(ge_si8(3, -128), true);
+        assert_eq!(ge_si8(3, -127), true);
+        assert_eq!(ge_si8(3, 0), true);
+        assert_eq!(ge_si8(3, 1), true);
+        assert_eq!(ge_si8(3, 2), true);
+        assert_eq!(ge_si8(3, 3), true);
+    }
+    #[test]
+    fn test_143() {
+        assert_eq!(ge_si8(4, -128), true);
+        assert_eq!(ge_si8(4, -127), true);
+        assert_eq!(ge_si8(4, 0), true);
+        assert_eq!(ge_si8(4, 1), true);
+        assert_eq!(ge_si8(4, 2), true);
+        assert_eq!(ge_si8(4, 3), true);
+        assert_eq!(ge_si8(4, 4), true);
+        assert_eq!(ge_si8(16, -128), true);
+        assert_eq!(ge_si8(16, -127), true);
+        assert_eq!(ge_si8(16, 0), true);
+    }
+    #[test]
+    fn test_144() {
+        assert_eq!(ge_si8(16, 1), true);
+        assert_eq!(ge_si8(16, 2), true);
+        assert_eq!(ge_si8(16, 3), true);
+        assert_eq!(ge_si8(16, 4), true);
+        assert_eq!(ge_si8(16, 16), true);
+        assert_eq!(ge_si8(126, -128), true);
+        assert_eq!(ge_si8(126, -127), true);
+        assert_eq!(ge_si8(126, 0), true);
+        assert_eq!(ge_si8(126, 1), true);
+        assert_eq!(ge_si8(126, 2), true);
+    }
+    #[test]
+    fn test_145() {
+        assert_eq!(ge_si8(126, 3), true);
+        assert_eq!(ge_si8(126, 4), true);
+        assert_eq!(ge_si8(126, 16), true);
+        assert_eq!(ge_si8(126, 126), true);
+        assert_eq!(ge_si8(127, -128), true);
+        assert_eq!(ge_si8(127, -127), true);
+        assert_eq!(ge_si8(127, 0), true);
+        assert_eq!(ge_si8(127, 1), true);
+        assert_eq!(ge_si8(127, 2), true);
+        assert_eq!(ge_si8(127, 3), true);
+    }
+    #[test]
+    fn test_146() {
+        assert_eq!(ge_si8(127, 4), true);
+        assert_eq!(ge_si8(127, 16), true);
+        assert_eq!(ge_si8(127, 126), true);
+        assert_eq!(ge_si8(127, 127), true);
+        assert_eq!(ge_ui16(0, 1), false);
+        assert_eq!(ge_ui16(0, 2), false);
+        assert_eq!(ge_ui16(0, 3), false);
+        assert_eq!(ge_ui16(0, 4), false);
+        assert_eq!(ge_ui16(0, 1717), false);
+        assert_eq!(ge_ui16(0, 17988), false);
+    }
+    #[test]
+    fn test_147() {
+        assert_eq!(ge_ui16(0, 65096), false);
+        assert_eq!(ge_ui16(0, 65534), false);
+        assert_eq!(ge_ui16(0, 65535), false);
+        assert_eq!(ge_ui16(1, 2), false);
+        assert_eq!(ge_ui16(1, 3), false);
+        assert_eq!(ge_ui16(1, 4), false);
+        assert_eq!(ge_ui16(1, 1717), false);
+        assert_eq!(ge_ui16(1, 17988), false);
+        assert_eq!(ge_ui16(1, 65096), false);
+        assert_eq!(ge_ui16(1, 65534), false);
+    }
+    #[test]
+    fn test_148() {
+        assert_eq!(ge_ui16(1, 65535), false);
+        assert_eq!(ge_ui16(2, 3), false);
+        assert_eq!(ge_ui16(2, 4), false);
+        assert_eq!(ge_ui16(2, 1717), false);
+        assert_eq!(ge_ui16(2, 17988), false);
+        assert_eq!(ge_ui16(2, 65096), false);
+        assert_eq!(ge_ui16(2, 65534), false);
+        assert_eq!(ge_ui16(2, 65535), false);
+        assert_eq!(ge_ui16(3, 4), false);
+        assert_eq!(ge_ui16(3, 1717), false);
+    }
+    #[test]
+    fn test_149() {
+        assert_eq!(ge_ui16(3, 17988), false);
+        assert_eq!(ge_ui16(3, 65096), false);
+        assert_eq!(ge_ui16(3, 65534), false);
+        assert_eq!(ge_ui16(3, 65535), false);
+        assert_eq!(ge_ui16(4, 1717), false);
+        assert_eq!(ge_ui16(4, 17988), false);
+        assert_eq!(ge_ui16(4, 65096), false);
+        assert_eq!(ge_ui16(4, 65534), false);
+        assert_eq!(ge_ui16(4, 65535), false);
+        assert_eq!(ge_ui16(1717, 17988), false);
+    }
+    #[test]
+    fn test_150() {
+        assert_eq!(ge_ui16(1717, 65096), false);
+        assert_eq!(ge_ui16(1717, 65534), false);
+        assert_eq!(ge_ui16(1717, 65535), false);
+        assert_eq!(ge_ui16(17988, 65096), false);
+        assert_eq!(ge_ui16(17988, 65534), false);
+        assert_eq!(ge_ui16(17988, 65535), false);
+        assert_eq!(ge_ui16(65096, 65534), false);
+        assert_eq!(ge_ui16(65096, 65535), false);
+        assert_eq!(ge_ui16(65534, 65535), false);
+        assert_eq!(ge_ui16(0, 0), true);
+    }
+    #[test]
+    fn test_151() {
+        assert_eq!(ge_ui16(1, 0), true);
+        assert_eq!(ge_ui16(1, 1), true);
+        assert_eq!(ge_ui16(2, 0), true);
+        assert_eq!(ge_ui16(2, 1), true);
+        assert_eq!(ge_ui16(2, 2), true);
+        assert_eq!(ge_ui16(3, 0), true);
+        assert_eq!(ge_ui16(3, 1), true);
+        assert_eq!(ge_ui16(3, 2), true);
+        assert_eq!(ge_ui16(3, 3), true);
+        assert_eq!(ge_ui16(4, 0), true);
+    }
+    #[test]
+    fn test_152() {
+        assert_eq!(ge_ui16(4, 1), true);
+        assert_eq!(ge_ui16(4, 2), true);
+        assert_eq!(ge_ui16(4, 3), true);
+        assert_eq!(ge_ui16(4, 4), true);
+        assert_eq!(ge_ui16(1717, 0), true);
+        assert_eq!(ge_ui16(1717, 1), true);
+        assert_eq!(ge_ui16(1717, 2), true);
+        assert_eq!(ge_ui16(1717, 3), true);
+        assert_eq!(ge_ui16(1717, 4), true);
+        assert_eq!(ge_ui16(1717, 1717), true);
+    }
+    #[test]
+    fn test_153() {
+        assert_eq!(ge_ui16(17988, 0), true);
+        assert_eq!(ge_ui16(17988, 1), true);
+        assert_eq!(ge_ui16(17988, 2), true);
+        assert_eq!(ge_ui16(17988, 3), true);
+        assert_eq!(ge_ui16(17988, 4), true);
+        assert_eq!(ge_ui16(17988, 1717), true);
+        assert_eq!(ge_ui16(17988, 17988), true);
+        assert_eq!(ge_ui16(65096, 0), true);
+        assert_eq!(ge_ui16(65096, 1), true);
+        assert_eq!(ge_ui16(65096, 2), true);
+    }
+    #[test]
+    fn test_154() {
+        assert_eq!(ge_ui16(65096, 3), true);
+        assert_eq!(ge_ui16(65096, 4), true);
+        assert_eq!(ge_ui16(65096, 1717), true);
+        assert_eq!(ge_ui16(65096, 17988), true);
+        assert_eq!(ge_ui16(65096, 65096), true);
+        assert_eq!(ge_ui16(65534, 0), true);
+        assert_eq!(ge_ui16(65534, 1), true);
+        assert_eq!(ge_ui16(65534, 2), true);
+        assert_eq!(ge_ui16(65534, 3), true);
+        assert_eq!(ge_ui16(65534, 4), true);
+    }
+    #[test]
+    fn test_155() {
+        assert_eq!(ge_ui16(65534, 1717), true);
+        assert_eq!(ge_ui16(65534, 17988), true);
+        assert_eq!(ge_ui16(65534, 65096), true);
+        assert_eq!(ge_ui16(65534, 65534), true);
+        assert_eq!(ge_ui16(65535, 0), true);
+        assert_eq!(ge_ui16(65535, 1), true);
+        assert_eq!(ge_ui16(65535, 2), true);
+        assert_eq!(ge_ui16(65535, 3), true);
+        assert_eq!(ge_ui16(65535, 4), true);
+        assert_eq!(ge_ui16(65535, 1717), true);
+    }
+    #[test]
+    fn test_156() {
+        assert_eq!(ge_ui16(65535, 17988), true);
+        assert_eq!(ge_ui16(65535, 65096), true);
+        assert_eq!(ge_ui16(65535, 65534), true);
+        assert_eq!(ge_ui16(65535, 65535), true);
+        assert_eq!(ge_ui32(0, 1), false);
+        assert_eq!(ge_ui32(0, 2), false);
+        assert_eq!(ge_ui32(0, 3), false);
+        assert_eq!(ge_ui32(0, 4), false);
+        assert_eq!(ge_ui32(0, 2119154652), false);
+        assert_eq!(ge_ui32(0, 3002788344), false);
+    }
+    #[test]
+    fn test_157() {
+        assert_eq!(ge_ui32(0, 3482297128), false);
+        assert_eq!(ge_ui32(0, 4294967294), false);
+        assert_eq!(ge_ui32(0, 4294967295), false);
+        assert_eq!(ge_ui32(1, 2), false);
+        assert_eq!(ge_ui32(1, 3), false);
+        assert_eq!(ge_ui32(1, 4), false);
+        assert_eq!(ge_ui32(1, 2119154652), false);
+        assert_eq!(ge_ui32(1, 3002788344), false);
+        assert_eq!(ge_ui32(1, 3482297128), false);
+        assert_eq!(ge_ui32(1, 4294967294), false);
+    }
+    #[test]
+    fn test_158() {
+        assert_eq!(ge_ui32(1, 4294967295), false);
+        assert_eq!(ge_ui32(2, 3), false);
+        assert_eq!(ge_ui32(2, 4), false);
+        assert_eq!(ge_ui32(2, 2119154652), false);
+        assert_eq!(ge_ui32(2, 3002788344), false);
+        assert_eq!(ge_ui32(2, 3482297128), false);
+        assert_eq!(ge_ui32(2, 4294967294), false);
+        assert_eq!(ge_ui32(2, 4294967295), false);
+        assert_eq!(ge_ui32(3, 4), false);
+        assert_eq!(ge_ui32(3, 2119154652), false);
+    }
+    #[test]
+    fn test_159() {
+        assert_eq!(ge_ui32(3, 3002788344), false);
+        assert_eq!(ge_ui32(3, 3482297128), false);
+        assert_eq!(ge_ui32(3, 4294967294), false);
+        assert_eq!(ge_ui32(3, 4294967295), false);
+        assert_eq!(ge_ui32(4, 2119154652), false);
+        assert_eq!(ge_ui32(4, 3002788344), false);
+        assert_eq!(ge_ui32(4, 3482297128), false);
+        assert_eq!(ge_ui32(4, 4294967294), false);
+        assert_eq!(ge_ui32(4, 4294967295), false);
+        assert_eq!(ge_ui32(2119154652, 3002788344), false);
+    }
+    #[test]
+    fn test_160() {
+        assert_eq!(ge_ui32(2119154652, 3482297128), false);
+        assert_eq!(ge_ui32(2119154652, 4294967294), false);
+        assert_eq!(ge_ui32(2119154652, 4294967295), false);
+        assert_eq!(ge_ui32(3002788344, 3482297128), false);
+        assert_eq!(ge_ui32(3002788344, 4294967294), false);
+        assert_eq!(ge_ui32(3002788344, 4294967295), false);
+        assert_eq!(ge_ui32(3482297128, 4294967294), false);
+        assert_eq!(ge_ui32(3482297128, 4294967295), false);
+        assert_eq!(ge_ui32(4294967294, 4294967295), false);
+        assert_eq!(ge_ui32(0, 0), true);
+    }
+    #[test]
+    fn test_161() {
+        assert_eq!(ge_ui32(1, 0), true);
+        assert_eq!(ge_ui32(1, 1), true);
+        assert_eq!(ge_ui32(2, 0), true);
+        assert_eq!(ge_ui32(2, 1), true);
+        assert_eq!(ge_ui32(2, 2), true);
+        assert_eq!(ge_ui32(3, 0), true);
+        assert_eq!(ge_ui32(3, 1), true);
+        assert_eq!(ge_ui32(3, 2), true);
+        assert_eq!(ge_ui32(3, 3), true);
+        assert_eq!(ge_ui32(4, 0), true);
+    }
+    #[test]
+    fn test_162() {
+        assert_eq!(ge_ui32(4, 1), true);
+        assert_eq!(ge_ui32(4, 2), true);
+        assert_eq!(ge_ui32(4, 3), true);
+        assert_eq!(ge_ui32(4, 4), true);
+        assert_eq!(ge_ui32(2119154652, 0), true);
+        assert_eq!(ge_ui32(2119154652, 1), true);
+        assert_eq!(ge_ui32(2119154652, 2), true);
+        assert_eq!(ge_ui32(2119154652, 3), true);
+        assert_eq!(ge_ui32(2119154652, 4), true);
+        assert_eq!(ge_ui32(2119154652, 2119154652), true);
+    }
+    #[test]
+    fn test_163() {
+        assert_eq!(ge_ui32(3002788344, 0), true);
+        assert_eq!(ge_ui32(3002788344, 1), true);
+        assert_eq!(ge_ui32(3002788344, 2), true);
+        assert_eq!(ge_ui32(3002788344, 3), true);
+        assert_eq!(ge_ui32(3002788344, 4), true);
+        assert_eq!(ge_ui32(3002788344, 2119154652), true);
+        assert_eq!(ge_ui32(3002788344, 3002788344), true);
+        assert_eq!(ge_ui32(3482297128, 0), true);
+        assert_eq!(ge_ui32(3482297128, 1), true);
+        assert_eq!(ge_ui32(3482297128, 2), true);
+    }
+    #[test]
+    fn test_164() {
+        assert_eq!(ge_ui32(3482297128, 3), true);
+        assert_eq!(ge_ui32(3482297128, 4), true);
+        assert_eq!(ge_ui32(3482297128, 2119154652), true);
+        assert_eq!(ge_ui32(3482297128, 3002788344), true);
+        assert_eq!(ge_ui32(3482297128, 3482297128), true);
+        assert_eq!(ge_ui32(4294967294, 0), true);
+        assert_eq!(ge_ui32(4294967294, 1), true);
+        assert_eq!(ge_ui32(4294967294, 2), true);
+        assert_eq!(ge_ui32(4294967294, 3), true);
+        assert_eq!(ge_ui32(4294967294, 4), true);
+    }
+    #[test]
+    fn test_165() {
+        assert_eq!(ge_ui32(4294967294, 2119154652), true);
+        assert_eq!(ge_ui32(4294967294, 3002788344), true);
+        assert_eq!(ge_ui32(4294967294, 3482297128), true);
+        assert_eq!(ge_ui32(4294967294, 4294967294), true);
+        assert_eq!(ge_ui32(4294967295, 0), true);
+        assert_eq!(ge_ui32(4294967295, 1), true);
+        assert_eq!(ge_ui32(4294967295, 2), true);
+        assert_eq!(ge_ui32(4294967295, 3), true);
+        assert_eq!(ge_ui32(4294967295, 4), true);
+        assert_eq!(ge_ui32(4294967295, 2119154652), true);
+    }
+    #[test]
+    fn test_166() {
+        assert_eq!(ge_ui32(4294967295, 3002788344), true);
+        assert_eq!(ge_ui32(4294967295, 3482297128), true);
+        assert_eq!(ge_ui32(4294967295, 4294967294), true);
+        assert_eq!(ge_ui32(4294967295, 4294967295), true);
+        assert_eq!(ge_ui64(0, 1), false);
+        assert_eq!(ge_ui64(0, 2), false);
+        assert_eq!(ge_ui64(0, 3), false);
+        assert_eq!(ge_ui64(0, 4), false);
+        assert_eq!(ge_ui64(0, 191084152064409600), false);
+        assert_eq!(ge_ui64(0, 11015955194427482112), false);
+    }
+    #[test]
+    fn test_167() {
+        assert_eq!(ge_ui64(0, 16990600415051759616), false);
+        assert_eq!(ge_ui64(0, 18446744073709551614), false);
+        assert_eq!(ge_ui64(0, 18446744073709551615), false);
+        assert_eq!(ge_ui64(1, 2), false);
+        assert_eq!(ge_ui64(1, 3), false);
+        assert_eq!(ge_ui64(1, 4), false);
+        assert_eq!(ge_ui64(1, 191084152064409600), false);
+        assert_eq!(ge_ui64(1, 11015955194427482112), false);
+        assert_eq!(ge_ui64(1, 16990600415051759616), false);
+        assert_eq!(ge_ui64(1, 18446744073709551614), false);
+    }
+    #[test]
+    fn test_168() {
+        assert_eq!(ge_ui64(1, 18446744073709551615), false);
+        assert_eq!(ge_ui64(2, 3), false);
+        assert_eq!(ge_ui64(2, 4), false);
+        assert_eq!(ge_ui64(2, 191084152064409600), false);
+        assert_eq!(ge_ui64(2, 11015955194427482112), false);
+        assert_eq!(ge_ui64(2, 16990600415051759616), false);
+        assert_eq!(ge_ui64(2, 18446744073709551614), false);
+        assert_eq!(ge_ui64(2, 18446744073709551615), false);
+        assert_eq!(ge_ui64(3, 4), false);
+        assert_eq!(ge_ui64(3, 191084152064409600), false);
+    }
+    #[test]
+    fn test_169() {
+        assert_eq!(ge_ui64(3, 11015955194427482112), false);
+        assert_eq!(ge_ui64(3, 16990600415051759616), false);
+        assert_eq!(ge_ui64(3, 18446744073709551614), false);
+        assert_eq!(ge_ui64(3, 18446744073709551615), false);
+        assert_eq!(ge_ui64(4, 191084152064409600), false);
+        assert_eq!(ge_ui64(4, 11015955194427482112), false);
+        assert_eq!(ge_ui64(4, 16990600415051759616), false);
+        assert_eq!(ge_ui64(4, 18446744073709551614), false);
+        assert_eq!(ge_ui64(4, 18446744073709551615), false);
+        assert_eq!(ge_ui64(191084152064409600, 11015955194427482112), false);
+    }
+    #[test]
+    fn test_170() {
+        assert_eq!(ge_ui64(191084152064409600, 16990600415051759616), false);
+        assert_eq!(ge_ui64(191084152064409600, 18446744073709551614), false);
+        assert_eq!(ge_ui64(191084152064409600, 18446744073709551615), false);
+        assert_eq!(ge_ui64(11015955194427482112, 16990600415051759616), false);
+        assert_eq!(ge_ui64(11015955194427482112, 18446744073709551614), false);
+        assert_eq!(ge_ui64(11015955194427482112, 18446744073709551615), false);
+        assert_eq!(ge_ui64(16990600415051759616, 18446744073709551614), false);
+        assert_eq!(ge_ui64(16990600415051759616, 18446744073709551615), false);
+        assert_eq!(ge_ui64(18446744073709551614, 18446744073709551615), false);
+        assert_eq!(ge_ui64(0, 0), true);
+    }
+    #[test]
+    fn test_171() {
+        assert_eq!(ge_ui64(1, 0), true);
+        assert_eq!(ge_ui64(1, 1), true);
+        assert_eq!(ge_ui64(2, 0), true);
+        assert_eq!(ge_ui64(2, 1), true);
+        assert_eq!(ge_ui64(2, 2), true);
+        assert_eq!(ge_ui64(3, 0), true);
+        assert_eq!(ge_ui64(3, 1), true);
+        assert_eq!(ge_ui64(3, 2), true);
+        assert_eq!(ge_ui64(3, 3), true);
+        assert_eq!(ge_ui64(4, 0), true);
+    }
+    #[test]
+    fn test_172() {
+        assert_eq!(ge_ui64(4, 1), true);
+        assert_eq!(ge_ui64(4, 2), true);
+        assert_eq!(ge_ui64(4, 3), true);
+        assert_eq!(ge_ui64(4, 4), true);
+        assert_eq!(ge_ui64(191084152064409600, 0), true);
+        assert_eq!(ge_ui64(191084152064409600, 1), true);
+        assert_eq!(ge_ui64(191084152064409600, 2), true);
+        assert_eq!(ge_ui64(191084152064409600, 3), true);
+        assert_eq!(ge_ui64(191084152064409600, 4), true);
+        assert_eq!(ge_ui64(191084152064409600, 191084152064409600), true);
+    }
+    #[test]
+    fn test_173() {
+        assert_eq!(ge_ui64(11015955194427482112, 0), true);
+        assert_eq!(ge_ui64(11015955194427482112, 1), true);
+        assert_eq!(ge_ui64(11015955194427482112, 2), true);
+        assert_eq!(ge_ui64(11015955194427482112, 3), true);
+        assert_eq!(ge_ui64(11015955194427482112, 4), true);
+        assert_eq!(ge_ui64(11015955194427482112, 191084152064409600), true);
+        assert_eq!(ge_ui64(11015955194427482112, 11015955194427482112), true);
+        assert_eq!(ge_ui64(16990600415051759616, 0), true);
+        assert_eq!(ge_ui64(16990600415051759616, 1), true);
+        assert_eq!(ge_ui64(16990600415051759616, 2), true);
+    }
+    #[test]
+    fn test_174() {
+        assert_eq!(ge_ui64(16990600415051759616, 3), true);
+        assert_eq!(ge_ui64(16990600415051759616, 4), true);
+        assert_eq!(ge_ui64(16990600415051759616, 191084152064409600), true);
+        assert_eq!(ge_ui64(16990600415051759616, 11015955194427482112), true);
+        assert_eq!(ge_ui64(16990600415051759616, 16990600415051759616), true);
+        assert_eq!(ge_ui64(18446744073709551614, 0), true);
+        assert_eq!(ge_ui64(18446744073709551614, 1), true);
+        assert_eq!(ge_ui64(18446744073709551614, 2), true);
+        assert_eq!(ge_ui64(18446744073709551614, 3), true);
+        assert_eq!(ge_ui64(18446744073709551614, 4), true);
+    }
+    #[test]
+    fn test_175() {
+        assert_eq!(ge_ui64(18446744073709551614, 191084152064409600), true);
+        assert_eq!(ge_ui64(18446744073709551614, 11015955194427482112), true);
+        assert_eq!(ge_ui64(18446744073709551614, 16990600415051759616), true);
+        assert_eq!(ge_ui64(18446744073709551614, 18446744073709551614), true);
+        assert_eq!(ge_ui64(18446744073709551615, 0), true);
+        assert_eq!(ge_ui64(18446744073709551615, 1), true);
+        assert_eq!(ge_ui64(18446744073709551615, 2), true);
+        assert_eq!(ge_ui64(18446744073709551615, 3), true);
+        assert_eq!(ge_ui64(18446744073709551615, 4), true);
+        assert_eq!(ge_ui64(18446744073709551615, 191084152064409600), true);
+    }
+    #[test]
+    fn test_176() {
+        assert_eq!(ge_ui64(18446744073709551615, 11015955194427482112), true);
+        assert_eq!(ge_ui64(18446744073709551615, 16990600415051759616), true);
+        assert_eq!(ge_ui64(18446744073709551615, 18446744073709551614), true);
+        assert_eq!(ge_ui64(18446744073709551615, 18446744073709551615), true);
+        assert_eq!(ge_ui8(0, 1), false);
+        assert_eq!(ge_ui8(0, 2), false);
+        assert_eq!(ge_ui8(0, 3), false);
+        assert_eq!(ge_ui8(0, 4), false);
+        assert_eq!(ge_ui8(0, 72), false);
+        assert_eq!(ge_ui8(0, 100), false);
+    }
+    #[test]
+    fn test_177() {
+        assert_eq!(ge_ui8(0, 162), false);
+        assert_eq!(ge_ui8(0, 254), false);
+        assert_eq!(ge_ui8(0, 255), false);
+        assert_eq!(ge_ui8(1, 2), false);
+        assert_eq!(ge_ui8(1, 3), false);
+        assert_eq!(ge_ui8(1, 4), false);
+        assert_eq!(ge_ui8(1, 72), false);
+        assert_eq!(ge_ui8(1, 100), false);
+        assert_eq!(ge_ui8(1, 162), false);
+        assert_eq!(ge_ui8(1, 254), false);
+    }
+    #[test]
+    fn test_178() {
+        assert_eq!(ge_ui8(1, 255), false);
+        assert_eq!(ge_ui8(2, 3), false);
+        assert_eq!(ge_ui8(2, 4), false);
+        assert_eq!(ge_ui8(2, 72), false);
+        assert_eq!(ge_ui8(2, 100), false);
+        assert_eq!(ge_ui8(2, 162), false);
+        assert_eq!(ge_ui8(2, 254), false);
+        assert_eq!(ge_ui8(2, 255), false);
+        assert_eq!(ge_ui8(3, 4), false);
+        assert_eq!(ge_ui8(3, 72), false);
+    }
+    #[test]
+    fn test_179() {
+        assert_eq!(ge_ui8(3, 100), false);
+        assert_eq!(ge_ui8(3, 162), false);
+        assert_eq!(ge_ui8(3, 254), false);
+        assert_eq!(ge_ui8(3, 255), false);
+        assert_eq!(ge_ui8(4, 72), false);
+        assert_eq!(ge_ui8(4, 100), false);
+        assert_eq!(ge_ui8(4, 162), false);
+        assert_eq!(ge_ui8(4, 254), false);
+        assert_eq!(ge_ui8(4, 255), false);
+        assert_eq!(ge_ui8(72, 100), false);
+    }
+    #[test]
+    fn test_180() {
+        assert_eq!(ge_ui8(72, 162), false);
+        assert_eq!(ge_ui8(72, 254), false);
+        assert_eq!(ge_ui8(72, 255), false);
+        assert_eq!(ge_ui8(100, 162), false);
+        assert_eq!(ge_ui8(100, 254), false);
+        assert_eq!(ge_ui8(100, 255), false);
+        assert_eq!(ge_ui8(162, 254), false);
+        assert_eq!(ge_ui8(162, 255), false);
+        assert_eq!(ge_ui8(254, 255), false);
+        assert_eq!(ge_ui8(0, 0), true);
+    }
+    #[test]
+    fn test_181() {
+        assert_eq!(ge_ui8(1, 0), true);
+        assert_eq!(ge_ui8(1, 1), true);
+        assert_eq!(ge_ui8(2, 0), true);
+        assert_eq!(ge_ui8(2, 1), true);
+        assert_eq!(ge_ui8(2, 2), true);
+        assert_eq!(ge_ui8(3, 0), true);
+        assert_eq!(ge_ui8(3, 1), true);
+        assert_eq!(ge_ui8(3, 2), true);
+        assert_eq!(ge_ui8(3, 3), true);
+        assert_eq!(ge_ui8(4, 0), true);
+    }
+    #[test]
+    fn test_182() {
+        assert_eq!(ge_ui8(4, 1), true);
+        assert_eq!(ge_ui8(4, 2), true);
+        assert_eq!(ge_ui8(4, 3), true);
+        assert_eq!(ge_ui8(4, 4), true);
+        assert_eq!(ge_ui8(72, 0), true);
+        assert_eq!(ge_ui8(72, 1), true);
+        assert_eq!(ge_ui8(72, 2), true);
+        assert_eq!(ge_ui8(72, 3), true);
+        assert_eq!(ge_ui8(72, 4), true);
+        assert_eq!(ge_ui8(72, 72), true);
+    }
+    #[test]
+    fn test_183() {
+        assert_eq!(ge_ui8(100, 0), true);
+        assert_eq!(ge_ui8(100, 1), true);
+        assert_eq!(ge_ui8(100, 2), true);
+        assert_eq!(ge_ui8(100, 3), true);
+        assert_eq!(ge_ui8(100, 4), true);
+        assert_eq!(ge_ui8(100, 72), true);
+        assert_eq!(ge_ui8(100, 100), true);
+        assert_eq!(ge_ui8(162, 0), true);
+        assert_eq!(ge_ui8(162, 1), true);
+        assert_eq!(ge_ui8(162, 2), true);
+    }
+    #[test]
+    fn test_184() {
+        assert_eq!(ge_ui8(162, 3), true);
+        assert_eq!(ge_ui8(162, 4), true);
+        assert_eq!(ge_ui8(162, 72), true);
+        assert_eq!(ge_ui8(162, 100), true);
+        assert_eq!(ge_ui8(162, 162), true);
+        assert_eq!(ge_ui8(254, 0), true);
+        assert_eq!(ge_ui8(254, 1), true);
+        assert_eq!(ge_ui8(254, 2), true);
+        assert_eq!(ge_ui8(254, 3), true);
+        assert_eq!(ge_ui8(254, 4), true);
+    }
+    #[test]
+    fn test_185() {
+        assert_eq!(ge_ui8(254, 72), true);
+        assert_eq!(ge_ui8(254, 100), true);
+        assert_eq!(ge_ui8(254, 162), true);
+        assert_eq!(ge_ui8(254, 254), true);
+        assert_eq!(ge_ui8(255, 0), true);
+        assert_eq!(ge_ui8(255, 1), true);
+        assert_eq!(ge_ui8(255, 2), true);
+        assert_eq!(ge_ui8(255, 3), true);
+        assert_eq!(ge_ui8(255, 4), true);
+        assert_eq!(ge_ui8(255, 72), true);
+    }
+    #[test]
+    fn test_186() {
+        assert_eq!(ge_ui8(255, 100), true);
+        assert_eq!(ge_ui8(255, 162), true);
+        assert_eq!(ge_ui8(255, 254), true);
+        assert_eq!(ge_ui8(255, 255), true);
+        assert_eq!(gt_si16(-32768, -32768), false);
+        assert_eq!(gt_si16(-32768, -32767), false);
+        assert_eq!(gt_si16(-32768, -32547), false);
+        assert_eq!(gt_si16(-32768, 0), false);
+        assert_eq!(gt_si16(-32768, 1), false);
+        assert_eq!(gt_si16(-32768, 2), false);
+    }
+    #[test]
+    fn test_187() {
+        assert_eq!(gt_si16(-32768, 3), false);
+        assert_eq!(gt_si16(-32768, 4), false);
+        assert_eq!(gt_si16(-32768, 10486), false);
+        assert_eq!(gt_si16(-32768, 16514), false);
+        assert_eq!(gt_si16(-32768, 32766), false);
+        assert_eq!(gt_si16(-32768, 32767), false);
+        assert_eq!(gt_si16(-32767, -32767), false);
+        assert_eq!(gt_si16(-32767, -32547), false);
+        assert_eq!(gt_si16(-32767, 0), false);
+        assert_eq!(gt_si16(-32767, 1), false);
+    }
+    #[test]
+    fn test_188() {
+        assert_eq!(gt_si16(-32767, 2), false);
+        assert_eq!(gt_si16(-32767, 3), false);
+        assert_eq!(gt_si16(-32767, 4), false);
+        assert_eq!(gt_si16(-32767, 10486), false);
+        assert_eq!(gt_si16(-32767, 16514), false);
+        assert_eq!(gt_si16(-32767, 32766), false);
+        assert_eq!(gt_si16(-32767, 32767), false);
+        assert_eq!(gt_si16(-32547, -32547), false);
+        assert_eq!(gt_si16(-32547, 0), false);
+        assert_eq!(gt_si16(-32547, 1), false);
+    }
+    #[test]
+    fn test_189() {
+        assert_eq!(gt_si16(-32547, 2), false);
+        assert_eq!(gt_si16(-32547, 3), false);
+        assert_eq!(gt_si16(-32547, 4), false);
+        assert_eq!(gt_si16(-32547, 10486), false);
+        assert_eq!(gt_si16(-32547, 16514), false);
+        assert_eq!(gt_si16(-32547, 32766), false);
+        assert_eq!(gt_si16(-32547, 32767), false);
+        assert_eq!(gt_si16(0, 0), false);
+        assert_eq!(gt_si16(0, 1), false);
+        assert_eq!(gt_si16(0, 2), false);
+    }
+    #[test]
+    fn test_190() {
+        assert_eq!(gt_si16(0, 3), false);
+        assert_eq!(gt_si16(0, 4), false);
+        assert_eq!(gt_si16(0, 10486), false);
+        assert_eq!(gt_si16(0, 16514), false);
+        assert_eq!(gt_si16(0, 32766), false);
+        assert_eq!(gt_si16(0, 32767), false);
+        assert_eq!(gt_si16(1, 1), false);
+        assert_eq!(gt_si16(1, 2), false);
+        assert_eq!(gt_si16(1, 3), false);
+        assert_eq!(gt_si16(1, 4), false);
+    }
+    #[test]
+    fn test_191() {
+        assert_eq!(gt_si16(1, 10486), false);
+        assert_eq!(gt_si16(1, 16514), false);
+        assert_eq!(gt_si16(1, 32766), false);
+        assert_eq!(gt_si16(1, 32767), false);
+        assert_eq!(gt_si16(2, 2), false);
+        assert_eq!(gt_si16(2, 3), false);
+        assert_eq!(gt_si16(2, 4), false);
+        assert_eq!(gt_si16(2, 10486), false);
+        assert_eq!(gt_si16(2, 16514), false);
+        assert_eq!(gt_si16(2, 32766), false);
+    }
+    #[test]
+    fn test_192() {
+        assert_eq!(gt_si16(2, 32767), false);
+        assert_eq!(gt_si16(3, 3), false);
+        assert_eq!(gt_si16(3, 4), false);
+        assert_eq!(gt_si16(3, 10486), false);
+        assert_eq!(gt_si16(3, 16514), false);
+        assert_eq!(gt_si16(3, 32766), false);
+        assert_eq!(gt_si16(3, 32767), false);
+        assert_eq!(gt_si16(4, 4), false);
+        assert_eq!(gt_si16(4, 10486), false);
+        assert_eq!(gt_si16(4, 16514), false);
+    }
+    #[test]
+    fn test_193() {
+        assert_eq!(gt_si16(4, 32766), false);
+        assert_eq!(gt_si16(4, 32767), false);
+        assert_eq!(gt_si16(10486, 10486), false);
+        assert_eq!(gt_si16(10486, 16514), false);
+        assert_eq!(gt_si16(10486, 32766), false);
+        assert_eq!(gt_si16(10486, 32767), false);
+        assert_eq!(gt_si16(16514, 16514), false);
+        assert_eq!(gt_si16(16514, 32766), false);
+        assert_eq!(gt_si16(16514, 32767), false);
+        assert_eq!(gt_si16(32766, 32766), false);
+    }
+    #[test]
+    fn test_194() {
+        assert_eq!(gt_si16(32766, 32767), false);
+        assert_eq!(gt_si16(32767, 32767), false);
+        assert_eq!(gt_si16(-32767, -32768), true);
+        assert_eq!(gt_si16(-32547, -32768), true);
+        assert_eq!(gt_si16(-32547, -32767), true);
+        assert_eq!(gt_si16(0, -32768), true);
+        assert_eq!(gt_si16(0, -32767), true);
+        assert_eq!(gt_si16(0, -32547), true);
+        assert_eq!(gt_si16(1, -32768), true);
+        assert_eq!(gt_si16(1, -32767), true);
+    }
+    #[test]
+    fn test_195() {
+        assert_eq!(gt_si16(1, -32547), true);
+        assert_eq!(gt_si16(1, 0), true);
+        assert_eq!(gt_si16(2, -32768), true);
+        assert_eq!(gt_si16(2, -32767), true);
+        assert_eq!(gt_si16(2, -32547), true);
+        assert_eq!(gt_si16(2, 0), true);
+        assert_eq!(gt_si16(2, 1), true);
+        assert_eq!(gt_si16(3, -32768), true);
+        assert_eq!(gt_si16(3, -32767), true);
+        assert_eq!(gt_si16(3, -32547), true);
+    }
+    #[test]
+    fn test_196() {
+        assert_eq!(gt_si16(3, 0), true);
+        assert_eq!(gt_si16(3, 1), true);
+        assert_eq!(gt_si16(3, 2), true);
+        assert_eq!(gt_si16(4, -32768), true);
+        assert_eq!(gt_si16(4, -32767), true);
+        assert_eq!(gt_si16(4, -32547), true);
+        assert_eq!(gt_si16(4, 0), true);
+        assert_eq!(gt_si16(4, 1), true);
+        assert_eq!(gt_si16(4, 2), true);
+        assert_eq!(gt_si16(4, 3), true);
+    }
+    #[test]
+    fn test_197() {
+        assert_eq!(gt_si16(10486, -32768), true);
+        assert_eq!(gt_si16(10486, -32767), true);
+        assert_eq!(gt_si16(10486, -32547), true);
+        assert_eq!(gt_si16(10486, 0), true);
+        assert_eq!(gt_si16(10486, 1), true);
+        assert_eq!(gt_si16(10486, 2), true);
+        assert_eq!(gt_si16(10486, 3), true);
+        assert_eq!(gt_si16(10486, 4), true);
+        assert_eq!(gt_si16(16514, -32768), true);
+        assert_eq!(gt_si16(16514, -32767), true);
+    }
+    #[test]
+    fn test_198() {
+        assert_eq!(gt_si16(16514, -32547), true);
+        assert_eq!(gt_si16(16514, 0), true);
+        assert_eq!(gt_si16(16514, 1), true);
+        assert_eq!(gt_si16(16514, 2), true);
+        assert_eq!(gt_si16(16514, 3), true);
+        assert_eq!(gt_si16(16514, 4), true);
+        assert_eq!(gt_si16(16514, 10486), true);
+        assert_eq!(gt_si16(32766, -32768), true);
+        assert_eq!(gt_si16(32766, -32767), true);
+        assert_eq!(gt_si16(32766, -32547), true);
+    }
+    #[test]
+    fn test_199() {
+        assert_eq!(gt_si16(32766, 0), true);
+        assert_eq!(gt_si16(32766, 1), true);
+        assert_eq!(gt_si16(32766, 2), true);
+        assert_eq!(gt_si16(32766, 3), true);
+        assert_eq!(gt_si16(32766, 4), true);
+        assert_eq!(gt_si16(32766, 10486), true);
+        assert_eq!(gt_si16(32766, 16514), true);
+        assert_eq!(gt_si16(32767, -32768), true);
+        assert_eq!(gt_si16(32767, -32767), true);
+        assert_eq!(gt_si16(32767, -32547), true);
+    }
+    #[test]
+    fn test_200() {
+        assert_eq!(gt_si16(32767, 0), true);
+        assert_eq!(gt_si16(32767, 1), true);
+        assert_eq!(gt_si16(32767, 2), true);
+        assert_eq!(gt_si16(32767, 3), true);
+        assert_eq!(gt_si16(32767, 4), true);
+        assert_eq!(gt_si16(32767, 10486), true);
+        assert_eq!(gt_si16(32767, 16514), true);
+        assert_eq!(gt_si16(32767, 32766), true);
+        assert_eq!(gt_si32(-2147483648, -2147483648), false);
+        assert_eq!(gt_si32(-2147483648, -2147483647), false);
+    }
+    #[test]
+    fn test_201() {
+        assert_eq!(gt_si32(-2147483648, -1713183800), false);
+        assert_eq!(gt_si32(-2147483648, -1252582164), false);
+        assert_eq!(gt_si32(-2147483648, -1035405763), false);
+        assert_eq!(gt_si32(-2147483648, 0), false);
+        assert_eq!(gt_si32(-2147483648, 1), false);
+        assert_eq!(gt_si32(-2147483648, 2), false);
+        assert_eq!(gt_si32(-2147483648, 3), false);
+        assert_eq!(gt_si32(-2147483648, 4), false);
+        assert_eq!(gt_si32(-2147483648, 2147483646), false);
+        assert_eq!(gt_si32(-2147483648, 2147483647), false);
+    }
+    #[test]
+    fn test_202() {
+        assert_eq!(gt_si32(-2147483647, -2147483647), false);
+        assert_eq!(gt_si32(-2147483647, -1713183800), false);
+        assert_eq!(gt_si32(-2147483647, -1252582164), false);
+        assert_eq!(gt_si32(-2147483647, -1035405763), false);
+        assert_eq!(gt_si32(-2147483647, 0), false);
+        assert_eq!(gt_si32(-2147483647, 1), false);
+        assert_eq!(gt_si32(-2147483647, 2), false);
+        assert_eq!(gt_si32(-2147483647, 3), false);
+        assert_eq!(gt_si32(-2147483647, 4), false);
+        assert_eq!(gt_si32(-2147483647, 2147483646), false);
+    }
+    #[test]
+    fn test_203() {
+        assert_eq!(gt_si32(-2147483647, 2147483647), false);
+        assert_eq!(gt_si32(-1713183800, -1713183800), false);
+        assert_eq!(gt_si32(-1713183800, -1252582164), false);
+        assert_eq!(gt_si32(-1713183800, -1035405763), false);
+        assert_eq!(gt_si32(-1713183800, 0), false);
+        assert_eq!(gt_si32(-1713183800, 1), false);
+        assert_eq!(gt_si32(-1713183800, 2), false);
+        assert_eq!(gt_si32(-1713183800, 3), false);
+        assert_eq!(gt_si32(-1713183800, 4), false);
+        assert_eq!(gt_si32(-1713183800, 2147483646), false);
+    }
+    #[test]
+    fn test_204() {
+        assert_eq!(gt_si32(-1713183800, 2147483647), false);
+        assert_eq!(gt_si32(-1252582164, -1252582164), false);
+        assert_eq!(gt_si32(-1252582164, -1035405763), false);
+        assert_eq!(gt_si32(-1252582164, 0), false);
+        assert_eq!(gt_si32(-1252582164, 1), false);
+        assert_eq!(gt_si32(-1252582164, 2), false);
+        assert_eq!(gt_si32(-1252582164, 3), false);
+        assert_eq!(gt_si32(-1252582164, 4), false);
+        assert_eq!(gt_si32(-1252582164, 2147483646), false);
+        assert_eq!(gt_si32(-1252582164, 2147483647), false);
+    }
+    #[test]
+    fn test_205() {
+        assert_eq!(gt_si32(-1035405763, -1035405763), false);
+        assert_eq!(gt_si32(-1035405763, 0), false);
+        assert_eq!(gt_si32(-1035405763, 1), false);
+        assert_eq!(gt_si32(-1035405763, 2), false);
+        assert_eq!(gt_si32(-1035405763, 3), false);
+        assert_eq!(gt_si32(-1035405763, 4), false);
+        assert_eq!(gt_si32(-1035405763, 2147483646), false);
+        assert_eq!(gt_si32(-1035405763, 2147483647), false);
+        assert_eq!(gt_si32(0, 0), false);
+        assert_eq!(gt_si32(0, 1), false);
+    }
+    #[test]
+    fn test_206() {
+        assert_eq!(gt_si32(0, 2), false);
+        assert_eq!(gt_si32(0, 3), false);
+        assert_eq!(gt_si32(0, 4), false);
+        assert_eq!(gt_si32(0, 2147483646), false);
+        assert_eq!(gt_si32(0, 2147483647), false);
+        assert_eq!(gt_si32(1, 1), false);
+        assert_eq!(gt_si32(1, 2), false);
+        assert_eq!(gt_si32(1, 3), false);
+        assert_eq!(gt_si32(1, 4), false);
+        assert_eq!(gt_si32(1, 2147483646), false);
+    }
+    #[test]
+    fn test_207() {
+        assert_eq!(gt_si32(1, 2147483647), false);
+        assert_eq!(gt_si32(2, 2), false);
+        assert_eq!(gt_si32(2, 3), false);
+        assert_eq!(gt_si32(2, 4), false);
+        assert_eq!(gt_si32(2, 2147483646), false);
+        assert_eq!(gt_si32(2, 2147483647), false);
+        assert_eq!(gt_si32(3, 3), false);
+        assert_eq!(gt_si32(3, 4), false);
+        assert_eq!(gt_si32(3, 2147483646), false);
+        assert_eq!(gt_si32(3, 2147483647), false);
+    }
+    #[test]
+    fn test_208() {
+        assert_eq!(gt_si32(4, 4), false);
+        assert_eq!(gt_si32(4, 2147483646), false);
+        assert_eq!(gt_si32(4, 2147483647), false);
+        assert_eq!(gt_si32(2147483646, 2147483646), false);
+        assert_eq!(gt_si32(2147483646, 2147483647), false);
+        assert_eq!(gt_si32(2147483647, 2147483647), false);
+        assert_eq!(gt_si32(-2147483647, -2147483648), true);
+        assert_eq!(gt_si32(-1713183800, -2147483648), true);
+        assert_eq!(gt_si32(-1713183800, -2147483647), true);
+        assert_eq!(gt_si32(-1252582164, -2147483648), true);
+    }
+    #[test]
+    fn test_209() {
+        assert_eq!(gt_si32(-1252582164, -2147483647), true);
+        assert_eq!(gt_si32(-1252582164, -1713183800), true);
+        assert_eq!(gt_si32(-1035405763, -2147483648), true);
+        assert_eq!(gt_si32(-1035405763, -2147483647), true);
+        assert_eq!(gt_si32(-1035405763, -1713183800), true);
+        assert_eq!(gt_si32(-1035405763, -1252582164), true);
+        assert_eq!(gt_si32(0, -2147483648), true);
+        assert_eq!(gt_si32(0, -2147483647), true);
+        assert_eq!(gt_si32(0, -1713183800), true);
+        assert_eq!(gt_si32(0, -1252582164), true);
+    }
+    #[test]
+    fn test_210() {
+        assert_eq!(gt_si32(0, -1035405763), true);
+        assert_eq!(gt_si32(1, -2147483648), true);
+        assert_eq!(gt_si32(1, -2147483647), true);
+        assert_eq!(gt_si32(1, -1713183800), true);
+        assert_eq!(gt_si32(1, -1252582164), true);
+        assert_eq!(gt_si32(1, -1035405763), true);
+        assert_eq!(gt_si32(1, 0), true);
+        assert_eq!(gt_si32(2, -2147483648), true);
+        assert_eq!(gt_si32(2, -2147483647), true);
+        assert_eq!(gt_si32(2, -1713183800), true);
+    }
+    #[test]
+    fn test_211() {
+        assert_eq!(gt_si32(2, -1252582164), true);
+        assert_eq!(gt_si32(2, -1035405763), true);
+        assert_eq!(gt_si32(2, 0), true);
+        assert_eq!(gt_si32(2, 1), true);
+        assert_eq!(gt_si32(3, -2147483648), true);
+        assert_eq!(gt_si32(3, -2147483647), true);
+        assert_eq!(gt_si32(3, -1713183800), true);
+        assert_eq!(gt_si32(3, -1252582164), true);
+        assert_eq!(gt_si32(3, -1035405763), true);
+        assert_eq!(gt_si32(3, 0), true);
+    }
+    #[test]
+    fn test_212() {
+        assert_eq!(gt_si32(3, 1), true);
+        assert_eq!(gt_si32(3, 2), true);
+        assert_eq!(gt_si32(4, -2147483648), true);
+        assert_eq!(gt_si32(4, -2147483647), true);
+        assert_eq!(gt_si32(4, -1713183800), true);
+        assert_eq!(gt_si32(4, -1252582164), true);
+        assert_eq!(gt_si32(4, -1035405763), true);
+        assert_eq!(gt_si32(4, 0), true);
+        assert_eq!(gt_si32(4, 1), true);
+        assert_eq!(gt_si32(4, 2), true);
+    }
+    #[test]
+    fn test_213() {
+        assert_eq!(gt_si32(4, 3), true);
+        assert_eq!(gt_si32(2147483646, -2147483648), true);
+        assert_eq!(gt_si32(2147483646, -2147483647), true);
+        assert_eq!(gt_si32(2147483646, -1713183800), true);
+        assert_eq!(gt_si32(2147483646, -1252582164), true);
+        assert_eq!(gt_si32(2147483646, -1035405763), true);
+        assert_eq!(gt_si32(2147483646, 0), true);
+        assert_eq!(gt_si32(2147483646, 1), true);
+        assert_eq!(gt_si32(2147483646, 2), true);
+        assert_eq!(gt_si32(2147483646, 3), true);
+    }
+    #[test]
+    fn test_214() {
+        assert_eq!(gt_si32(2147483646, 4), true);
+        assert_eq!(gt_si32(2147483647, -2147483648), true);
+        assert_eq!(gt_si32(2147483647, -2147483647), true);
+        assert_eq!(gt_si32(2147483647, -1713183800), true);
+        assert_eq!(gt_si32(2147483647, -1252582164), true);
+        assert_eq!(gt_si32(2147483647, -1035405763), true);
+        assert_eq!(gt_si32(2147483647, 0), true);
+        assert_eq!(gt_si32(2147483647, 1), true);
+        assert_eq!(gt_si32(2147483647, 2), true);
+        assert_eq!(gt_si32(2147483647, 3), true);
+    }
+    #[test]
+    fn test_215() {
+        assert_eq!(gt_si32(2147483647, 4), true);
+        assert_eq!(gt_si32(2147483647, 2147483646), true);
+        assert_eq!(gt_si64(-9223372036854775808, -9223372036854775808), false);
+        assert_eq!(gt_si64(-9223372036854775808, -9223372036854775807), false);
+        assert_eq!(gt_si64(-9223372036854775808, -1741927215160008704), false);
+        assert_eq!(gt_si64(-9223372036854775808, -1328271339354574848), false);
+        assert_eq!(gt_si64(-9223372036854775808, 0), false);
+        assert_eq!(gt_si64(-9223372036854775808, 1), false);
+        assert_eq!(gt_si64(-9223372036854775808, 2), false);
+        assert_eq!(gt_si64(-9223372036854775808, 3), false);
+    }
+    #[test]
+    fn test_216() {
+        assert_eq!(gt_si64(-9223372036854775808, 4), false);
+        assert_eq!(gt_si64(-9223372036854775808, 5577148965131116544), false);
+        assert_eq!(gt_si64(-9223372036854775808, 9223372036854775806), false);
+        assert_eq!(gt_si64(-9223372036854775808, 9223372036854775807), false);
+        assert_eq!(gt_si64(-9223372036854775807, -9223372036854775807), false);
+        assert_eq!(gt_si64(-9223372036854775807, -1741927215160008704), false);
+        assert_eq!(gt_si64(-9223372036854775807, -1328271339354574848), false);
+        assert_eq!(gt_si64(-9223372036854775807, 0), false);
+        assert_eq!(gt_si64(-9223372036854775807, 1), false);
+        assert_eq!(gt_si64(-9223372036854775807, 2), false);
+    }
+    #[test]
+    fn test_217() {
+        assert_eq!(gt_si64(-9223372036854775807, 3), false);
+        assert_eq!(gt_si64(-9223372036854775807, 4), false);
+        assert_eq!(gt_si64(-9223372036854775807, 5577148965131116544), false);
+        assert_eq!(gt_si64(-9223372036854775807, 9223372036854775806), false);
+        assert_eq!(gt_si64(-9223372036854775807, 9223372036854775807), false);
+        assert_eq!(gt_si64(-1741927215160008704, -1741927215160008704), false);
+        assert_eq!(gt_si64(-1741927215160008704, -1328271339354574848), false);
+        assert_eq!(gt_si64(-1741927215160008704, 0), false);
+        assert_eq!(gt_si64(-1741927215160008704, 1), false);
+        assert_eq!(gt_si64(-1741927215160008704, 2), false);
+    }
+    #[test]
+    fn test_218() {
+        assert_eq!(gt_si64(-1741927215160008704, 3), false);
+        assert_eq!(gt_si64(-1741927215160008704, 4), false);
+        assert_eq!(gt_si64(-1741927215160008704, 5577148965131116544), false);
+        assert_eq!(gt_si64(-1741927215160008704, 9223372036854775806), false);
+        assert_eq!(gt_si64(-1741927215160008704, 9223372036854775807), false);
+        assert_eq!(gt_si64(-1328271339354574848, -1328271339354574848), false);
+        assert_eq!(gt_si64(-1328271339354574848, 0), false);
+        assert_eq!(gt_si64(-1328271339354574848, 1), false);
+        assert_eq!(gt_si64(-1328271339354574848, 2), false);
+        assert_eq!(gt_si64(-1328271339354574848, 3), false);
+    }
+    #[test]
+    fn test_219() {
+        assert_eq!(gt_si64(-1328271339354574848, 4), false);
+        assert_eq!(gt_si64(-1328271339354574848, 5577148965131116544), false);
+        assert_eq!(gt_si64(-1328271339354574848, 9223372036854775806), false);
+        assert_eq!(gt_si64(-1328271339354574848, 9223372036854775807), false);
+        assert_eq!(gt_si64(0, 0), false);
+        assert_eq!(gt_si64(0, 1), false);
+        assert_eq!(gt_si64(0, 2), false);
+        assert_eq!(gt_si64(0, 3), false);
+        assert_eq!(gt_si64(0, 4), false);
+        assert_eq!(gt_si64(0, 5577148965131116544), false);
+    }
+    #[test]
+    fn test_220() {
+        assert_eq!(gt_si64(0, 9223372036854775806), false);
+        assert_eq!(gt_si64(0, 9223372036854775807), false);
+        assert_eq!(gt_si64(1, 1), false);
+        assert_eq!(gt_si64(1, 2), false);
+        assert_eq!(gt_si64(1, 3), false);
+        assert_eq!(gt_si64(1, 4), false);
+        assert_eq!(gt_si64(1, 5577148965131116544), false);
+        assert_eq!(gt_si64(1, 9223372036854775806), false);
+        assert_eq!(gt_si64(1, 9223372036854775807), false);
+        assert_eq!(gt_si64(2, 2), false);
+    }
+    #[test]
+    fn test_221() {
+        assert_eq!(gt_si64(2, 3), false);
+        assert_eq!(gt_si64(2, 4), false);
+        assert_eq!(gt_si64(2, 5577148965131116544), false);
+        assert_eq!(gt_si64(2, 9223372036854775806), false);
+        assert_eq!(gt_si64(2, 9223372036854775807), false);
+        assert_eq!(gt_si64(3, 3), false);
+        assert_eq!(gt_si64(3, 4), false);
+        assert_eq!(gt_si64(3, 5577148965131116544), false);
+        assert_eq!(gt_si64(3, 9223372036854775806), false);
+        assert_eq!(gt_si64(3, 9223372036854775807), false);
+    }
+    #[test]
+    fn test_222() {
+        assert_eq!(gt_si64(4, 4), false);
+        assert_eq!(gt_si64(4, 5577148965131116544), false);
+        assert_eq!(gt_si64(4, 9223372036854775806), false);
+        assert_eq!(gt_si64(4, 9223372036854775807), false);
+        assert_eq!(gt_si64(5577148965131116544, 5577148965131116544), false);
+        assert_eq!(gt_si64(5577148965131116544, 9223372036854775806), false);
+        assert_eq!(gt_si64(5577148965131116544, 9223372036854775807), false);
+        assert_eq!(gt_si64(9223372036854775806, 9223372036854775806), false);
+        assert_eq!(gt_si64(9223372036854775806, 9223372036854775807), false);
+        assert_eq!(gt_si64(9223372036854775807, 9223372036854775807), false);
+    }
+    #[test]
+    fn test_223() {
+        assert_eq!(gt_si64(-9223372036854775807, -9223372036854775808), true);
+        assert_eq!(gt_si64(-1741927215160008704, -9223372036854775808), true);
+        assert_eq!(gt_si64(-1741927215160008704, -9223372036854775807), true);
+        assert_eq!(gt_si64(-1328271339354574848, -9223372036854775808), true);
+        assert_eq!(gt_si64(-1328271339354574848, -9223372036854775807), true);
+        assert_eq!(gt_si64(-1328271339354574848, -1741927215160008704), true);
+        assert_eq!(gt_si64(0, -9223372036854775808), true);
+        assert_eq!(gt_si64(0, -9223372036854775807), true);
+        assert_eq!(gt_si64(0, -1741927215160008704), true);
+        assert_eq!(gt_si64(0, -1328271339354574848), true);
+    }
+    #[test]
+    fn test_224() {
+        assert_eq!(gt_si64(1, -9223372036854775808), true);
+        assert_eq!(gt_si64(1, -9223372036854775807), true);
+        assert_eq!(gt_si64(1, -1741927215160008704), true);
+        assert_eq!(gt_si64(1, -1328271339354574848), true);
+        assert_eq!(gt_si64(1, 0), true);
+        assert_eq!(gt_si64(2, -9223372036854775808), true);
+        assert_eq!(gt_si64(2, -9223372036854775807), true);
+        assert_eq!(gt_si64(2, -1741927215160008704), true);
+        assert_eq!(gt_si64(2, -1328271339354574848), true);
+        assert_eq!(gt_si64(2, 0), true);
+    }
+    #[test]
+    fn test_225() {
+        assert_eq!(gt_si64(2, 1), true);
+        assert_eq!(gt_si64(3, -9223372036854775808), true);
+        assert_eq!(gt_si64(3, -9223372036854775807), true);
+        assert_eq!(gt_si64(3, -1741927215160008704), true);
+        assert_eq!(gt_si64(3, -1328271339354574848), true);
+        assert_eq!(gt_si64(3, 0), true);
+        assert_eq!(gt_si64(3, 1), true);
+        assert_eq!(gt_si64(3, 2), true);
+        assert_eq!(gt_si64(4, -9223372036854775808), true);
+        assert_eq!(gt_si64(4, -9223372036854775807), true);
+    }
+    #[test]
+    fn test_226() {
+        assert_eq!(gt_si64(4, -1741927215160008704), true);
+        assert_eq!(gt_si64(4, -1328271339354574848), true);
+        assert_eq!(gt_si64(4, 0), true);
+        assert_eq!(gt_si64(4, 1), true);
+        assert_eq!(gt_si64(4, 2), true);
+        assert_eq!(gt_si64(4, 3), true);
+        assert_eq!(gt_si64(5577148965131116544, -9223372036854775808), true);
+        assert_eq!(gt_si64(5577148965131116544, -9223372036854775807), true);
+        assert_eq!(gt_si64(5577148965131116544, -1741927215160008704), true);
+        assert_eq!(gt_si64(5577148965131116544, -1328271339354574848), true);
+    }
+    #[test]
+    fn test_227() {
+        assert_eq!(gt_si64(5577148965131116544, 0), true);
+        assert_eq!(gt_si64(5577148965131116544, 1), true);
+        assert_eq!(gt_si64(5577148965131116544, 2), true);
+        assert_eq!(gt_si64(5577148965131116544, 3), true);
+        assert_eq!(gt_si64(5577148965131116544, 4), true);
+        assert_eq!(gt_si64(9223372036854775806, -9223372036854775808), true);
+        assert_eq!(gt_si64(9223372036854775806, -9223372036854775807), true);
+        assert_eq!(gt_si64(9223372036854775806, -1741927215160008704), true);
+        assert_eq!(gt_si64(9223372036854775806, -1328271339354574848), true);
+        assert_eq!(gt_si64(9223372036854775806, 0), true);
+    }
+    #[test]
+    fn test_228() {
+        assert_eq!(gt_si64(9223372036854775806, 1), true);
+        assert_eq!(gt_si64(9223372036854775806, 2), true);
+        assert_eq!(gt_si64(9223372036854775806, 3), true);
+        assert_eq!(gt_si64(9223372036854775806, 4), true);
+        assert_eq!(gt_si64(9223372036854775806, 5577148965131116544), true);
+        assert_eq!(gt_si64(9223372036854775807, -9223372036854775808), true);
+        assert_eq!(gt_si64(9223372036854775807, -9223372036854775807), true);
+        assert_eq!(gt_si64(9223372036854775807, -1741927215160008704), true);
+        assert_eq!(gt_si64(9223372036854775807, -1328271339354574848), true);
+        assert_eq!(gt_si64(9223372036854775807, 0), true);
+    }
+    #[test]
+    fn test_229() {
+        assert_eq!(gt_si64(9223372036854775807, 1), true);
+        assert_eq!(gt_si64(9223372036854775807, 2), true);
+        assert_eq!(gt_si64(9223372036854775807, 3), true);
+        assert_eq!(gt_si64(9223372036854775807, 4), true);
+        assert_eq!(gt_si64(9223372036854775807, 5577148965131116544), true);
+        assert_eq!(gt_si64(9223372036854775807, 9223372036854775806), true);
+        assert_eq!(gt_si8(-128, -128), false);
+        assert_eq!(gt_si8(-128, -127), false);
+        assert_eq!(gt_si8(-128, 0), false);
+        assert_eq!(gt_si8(-128, 1), false);
+    }
+    #[test]
+    fn test_230() {
+        assert_eq!(gt_si8(-128, 2), false);
+        assert_eq!(gt_si8(-128, 3), false);
+        assert_eq!(gt_si8(-128, 4), false);
+        assert_eq!(gt_si8(-128, 16), false);
+        assert_eq!(gt_si8(-128, 126), false);
+        assert_eq!(gt_si8(-128, 127), false);
+        assert_eq!(gt_si8(-127, -127), false);
+        assert_eq!(gt_si8(-127, 0), false);
+        assert_eq!(gt_si8(-127, 1), false);
+        assert_eq!(gt_si8(-127, 2), false);
+    }
+    #[test]
+    fn test_231() {
+        assert_eq!(gt_si8(-127, 3), false);
+        assert_eq!(gt_si8(-127, 4), false);
+        assert_eq!(gt_si8(-127, 16), false);
+        assert_eq!(gt_si8(-127, 126), false);
+        assert_eq!(gt_si8(-127, 127), false);
+        assert_eq!(gt_si8(0, 0), false);
+        assert_eq!(gt_si8(0, 1), false);
+        assert_eq!(gt_si8(0, 2), false);
+        assert_eq!(gt_si8(0, 3), false);
+        assert_eq!(gt_si8(0, 4), false);
+    }
+    #[test]
+    fn test_232() {
+        assert_eq!(gt_si8(0, 16), false);
+        assert_eq!(gt_si8(0, 126), false);
+        assert_eq!(gt_si8(0, 127), false);
+        assert_eq!(gt_si8(1, 1), false);
+        assert_eq!(gt_si8(1, 2), false);
+        assert_eq!(gt_si8(1, 3), false);
+        assert_eq!(gt_si8(1, 4), false);
+        assert_eq!(gt_si8(1, 16), false);
+        assert_eq!(gt_si8(1, 126), false);
+        assert_eq!(gt_si8(1, 127), false);
+    }
+    #[test]
+    fn test_233() {
+        assert_eq!(gt_si8(2, 2), false);
+        assert_eq!(gt_si8(2, 3), false);
+        assert_eq!(gt_si8(2, 4), false);
+        assert_eq!(gt_si8(2, 16), false);
+        assert_eq!(gt_si8(2, 126), false);
+        assert_eq!(gt_si8(2, 127), false);
+        assert_eq!(gt_si8(3, 3), false);
+        assert_eq!(gt_si8(3, 4), false);
+        assert_eq!(gt_si8(3, 16), false);
+        assert_eq!(gt_si8(3, 126), false);
+    }
+    #[test]
+    fn test_234() {
+        assert_eq!(gt_si8(3, 127), false);
+        assert_eq!(gt_si8(4, 4), false);
+        assert_eq!(gt_si8(4, 16), false);
+        assert_eq!(gt_si8(4, 126), false);
+        assert_eq!(gt_si8(4, 127), false);
+        assert_eq!(gt_si8(16, 16), false);
+        assert_eq!(gt_si8(16, 126), false);
+        assert_eq!(gt_si8(16, 127), false);
+        assert_eq!(gt_si8(126, 126), false);
+        assert_eq!(gt_si8(126, 127), false);
+    }
+    #[test]
+    fn test_235() {
+        assert_eq!(gt_si8(127, 127), false);
+        assert_eq!(gt_si8(-127, -128), true);
+        assert_eq!(gt_si8(0, -128), true);
+        assert_eq!(gt_si8(0, -127), true);
+        assert_eq!(gt_si8(1, -128), true);
+        assert_eq!(gt_si8(1, -127), true);
+        assert_eq!(gt_si8(1, 0), true);
+        assert_eq!(gt_si8(2, -128), true);
+        assert_eq!(gt_si8(2, -127), true);
+        assert_eq!(gt_si8(2, 0), true);
+    }
+    #[test]
+    fn test_236() {
+        assert_eq!(gt_si8(2, 1), true);
+        assert_eq!(gt_si8(3, -128), true);
+        assert_eq!(gt_si8(3, -127), true);
+        assert_eq!(gt_si8(3, 0), true);
+        assert_eq!(gt_si8(3, 1), true);
+        assert_eq!(gt_si8(3, 2), true);
+        assert_eq!(gt_si8(4, -128), true);
+        assert_eq!(gt_si8(4, -127), true);
+        assert_eq!(gt_si8(4, 0), true);
+        assert_eq!(gt_si8(4, 1), true);
+    }
+    #[test]
+    fn test_237() {
+        assert_eq!(gt_si8(4, 2), true);
+        assert_eq!(gt_si8(4, 3), true);
+        assert_eq!(gt_si8(16, -128), true);
+        assert_eq!(gt_si8(16, -127), true);
+        assert_eq!(gt_si8(16, 0), true);
+        assert_eq!(gt_si8(16, 1), true);
+        assert_eq!(gt_si8(16, 2), true);
+        assert_eq!(gt_si8(16, 3), true);
+        assert_eq!(gt_si8(16, 4), true);
+        assert_eq!(gt_si8(126, -128), true);
+    }
+    #[test]
+    fn test_238() {
+        assert_eq!(gt_si8(126, -127), true);
+        assert_eq!(gt_si8(126, 0), true);
+        assert_eq!(gt_si8(126, 1), true);
+        assert_eq!(gt_si8(126, 2), true);
+        assert_eq!(gt_si8(126, 3), true);
+        assert_eq!(gt_si8(126, 4), true);
+        assert_eq!(gt_si8(126, 16), true);
+        assert_eq!(gt_si8(127, -128), true);
+        assert_eq!(gt_si8(127, -127), true);
+        assert_eq!(gt_si8(127, 0), true);
+    }
+    #[test]
+    fn test_239() {
+        assert_eq!(gt_si8(127, 1), true);
+        assert_eq!(gt_si8(127, 2), true);
+        assert_eq!(gt_si8(127, 3), true);
+        assert_eq!(gt_si8(127, 4), true);
+        assert_eq!(gt_si8(127, 16), true);
+        assert_eq!(gt_si8(127, 126), true);
+        assert_eq!(gt_ui16(0, 0), false);
+        assert_eq!(gt_ui16(0, 1), false);
+        assert_eq!(gt_ui16(0, 2), false);
+        assert_eq!(gt_ui16(0, 3), false);
+    }
+    #[test]
+    fn test_240() {
+        assert_eq!(gt_ui16(0, 4), false);
+        assert_eq!(gt_ui16(0, 1717), false);
+        assert_eq!(gt_ui16(0, 17988), false);
+        assert_eq!(gt_ui16(0, 65096), false);
+        assert_eq!(gt_ui16(0, 65534), false);
+        assert_eq!(gt_ui16(0, 65535), false);
+        assert_eq!(gt_ui16(1, 1), false);
+        assert_eq!(gt_ui16(1, 2), false);
+        assert_eq!(gt_ui16(1, 3), false);
+        assert_eq!(gt_ui16(1, 4), false);
+    }
+    #[test]
+    fn test_241() {
+        assert_eq!(gt_ui16(1, 1717), false);
+        assert_eq!(gt_ui16(1, 17988), false);
+        assert_eq!(gt_ui16(1, 65096), false);
+        assert_eq!(gt_ui16(1, 65534), false);
+        assert_eq!(gt_ui16(1, 65535), false);
+        assert_eq!(gt_ui16(2, 2), false);
+        assert_eq!(gt_ui16(2, 3), false);
+        assert_eq!(gt_ui16(2, 4), false);
+        assert_eq!(gt_ui16(2, 1717), false);
+        assert_eq!(gt_ui16(2, 17988), false);
+    }
+    #[test]
+    fn test_242() {
+        assert_eq!(gt_ui16(2, 65096), false);
+        assert_eq!(gt_ui16(2, 65534), false);
+        assert_eq!(gt_ui16(2, 65535), false);
+        assert_eq!(gt_ui16(3, 3), false);
+        assert_eq!(gt_ui16(3, 4), false);
+        assert_eq!(gt_ui16(3, 1717), false);
+        assert_eq!(gt_ui16(3, 17988), false);
+        assert_eq!(gt_ui16(3, 65096), false);
+        assert_eq!(gt_ui16(3, 65534), false);
+        assert_eq!(gt_ui16(3, 65535), false);
+    }
+    #[test]
+    fn test_243() {
+        assert_eq!(gt_ui16(4, 4), false);
+        assert_eq!(gt_ui16(4, 1717), false);
+        assert_eq!(gt_ui16(4, 17988), false);
+        assert_eq!(gt_ui16(4, 65096), false);
+        assert_eq!(gt_ui16(4, 65534), false);
+        assert_eq!(gt_ui16(4, 65535), false);
+        assert_eq!(gt_ui16(1717, 1717), false);
+        assert_eq!(gt_ui16(1717, 17988), false);
+        assert_eq!(gt_ui16(1717, 65096), false);
+        assert_eq!(gt_ui16(1717, 65534), false);
+    }
+    #[test]
+    fn test_244() {
+        assert_eq!(gt_ui16(1717, 65535), false);
+        assert_eq!(gt_ui16(17988, 17988), false);
+        assert_eq!(gt_ui16(17988, 65096), false);
+        assert_eq!(gt_ui16(17988, 65534), false);
+        assert_eq!(gt_ui16(17988, 65535), false);
+        assert_eq!(gt_ui16(65096, 65096), false);
+        assert_eq!(gt_ui16(65096, 65534), false);
+        assert_eq!(gt_ui16(65096, 65535), false);
+        assert_eq!(gt_ui16(65534, 65534), false);
+        assert_eq!(gt_ui16(65534, 65535), false);
+    }
+    #[test]
+    fn test_245() {
+        assert_eq!(gt_ui16(65535, 65535), false);
+        assert_eq!(gt_ui16(1, 0), true);
+        assert_eq!(gt_ui16(2, 0), true);
+        assert_eq!(gt_ui16(2, 1), true);
+        assert_eq!(gt_ui16(3, 0), true);
+        assert_eq!(gt_ui16(3, 1), true);
+        assert_eq!(gt_ui16(3, 2), true);
+        assert_eq!(gt_ui16(4, 0), true);
+        assert_eq!(gt_ui16(4, 1), true);
+        assert_eq!(gt_ui16(4, 2), true);
+    }
+    #[test]
+    fn test_246() {
+        assert_eq!(gt_ui16(4, 3), true);
+        assert_eq!(gt_ui16(1717, 0), true);
+        assert_eq!(gt_ui16(1717, 1), true);
+        assert_eq!(gt_ui16(1717, 2), true);
+        assert_eq!(gt_ui16(1717, 3), true);
+        assert_eq!(gt_ui16(1717, 4), true);
+        assert_eq!(gt_ui16(17988, 0), true);
+        assert_eq!(gt_ui16(17988, 1), true);
+        assert_eq!(gt_ui16(17988, 2), true);
+        assert_eq!(gt_ui16(17988, 3), true);
+    }
+    #[test]
+    fn test_247() {
+        assert_eq!(gt_ui16(17988, 4), true);
+        assert_eq!(gt_ui16(17988, 1717), true);
+        assert_eq!(gt_ui16(65096, 0), true);
+        assert_eq!(gt_ui16(65096, 1), true);
+        assert_eq!(gt_ui16(65096, 2), true);
+        assert_eq!(gt_ui16(65096, 3), true);
+        assert_eq!(gt_ui16(65096, 4), true);
+        assert_eq!(gt_ui16(65096, 1717), true);
+        assert_eq!(gt_ui16(65096, 17988), true);
+        assert_eq!(gt_ui16(65534, 0), true);
+    }
+    #[test]
+    fn test_248() {
+        assert_eq!(gt_ui16(65534, 1), true);
+        assert_eq!(gt_ui16(65534, 2), true);
+        assert_eq!(gt_ui16(65534, 3), true);
+        assert_eq!(gt_ui16(65534, 4), true);
+        assert_eq!(gt_ui16(65534, 1717), true);
+        assert_eq!(gt_ui16(65534, 17988), true);
+        assert_eq!(gt_ui16(65534, 65096), true);
+        assert_eq!(gt_ui16(65535, 0), true);
+        assert_eq!(gt_ui16(65535, 1), true);
+        assert_eq!(gt_ui16(65535, 2), true);
+    }
+    #[test]
+    fn test_249() {
+        assert_eq!(gt_ui16(65535, 3), true);
+        assert_eq!(gt_ui16(65535, 4), true);
+        assert_eq!(gt_ui16(65535, 1717), true);
+        assert_eq!(gt_ui16(65535, 17988), true);
+        assert_eq!(gt_ui16(65535, 65096), true);
+        assert_eq!(gt_ui16(65535, 65534), true);
+        assert_eq!(gt_ui32(0, 0), false);
+        assert_eq!(gt_ui32(0, 1), false);
+        assert_eq!(gt_ui32(0, 2), false);
+        assert_eq!(gt_ui32(0, 3), false);
+    }
+    #[test]
+    fn test_250() {
+        assert_eq!(gt_ui32(0, 4), false);
+        assert_eq!(gt_ui32(0, 2119154652), false);
+        assert_eq!(gt_ui32(0, 3002788344), false);
+        assert_eq!(gt_ui32(0, 3482297128), false);
+        assert_eq!(gt_ui32(0, 4294967294), false);
+        assert_eq!(gt_ui32(0, 4294967295), false);
+        assert_eq!(gt_ui32(1, 1), false);
+        assert_eq!(gt_ui32(1, 2), false);
+        assert_eq!(gt_ui32(1, 3), false);
+        assert_eq!(gt_ui32(1, 4), false);
+    }
+    #[test]
+    fn test_251() {
+        assert_eq!(gt_ui32(1, 2119154652), false);
+        assert_eq!(gt_ui32(1, 3002788344), false);
+        assert_eq!(gt_ui32(1, 3482297128), false);
+        assert_eq!(gt_ui32(1, 4294967294), false);
+        assert_eq!(gt_ui32(1, 4294967295), false);
+        assert_eq!(gt_ui32(2, 2), false);
+        assert_eq!(gt_ui32(2, 3), false);
+        assert_eq!(gt_ui32(2, 4), false);
+        assert_eq!(gt_ui32(2, 2119154652), false);
+        assert_eq!(gt_ui32(2, 3002788344), false);
+    }
+    #[test]
+    fn test_252() {
+        assert_eq!(gt_ui32(2, 3482297128), false);
+        assert_eq!(gt_ui32(2, 4294967294), false);
+        assert_eq!(gt_ui32(2, 4294967295), false);
+        assert_eq!(gt_ui32(3, 3), false);
+        assert_eq!(gt_ui32(3, 4), false);
+        assert_eq!(gt_ui32(3, 2119154652), false);
+        assert_eq!(gt_ui32(3, 3002788344), false);
+        assert_eq!(gt_ui32(3, 3482297128), false);
+        assert_eq!(gt_ui32(3, 4294967294), false);
+        assert_eq!(gt_ui32(3, 4294967295), false);
+    }
+    #[test]
+    fn test_253() {
+        assert_eq!(gt_ui32(4, 4), false);
+        assert_eq!(gt_ui32(4, 2119154652), false);
+        assert_eq!(gt_ui32(4, 3002788344), false);
+        assert_eq!(gt_ui32(4, 3482297128), false);
+        assert_eq!(gt_ui32(4, 4294967294), false);
+        assert_eq!(gt_ui32(4, 4294967295), false);
+        assert_eq!(gt_ui32(2119154652, 2119154652), false);
+        assert_eq!(gt_ui32(2119154652, 3002788344), false);
+        assert_eq!(gt_ui32(2119154652, 3482297128), false);
+        assert_eq!(gt_ui32(2119154652, 4294967294), false);
+    }
+    #[test]
+    fn test_254() {
+        assert_eq!(gt_ui32(2119154652, 4294967295), false);
+        assert_eq!(gt_ui32(3002788344, 3002788344), false);
+        assert_eq!(gt_ui32(3002788344, 3482297128), false);
+        assert_eq!(gt_ui32(3002788344, 4294967294), false);
+        assert_eq!(gt_ui32(3002788344, 4294967295), false);
+        assert_eq!(gt_ui32(3482297128, 3482297128), false);
+        assert_eq!(gt_ui32(3482297128, 4294967294), false);
+        assert_eq!(gt_ui32(3482297128, 4294967295), false);
+        assert_eq!(gt_ui32(4294967294, 4294967294), false);
+        assert_eq!(gt_ui32(4294967294, 4294967295), false);
+    }
+    #[test]
+    fn test_255() {
+        assert_eq!(gt_ui32(4294967295, 4294967295), false);
+        assert_eq!(gt_ui32(1, 0), true);
+        assert_eq!(gt_ui32(2, 0), true);
+        assert_eq!(gt_ui32(2, 1), true);
+        assert_eq!(gt_ui32(3, 0), true);
+        assert_eq!(gt_ui32(3, 1), true);
+        assert_eq!(gt_ui32(3, 2), true);
+        assert_eq!(gt_ui32(4, 0), true);
+        assert_eq!(gt_ui32(4, 1), true);
+        assert_eq!(gt_ui32(4, 2), true);
+    }
+    #[test]
+    fn test_256() {
+        assert_eq!(gt_ui32(4, 3), true);
+        assert_eq!(gt_ui32(2119154652, 0), true);
+        assert_eq!(gt_ui32(2119154652, 1), true);
+        assert_eq!(gt_ui32(2119154652, 2), true);
+        assert_eq!(gt_ui32(2119154652, 3), true);
+        assert_eq!(gt_ui32(2119154652, 4), true);
+        assert_eq!(gt_ui32(3002788344, 0), true);
+        assert_eq!(gt_ui32(3002788344, 1), true);
+        assert_eq!(gt_ui32(3002788344, 2), true);
+        assert_eq!(gt_ui32(3002788344, 3), true);
+    }
+    #[test]
+    fn test_257() {
+        assert_eq!(gt_ui32(3002788344, 4), true);
+        assert_eq!(gt_ui32(3002788344, 2119154652), true);
+        assert_eq!(gt_ui32(3482297128, 0), true);
+        assert_eq!(gt_ui32(3482297128, 1), true);
+        assert_eq!(gt_ui32(3482297128, 2), true);
+        assert_eq!(gt_ui32(3482297128, 3), true);
+        assert_eq!(gt_ui32(3482297128, 4), true);
+        assert_eq!(gt_ui32(3482297128, 2119154652), true);
+        assert_eq!(gt_ui32(3482297128, 3002788344), true);
+        assert_eq!(gt_ui32(4294967294, 0), true);
+    }
+    #[test]
+    fn test_258() {
+        assert_eq!(gt_ui32(4294967294, 1), true);
+        assert_eq!(gt_ui32(4294967294, 2), true);
+        assert_eq!(gt_ui32(4294967294, 3), true);
+        assert_eq!(gt_ui32(4294967294, 4), true);
+        assert_eq!(gt_ui32(4294967294, 2119154652), true);
+        assert_eq!(gt_ui32(4294967294, 3002788344), true);
+        assert_eq!(gt_ui32(4294967294, 3482297128), true);
+        assert_eq!(gt_ui32(4294967295, 0), true);
+        assert_eq!(gt_ui32(4294967295, 1), true);
+        assert_eq!(gt_ui32(4294967295, 2), true);
+    }
+    #[test]
+    fn test_259() {
+        assert_eq!(gt_ui32(4294967295, 3), true);
+        assert_eq!(gt_ui32(4294967295, 4), true);
+        assert_eq!(gt_ui32(4294967295, 2119154652), true);
+        assert_eq!(gt_ui32(4294967295, 3002788344), true);
+        assert_eq!(gt_ui32(4294967295, 3482297128), true);
+        assert_eq!(gt_ui32(4294967295, 4294967294), true);
+        assert_eq!(gt_ui64(0, 0), false);
+        assert_eq!(gt_ui64(0, 1), false);
+        assert_eq!(gt_ui64(0, 2), false);
+        assert_eq!(gt_ui64(0, 3), false);
+    }
+    #[test]
+    fn test_260() {
+        assert_eq!(gt_ui64(0, 4), false);
+        assert_eq!(gt_ui64(0, 191084152064409600), false);
+        assert_eq!(gt_ui64(0, 11015955194427482112), false);
+        assert_eq!(gt_ui64(0, 16990600415051759616), false);
+        assert_eq!(gt_ui64(0, 18446744073709551614), false);
+        assert_eq!(gt_ui64(0, 18446744073709551615), false);
+        assert_eq!(gt_ui64(1, 1), false);
+        assert_eq!(gt_ui64(1, 2), false);
+        assert_eq!(gt_ui64(1, 3), false);
+        assert_eq!(gt_ui64(1, 4), false);
+    }
+    #[test]
+    fn test_261() {
+        assert_eq!(gt_ui64(1, 191084152064409600), false);
+        assert_eq!(gt_ui64(1, 11015955194427482112), false);
+        assert_eq!(gt_ui64(1, 16990600415051759616), false);
+        assert_eq!(gt_ui64(1, 18446744073709551614), false);
+        assert_eq!(gt_ui64(1, 18446744073709551615), false);
+        assert_eq!(gt_ui64(2, 2), false);
+        assert_eq!(gt_ui64(2, 3), false);
+        assert_eq!(gt_ui64(2, 4), false);
+        assert_eq!(gt_ui64(2, 191084152064409600), false);
+        assert_eq!(gt_ui64(2, 11015955194427482112), false);
+    }
+    #[test]
+    fn test_262() {
+        assert_eq!(gt_ui64(2, 16990600415051759616), false);
+        assert_eq!(gt_ui64(2, 18446744073709551614), false);
+        assert_eq!(gt_ui64(2, 18446744073709551615), false);
+        assert_eq!(gt_ui64(3, 3), false);
+        assert_eq!(gt_ui64(3, 4), false);
+        assert_eq!(gt_ui64(3, 191084152064409600), false);
+        assert_eq!(gt_ui64(3, 11015955194427482112), false);
+        assert_eq!(gt_ui64(3, 16990600415051759616), false);
+        assert_eq!(gt_ui64(3, 18446744073709551614), false);
+        assert_eq!(gt_ui64(3, 18446744073709551615), false);
+    }
+    #[test]
+    fn test_263() {
+        assert_eq!(gt_ui64(4, 4), false);
+        assert_eq!(gt_ui64(4, 191084152064409600), false);
+        assert_eq!(gt_ui64(4, 11015955194427482112), false);
+        assert_eq!(gt_ui64(4, 16990600415051759616), false);
+        assert_eq!(gt_ui64(4, 18446744073709551614), false);
+        assert_eq!(gt_ui64(4, 18446744073709551615), false);
+        assert_eq!(gt_ui64(191084152064409600, 191084152064409600), false);
+        assert_eq!(gt_ui64(191084152064409600, 11015955194427482112), false);
+        assert_eq!(gt_ui64(191084152064409600, 16990600415051759616), false);
+        assert_eq!(gt_ui64(191084152064409600, 18446744073709551614), false);
+    }
+    #[test]
+    fn test_264() {
+        assert_eq!(gt_ui64(191084152064409600, 18446744073709551615), false);
+        assert_eq!(gt_ui64(11015955194427482112, 11015955194427482112), false);
+        assert_eq!(gt_ui64(11015955194427482112, 16990600415051759616), false);
+        assert_eq!(gt_ui64(11015955194427482112, 18446744073709551614), false);
+        assert_eq!(gt_ui64(11015955194427482112, 18446744073709551615), false);
+        assert_eq!(gt_ui64(16990600415051759616, 16990600415051759616), false);
+        assert_eq!(gt_ui64(16990600415051759616, 18446744073709551614), false);
+        assert_eq!(gt_ui64(16990600415051759616, 18446744073709551615), false);
+        assert_eq!(gt_ui64(18446744073709551614, 18446744073709551614), false);
+        assert_eq!(gt_ui64(18446744073709551614, 18446744073709551615), false);
+    }
+    #[test]
+    fn test_265() {
+        assert_eq!(gt_ui64(18446744073709551615, 18446744073709551615), false);
+        assert_eq!(gt_ui64(1, 0), true);
+        assert_eq!(gt_ui64(2, 0), true);
+        assert_eq!(gt_ui64(2, 1), true);
+        assert_eq!(gt_ui64(3, 0), true);
+        assert_eq!(gt_ui64(3, 1), true);
+        assert_eq!(gt_ui64(3, 2), true);
+        assert_eq!(gt_ui64(4, 0), true);
+        assert_eq!(gt_ui64(4, 1), true);
+        assert_eq!(gt_ui64(4, 2), true);
+    }
+    #[test]
+    fn test_266() {
+        assert_eq!(gt_ui64(4, 3), true);
+        assert_eq!(gt_ui64(191084152064409600, 0), true);
+        assert_eq!(gt_ui64(191084152064409600, 1), true);
+        assert_eq!(gt_ui64(191084152064409600, 2), true);
+        assert_eq!(gt_ui64(191084152064409600, 3), true);
+        assert_eq!(gt_ui64(191084152064409600, 4), true);
+        assert_eq!(gt_ui64(11015955194427482112, 0), true);
+        assert_eq!(gt_ui64(11015955194427482112, 1), true);
+        assert_eq!(gt_ui64(11015955194427482112, 2), true);
+        assert_eq!(gt_ui64(11015955194427482112, 3), true);
+    }
+    #[test]
+    fn test_267() {
+        assert_eq!(gt_ui64(11015955194427482112, 4), true);
+        assert_eq!(gt_ui64(11015955194427482112, 191084152064409600), true);
+        assert_eq!(gt_ui64(16990600415051759616, 0), true);
+        assert_eq!(gt_ui64(16990600415051759616, 1), true);
+        assert_eq!(gt_ui64(16990600415051759616, 2), true);
+        assert_eq!(gt_ui64(16990600415051759616, 3), true);
+        assert_eq!(gt_ui64(16990600415051759616, 4), true);
+        assert_eq!(gt_ui64(16990600415051759616, 191084152064409600), true);
+        assert_eq!(gt_ui64(16990600415051759616, 11015955194427482112), true);
+        assert_eq!(gt_ui64(18446744073709551614, 0), true);
+    }
+    #[test]
+    fn test_268() {
+        assert_eq!(gt_ui64(18446744073709551614, 1), true);
+        assert_eq!(gt_ui64(18446744073709551614, 2), true);
+        assert_eq!(gt_ui64(18446744073709551614, 3), true);
+        assert_eq!(gt_ui64(18446744073709551614, 4), true);
+        assert_eq!(gt_ui64(18446744073709551614, 191084152064409600), true);
+        assert_eq!(gt_ui64(18446744073709551614, 11015955194427482112), true);
+        assert_eq!(gt_ui64(18446744073709551614, 16990600415051759616), true);
+        assert_eq!(gt_ui64(18446744073709551615, 0), true);
+        assert_eq!(gt_ui64(18446744073709551615, 1), true);
+        assert_eq!(gt_ui64(18446744073709551615, 2), true);
+    }
+    #[test]
+    fn test_269() {
+        assert_eq!(gt_ui64(18446744073709551615, 3), true);
+        assert_eq!(gt_ui64(18446744073709551615, 4), true);
+        assert_eq!(gt_ui64(18446744073709551615, 191084152064409600), true);
+        assert_eq!(gt_ui64(18446744073709551615, 11015955194427482112), true);
+        assert_eq!(gt_ui64(18446744073709551615, 16990600415051759616), true);
+        assert_eq!(gt_ui64(18446744073709551615, 18446744073709551614), true);
+        assert_eq!(gt_ui8(0, 0), false);
+        assert_eq!(gt_ui8(0, 1), false);
+        assert_eq!(gt_ui8(0, 2), false);
+        assert_eq!(gt_ui8(0, 3), false);
+    }
+    #[test]
+    fn test_270() {
+        assert_eq!(gt_ui8(0, 4), false);
+        assert_eq!(gt_ui8(0, 72), false);
+        assert_eq!(gt_ui8(0, 100), false);
+        assert_eq!(gt_ui8(0, 162), false);
+        assert_eq!(gt_ui8(0, 254), false);
+        assert_eq!(gt_ui8(0, 255), false);
+        assert_eq!(gt_ui8(1, 1), false);
+        assert_eq!(gt_ui8(1, 2), false);
+        assert_eq!(gt_ui8(1, 3), false);
+        assert_eq!(gt_ui8(1, 4), false);
+    }
+    #[test]
+    fn test_271() {
+        assert_eq!(gt_ui8(1, 72), false);
+        assert_eq!(gt_ui8(1, 100), false);
+        assert_eq!(gt_ui8(1, 162), false);
+        assert_eq!(gt_ui8(1, 254), false);
+        assert_eq!(gt_ui8(1, 255), false);
+        assert_eq!(gt_ui8(2, 2), false);
+        assert_eq!(gt_ui8(2, 3), false);
+        assert_eq!(gt_ui8(2, 4), false);
+        assert_eq!(gt_ui8(2, 72), false);
+        assert_eq!(gt_ui8(2, 100), false);
+    }
+    #[test]
+    fn test_272() {
+        assert_eq!(gt_ui8(2, 162), false);
+        assert_eq!(gt_ui8(2, 254), false);
+        assert_eq!(gt_ui8(2, 255), false);
+        assert_eq!(gt_ui8(3, 3), false);
+        assert_eq!(gt_ui8(3, 4), false);
+        assert_eq!(gt_ui8(3, 72), false);
+        assert_eq!(gt_ui8(3, 100), false);
+        assert_eq!(gt_ui8(3, 162), false);
+        assert_eq!(gt_ui8(3, 254), false);
+        assert_eq!(gt_ui8(3, 255), false);
+    }
+    #[test]
+    fn test_273() {
+        assert_eq!(gt_ui8(4, 4), false);
+        assert_eq!(gt_ui8(4, 72), false);
+        assert_eq!(gt_ui8(4, 100), false);
+        assert_eq!(gt_ui8(4, 162), false);
+        assert_eq!(gt_ui8(4, 254), false);
+        assert_eq!(gt_ui8(4, 255), false);
+        assert_eq!(gt_ui8(72, 72), false);
+        assert_eq!(gt_ui8(72, 100), false);
+        assert_eq!(gt_ui8(72, 162), false);
+        assert_eq!(gt_ui8(72, 254), false);
+    }
+    #[test]
+    fn test_274() {
+        assert_eq!(gt_ui8(72, 255), false);
+        assert_eq!(gt_ui8(100, 100), false);
+        assert_eq!(gt_ui8(100, 162), false);
+        assert_eq!(gt_ui8(100, 254), false);
+        assert_eq!(gt_ui8(100, 255), false);
+        assert_eq!(gt_ui8(162, 162), false);
+        assert_eq!(gt_ui8(162, 254), false);
+        assert_eq!(gt_ui8(162, 255), false);
+        assert_eq!(gt_ui8(254, 254), false);
+        assert_eq!(gt_ui8(254, 255), false);
+    }
+    #[test]
+    fn test_275() {
+        assert_eq!(gt_ui8(255, 255), false);
+        assert_eq!(gt_ui8(1, 0), true);
+        assert_eq!(gt_ui8(2, 0), true);
+        assert_eq!(gt_ui8(2, 1), true);
+        assert_eq!(gt_ui8(3, 0), true);
+        assert_eq!(gt_ui8(3, 1), true);
+        assert_eq!(gt_ui8(3, 2), true);
+        assert_eq!(gt_ui8(4, 0), true);
+        assert_eq!(gt_ui8(4, 1), true);
+        assert_eq!(gt_ui8(4, 2), true);
+    }
+    #[test]
+    fn test_276() {
+        assert_eq!(gt_ui8(4, 3), true);
+        assert_eq!(gt_ui8(72, 0), true);
+        assert_eq!(gt_ui8(72, 1), true);
+        assert_eq!(gt_ui8(72, 2), true);
+        assert_eq!(gt_ui8(72, 3), true);
+        assert_eq!(gt_ui8(72, 4), true);
+        assert_eq!(gt_ui8(100, 0), true);
+        assert_eq!(gt_ui8(100, 1), true);
+        assert_eq!(gt_ui8(100, 2), true);
+        assert_eq!(gt_ui8(100, 3), true);
+    }
+    #[test]
+    fn test_277() {
+        assert_eq!(gt_ui8(100, 4), true);
+        assert_eq!(gt_ui8(100, 72), true);
+        assert_eq!(gt_ui8(162, 0), true);
+        assert_eq!(gt_ui8(162, 1), true);
+        assert_eq!(gt_ui8(162, 2), true);
+        assert_eq!(gt_ui8(162, 3), true);
+        assert_eq!(gt_ui8(162, 4), true);
+        assert_eq!(gt_ui8(162, 72), true);
+        assert_eq!(gt_ui8(162, 100), true);
+        assert_eq!(gt_ui8(254, 0), true);
+    }
+    #[test]
+    fn test_278() {
+        assert_eq!(gt_ui8(254, 1), true);
+        assert_eq!(gt_ui8(254, 2), true);
+        assert_eq!(gt_ui8(254, 3), true);
+        assert_eq!(gt_ui8(254, 4), true);
+        assert_eq!(gt_ui8(254, 72), true);
+        assert_eq!(gt_ui8(254, 100), true);
+        assert_eq!(gt_ui8(254, 162), true);
+        assert_eq!(gt_ui8(255, 0), true);
+        assert_eq!(gt_ui8(255, 1), true);
+        assert_eq!(gt_ui8(255, 2), true);
+    }
+    #[test]
+    fn test_279() {
+        assert_eq!(gt_ui8(255, 3), true);
+        assert_eq!(gt_ui8(255, 4), true);
+        assert_eq!(gt_ui8(255, 72), true);
+        assert_eq!(gt_ui8(255, 100), true);
+        assert_eq!(gt_ui8(255, 162), true);
+        assert_eq!(gt_ui8(255, 254), true);
+        assert_eq!(le_si16(-32767, -32768), false);
+        assert_eq!(le_si16(-32547, -32768), false);
+        assert_eq!(le_si16(-32547, -32767), false);
+        assert_eq!(le_si16(0, -32768), false);
+    }
+    #[test]
+    fn test_280() {
+        assert_eq!(le_si16(0, -32767), false);
+        assert_eq!(le_si16(0, -32547), false);
+        assert_eq!(le_si16(1, -32768), false);
+        assert_eq!(le_si16(1, -32767), false);
+        assert_eq!(le_si16(1, -32547), false);
+        assert_eq!(le_si16(1, 0), false);
+        assert_eq!(le_si16(2, -32768), false);
+        assert_eq!(le_si16(2, -32767), false);
+        assert_eq!(le_si16(2, -32547), false);
+        assert_eq!(le_si16(2, 0), false);
+    }
+    #[test]
+    fn test_281() {
+        assert_eq!(le_si16(2, 1), false);
+        assert_eq!(le_si16(3, -32768), false);
+        assert_eq!(le_si16(3, -32767), false);
+        assert_eq!(le_si16(3, -32547), false);
+        assert_eq!(le_si16(3, 0), false);
+        assert_eq!(le_si16(3, 1), false);
+        assert_eq!(le_si16(3, 2), false);
+        assert_eq!(le_si16(4, -32768), false);
+        assert_eq!(le_si16(4, -32767), false);
+        assert_eq!(le_si16(4, -32547), false);
+    }
+    #[test]
+    fn test_282() {
+        assert_eq!(le_si16(4, 0), false);
+        assert_eq!(le_si16(4, 1), false);
+        assert_eq!(le_si16(4, 2), false);
+        assert_eq!(le_si16(4, 3), false);
+        assert_eq!(le_si16(10486, -32768), false);
+        assert_eq!(le_si16(10486, -32767), false);
+        assert_eq!(le_si16(10486, -32547), false);
+        assert_eq!(le_si16(10486, 0), false);
+        assert_eq!(le_si16(10486, 1), false);
+        assert_eq!(le_si16(10486, 2), false);
+    }
+    #[test]
+    fn test_283() {
+        assert_eq!(le_si16(10486, 3), false);
+        assert_eq!(le_si16(10486, 4), false);
+        assert_eq!(le_si16(16514, -32768), false);
+        assert_eq!(le_si16(16514, -32767), false);
+        assert_eq!(le_si16(16514, -32547), false);
+        assert_eq!(le_si16(16514, 0), false);
+        assert_eq!(le_si16(16514, 1), false);
+        assert_eq!(le_si16(16514, 2), false);
+        assert_eq!(le_si16(16514, 3), false);
+        assert_eq!(le_si16(16514, 4), false);
+    }
+    #[test]
+    fn test_284() {
+        assert_eq!(le_si16(16514, 10486), false);
+        assert_eq!(le_si16(32766, -32768), false);
+        assert_eq!(le_si16(32766, -32767), false);
+        assert_eq!(le_si16(32766, -32547), false);
+        assert_eq!(le_si16(32766, 0), false);
+        assert_eq!(le_si16(32766, 1), false);
+        assert_eq!(le_si16(32766, 2), false);
+        assert_eq!(le_si16(32766, 3), false);
+        assert_eq!(le_si16(32766, 4), false);
+        assert_eq!(le_si16(32766, 10486), false);
+    }
+    #[test]
+    fn test_285() {
+        assert_eq!(le_si16(32766, 16514), false);
+        assert_eq!(le_si16(32767, -32768), false);
+        assert_eq!(le_si16(32767, -32767), false);
+        assert_eq!(le_si16(32767, -32547), false);
+        assert_eq!(le_si16(32767, 0), false);
+        assert_eq!(le_si16(32767, 1), false);
+        assert_eq!(le_si16(32767, 2), false);
+        assert_eq!(le_si16(32767, 3), false);
+        assert_eq!(le_si16(32767, 4), false);
+        assert_eq!(le_si16(32767, 10486), false);
+    }
+    #[test]
+    fn test_286() {
+        assert_eq!(le_si16(32767, 16514), false);
+        assert_eq!(le_si16(32767, 32766), false);
+        assert_eq!(le_si16(-32768, -32768), true);
+        assert_eq!(le_si16(-32768, -32767), true);
+        assert_eq!(le_si16(-32768, -32547), true);
+        assert_eq!(le_si16(-32768, 0), true);
+        assert_eq!(le_si16(-32768, 1), true);
+        assert_eq!(le_si16(-32768, 2), true);
+        assert_eq!(le_si16(-32768, 3), true);
+        assert_eq!(le_si16(-32768, 4), true);
+    }
+    #[test]
+    fn test_287() {
+        assert_eq!(le_si16(-32768, 10486), true);
+        assert_eq!(le_si16(-32768, 16514), true);
+        assert_eq!(le_si16(-32768, 32766), true);
+        assert_eq!(le_si16(-32768, 32767), true);
+        assert_eq!(le_si16(-32767, -32767), true);
+        assert_eq!(le_si16(-32767, -32547), true);
+        assert_eq!(le_si16(-32767, 0), true);
+        assert_eq!(le_si16(-32767, 1), true);
+        assert_eq!(le_si16(-32767, 2), true);
+        assert_eq!(le_si16(-32767, 3), true);
+    }
+    #[test]
+    fn test_288() {
+        assert_eq!(le_si16(-32767, 4), true);
+        assert_eq!(le_si16(-32767, 10486), true);
+        assert_eq!(le_si16(-32767, 16514), true);
+        assert_eq!(le_si16(-32767, 32766), true);
+        assert_eq!(le_si16(-32767, 32767), true);
+        assert_eq!(le_si16(-32547, -32547), true);
+        assert_eq!(le_si16(-32547, 0), true);
+        assert_eq!(le_si16(-32547, 1), true);
+        assert_eq!(le_si16(-32547, 2), true);
+        assert_eq!(le_si16(-32547, 3), true);
+    }
+    #[test]
+    fn test_289() {
+        assert_eq!(le_si16(-32547, 4), true);
+        assert_eq!(le_si16(-32547, 10486), true);
+        assert_eq!(le_si16(-32547, 16514), true);
+        assert_eq!(le_si16(-32547, 32766), true);
+        assert_eq!(le_si16(-32547, 32767), true);
+        assert_eq!(le_si16(0, 0), true);
+        assert_eq!(le_si16(0, 1), true);
+        assert_eq!(le_si16(0, 2), true);
+        assert_eq!(le_si16(0, 3), true);
+        assert_eq!(le_si16(0, 4), true);
+    }
+    #[test]
+    fn test_290() {
+        assert_eq!(le_si16(0, 10486), true);
+        assert_eq!(le_si16(0, 16514), true);
+        assert_eq!(le_si16(0, 32766), true);
+        assert_eq!(le_si16(0, 32767), true);
+        assert_eq!(le_si16(1, 1), true);
+        assert_eq!(le_si16(1, 2), true);
+        assert_eq!(le_si16(1, 3), true);
+        assert_eq!(le_si16(1, 4), true);
+        assert_eq!(le_si16(1, 10486), true);
+        assert_eq!(le_si16(1, 16514), true);
+    }
+    #[test]
+    fn test_291() {
+        assert_eq!(le_si16(1, 32766), true);
+        assert_eq!(le_si16(1, 32767), true);
+        assert_eq!(le_si16(2, 2), true);
+        assert_eq!(le_si16(2, 3), true);
+        assert_eq!(le_si16(2, 4), true);
+        assert_eq!(le_si16(2, 10486), true);
+        assert_eq!(le_si16(2, 16514), true);
+        assert_eq!(le_si16(2, 32766), true);
+        assert_eq!(le_si16(2, 32767), true);
+        assert_eq!(le_si16(3, 3), true);
+    }
+    #[test]
+    fn test_292() {
+        assert_eq!(le_si16(3, 4), true);
+        assert_eq!(le_si16(3, 10486), true);
+        assert_eq!(le_si16(3, 16514), true);
+        assert_eq!(le_si16(3, 32766), true);
+        assert_eq!(le_si16(3, 32767), true);
+        assert_eq!(le_si16(4, 4), true);
+        assert_eq!(le_si16(4, 10486), true);
+        assert_eq!(le_si16(4, 16514), true);
+        assert_eq!(le_si16(4, 32766), true);
+        assert_eq!(le_si16(4, 32767), true);
+    }
+    #[test]
+    fn test_293() {
+        assert_eq!(le_si16(10486, 10486), true);
+        assert_eq!(le_si16(10486, 16514), true);
+        assert_eq!(le_si16(10486, 32766), true);
+        assert_eq!(le_si16(10486, 32767), true);
+        assert_eq!(le_si16(16514, 16514), true);
+        assert_eq!(le_si16(16514, 32766), true);
+        assert_eq!(le_si16(16514, 32767), true);
+        assert_eq!(le_si16(32766, 32766), true);
+        assert_eq!(le_si16(32766, 32767), true);
+        assert_eq!(le_si16(32767, 32767), true);
+    }
+    #[test]
+    fn test_294() {
+        assert_eq!(le_si32(-2147483647, -2147483648), false);
+        assert_eq!(le_si32(-1713183800, -2147483648), false);
+        assert_eq!(le_si32(-1713183800, -2147483647), false);
+        assert_eq!(le_si32(-1252582164, -2147483648), false);
+        assert_eq!(le_si32(-1252582164, -2147483647), false);
+        assert_eq!(le_si32(-1252582164, -1713183800), false);
+        assert_eq!(le_si32(-1035405763, -2147483648), false);
+        assert_eq!(le_si32(-1035405763, -2147483647), false);
+        assert_eq!(le_si32(-1035405763, -1713183800), false);
+        assert_eq!(le_si32(-1035405763, -1252582164), false);
+    }
+    #[test]
+    fn test_295() {
+        assert_eq!(le_si32(0, -2147483648), false);
+        assert_eq!(le_si32(0, -2147483647), false);
+        assert_eq!(le_si32(0, -1713183800), false);
+        assert_eq!(le_si32(0, -1252582164), false);
+        assert_eq!(le_si32(0, -1035405763), false);
+        assert_eq!(le_si32(1, -2147483648), false);
+        assert_eq!(le_si32(1, -2147483647), false);
+        assert_eq!(le_si32(1, -1713183800), false);
+        assert_eq!(le_si32(1, -1252582164), false);
+        assert_eq!(le_si32(1, -1035405763), false);
+    }
+    #[test]
+    fn test_296() {
+        assert_eq!(le_si32(1, 0), false);
+        assert_eq!(le_si32(2, -2147483648), false);
+        assert_eq!(le_si32(2, -2147483647), false);
+        assert_eq!(le_si32(2, -1713183800), false);
+        assert_eq!(le_si32(2, -1252582164), false);
+        assert_eq!(le_si32(2, -1035405763), false);
+        assert_eq!(le_si32(2, 0), false);
+        assert_eq!(le_si32(2, 1), false);
+        assert_eq!(le_si32(3, -2147483648), false);
+        assert_eq!(le_si32(3, -2147483647), false);
+    }
+    #[test]
+    fn test_297() {
+        assert_eq!(le_si32(3, -1713183800), false);
+        assert_eq!(le_si32(3, -1252582164), false);
+        assert_eq!(le_si32(3, -1035405763), false);
+        assert_eq!(le_si32(3, 0), false);
+        assert_eq!(le_si32(3, 1), false);
+        assert_eq!(le_si32(3, 2), false);
+        assert_eq!(le_si32(4, -2147483648), false);
+        assert_eq!(le_si32(4, -2147483647), false);
+        assert_eq!(le_si32(4, -1713183800), false);
+        assert_eq!(le_si32(4, -1252582164), false);
+    }
+    #[test]
+    fn test_298() {
+        assert_eq!(le_si32(4, -1035405763), false);
+        assert_eq!(le_si32(4, 0), false);
+        assert_eq!(le_si32(4, 1), false);
+        assert_eq!(le_si32(4, 2), false);
+        assert_eq!(le_si32(4, 3), false);
+        assert_eq!(le_si32(2147483646, -2147483648), false);
+        assert_eq!(le_si32(2147483646, -2147483647), false);
+        assert_eq!(le_si32(2147483646, -1713183800), false);
+        assert_eq!(le_si32(2147483646, -1252582164), false);
+        assert_eq!(le_si32(2147483646, -1035405763), false);
+    }
+    #[test]
+    fn test_299() {
+        assert_eq!(le_si32(2147483646, 0), false);
+        assert_eq!(le_si32(2147483646, 1), false);
+        assert_eq!(le_si32(2147483646, 2), false);
+        assert_eq!(le_si32(2147483646, 3), false);
+        assert_eq!(le_si32(2147483646, 4), false);
+        assert_eq!(le_si32(2147483647, -2147483648), false);
+        assert_eq!(le_si32(2147483647, -2147483647), false);
+        assert_eq!(le_si32(2147483647, -1713183800), false);
+        assert_eq!(le_si32(2147483647, -1252582164), false);
+        assert_eq!(le_si32(2147483647, -1035405763), false);
+    }
+    #[test]
+    fn test_300() {
+        assert_eq!(le_si32(2147483647, 0), false);
+        assert_eq!(le_si32(2147483647, 1), false);
+        assert_eq!(le_si32(2147483647, 2), false);
+        assert_eq!(le_si32(2147483647, 3), false);
+        assert_eq!(le_si32(2147483647, 4), false);
+        assert_eq!(le_si32(2147483647, 2147483646), false);
+        assert_eq!(le_si32(-2147483648, -2147483648), true);
+        assert_eq!(le_si32(-2147483648, -2147483647), true);
+        assert_eq!(le_si32(-2147483648, -1713183800), true);
+        assert_eq!(le_si32(-2147483648, -1252582164), true);
+    }
+    #[test]
+    fn test_301() {
+        assert_eq!(le_si32(-2147483648, -1035405763), true);
+        assert_eq!(le_si32(-2147483648, 0), true);
+        assert_eq!(le_si32(-2147483648, 1), true);
+        assert_eq!(le_si32(-2147483648, 2), true);
+        assert_eq!(le_si32(-2147483648, 3), true);
+        assert_eq!(le_si32(-2147483648, 4), true);
+        assert_eq!(le_si32(-2147483648, 2147483646), true);
+        assert_eq!(le_si32(-2147483648, 2147483647), true);
+        assert_eq!(le_si32(-2147483647, -2147483647), true);
+        assert_eq!(le_si32(-2147483647, -1713183800), true);
+    }
+    #[test]
+    fn test_302() {
+        assert_eq!(le_si32(-2147483647, -1252582164), true);
+        assert_eq!(le_si32(-2147483647, -1035405763), true);
+        assert_eq!(le_si32(-2147483647, 0), true);
+        assert_eq!(le_si32(-2147483647, 1), true);
+        assert_eq!(le_si32(-2147483647, 2), true);
+        assert_eq!(le_si32(-2147483647, 3), true);
+        assert_eq!(le_si32(-2147483647, 4), true);
+        assert_eq!(le_si32(-2147483647, 2147483646), true);
+        assert_eq!(le_si32(-2147483647, 2147483647), true);
+        assert_eq!(le_si32(-1713183800, -1713183800), true);
+    }
+    #[test]
+    fn test_303() {
+        assert_eq!(le_si32(-1713183800, -1252582164), true);
+        assert_eq!(le_si32(-1713183800, -1035405763), true);
+        assert_eq!(le_si32(-1713183800, 0), true);
+        assert_eq!(le_si32(-1713183800, 1), true);
+        assert_eq!(le_si32(-1713183800, 2), true);
+        assert_eq!(le_si32(-1713183800, 3), true);
+        assert_eq!(le_si32(-1713183800, 4), true);
+        assert_eq!(le_si32(-1713183800, 2147483646), true);
+        assert_eq!(le_si32(-1713183800, 2147483647), true);
+        assert_eq!(le_si32(-1252582164, -1252582164), true);
+    }
+    #[test]
+    fn test_304() {
+        assert_eq!(le_si32(-1252582164, -1035405763), true);
+        assert_eq!(le_si32(-1252582164, 0), true);
+        assert_eq!(le_si32(-1252582164, 1), true);
+        assert_eq!(le_si32(-1252582164, 2), true);
+        assert_eq!(le_si32(-1252582164, 3), true);
+        assert_eq!(le_si32(-1252582164, 4), true);
+        assert_eq!(le_si32(-1252582164, 2147483646), true);
+        assert_eq!(le_si32(-1252582164, 2147483647), true);
+        assert_eq!(le_si32(-1035405763, -1035405763), true);
+        assert_eq!(le_si32(-1035405763, 0), true);
+    }
+    #[test]
+    fn test_305() {
+        assert_eq!(le_si32(-1035405763, 1), true);
+        assert_eq!(le_si32(-1035405763, 2), true);
+        assert_eq!(le_si32(-1035405763, 3), true);
+        assert_eq!(le_si32(-1035405763, 4), true);
+        assert_eq!(le_si32(-1035405763, 2147483646), true);
+        assert_eq!(le_si32(-1035405763, 2147483647), true);
+        assert_eq!(le_si32(0, 0), true);
+        assert_eq!(le_si32(0, 1), true);
+        assert_eq!(le_si32(0, 2), true);
+        assert_eq!(le_si32(0, 3), true);
+    }
+    #[test]
+    fn test_306() {
+        assert_eq!(le_si32(0, 4), true);
+        assert_eq!(le_si32(0, 2147483646), true);
+        assert_eq!(le_si32(0, 2147483647), true);
+        assert_eq!(le_si32(1, 1), true);
+        assert_eq!(le_si32(1, 2), true);
+        assert_eq!(le_si32(1, 3), true);
+        assert_eq!(le_si32(1, 4), true);
+        assert_eq!(le_si32(1, 2147483646), true);
+        assert_eq!(le_si32(1, 2147483647), true);
+        assert_eq!(le_si32(2, 2), true);
+    }
+    #[test]
+    fn test_307() {
+        assert_eq!(le_si32(2, 3), true);
+        assert_eq!(le_si32(2, 4), true);
+        assert_eq!(le_si32(2, 2147483646), true);
+        assert_eq!(le_si32(2, 2147483647), true);
+        assert_eq!(le_si32(3, 3), true);
+        assert_eq!(le_si32(3, 4), true);
+        assert_eq!(le_si32(3, 2147483646), true);
+        assert_eq!(le_si32(3, 2147483647), true);
+        assert_eq!(le_si32(4, 4), true);
+        assert_eq!(le_si32(4, 2147483646), true);
+    }
+    #[test]
+    fn test_308() {
+        assert_eq!(le_si32(4, 2147483647), true);
+        assert_eq!(le_si32(2147483646, 2147483646), true);
+        assert_eq!(le_si32(2147483646, 2147483647), true);
+        assert_eq!(le_si32(2147483647, 2147483647), true);
+        assert_eq!(le_si64(-9223372036854775807, -9223372036854775808), false);
+        assert_eq!(le_si64(-1741927215160008704, -9223372036854775808), false);
+        assert_eq!(le_si64(-1741927215160008704, -9223372036854775807), false);
+        assert_eq!(le_si64(-1328271339354574848, -9223372036854775808), false);
+        assert_eq!(le_si64(-1328271339354574848, -9223372036854775807), false);
+        assert_eq!(le_si64(-1328271339354574848, -1741927215160008704), false);
+    }
+    #[test]
+    fn test_309() {
+        assert_eq!(le_si64(0, -9223372036854775808), false);
+        assert_eq!(le_si64(0, -9223372036854775807), false);
+        assert_eq!(le_si64(0, -1741927215160008704), false);
+        assert_eq!(le_si64(0, -1328271339354574848), false);
+        assert_eq!(le_si64(1, -9223372036854775808), false);
+        assert_eq!(le_si64(1, -9223372036854775807), false);
+        assert_eq!(le_si64(1, -1741927215160008704), false);
+        assert_eq!(le_si64(1, -1328271339354574848), false);
+        assert_eq!(le_si64(1, 0), false);
+        assert_eq!(le_si64(2, -9223372036854775808), false);
+    }
+    #[test]
+    fn test_310() {
+        assert_eq!(le_si64(2, -9223372036854775807), false);
+        assert_eq!(le_si64(2, -1741927215160008704), false);
+        assert_eq!(le_si64(2, -1328271339354574848), false);
+        assert_eq!(le_si64(2, 0), false);
+        assert_eq!(le_si64(2, 1), false);
+        assert_eq!(le_si64(3, -9223372036854775808), false);
+        assert_eq!(le_si64(3, -9223372036854775807), false);
+        assert_eq!(le_si64(3, -1741927215160008704), false);
+        assert_eq!(le_si64(3, -1328271339354574848), false);
+        assert_eq!(le_si64(3, 0), false);
+    }
+    #[test]
+    fn test_311() {
+        assert_eq!(le_si64(3, 1), false);
+        assert_eq!(le_si64(3, 2), false);
+        assert_eq!(le_si64(4, -9223372036854775808), false);
+        assert_eq!(le_si64(4, -9223372036854775807), false);
+        assert_eq!(le_si64(4, -1741927215160008704), false);
+        assert_eq!(le_si64(4, -1328271339354574848), false);
+        assert_eq!(le_si64(4, 0), false);
+        assert_eq!(le_si64(4, 1), false);
+        assert_eq!(le_si64(4, 2), false);
+        assert_eq!(le_si64(4, 3), false);
+    }
+    #[test]
+    fn test_312() {
+        assert_eq!(le_si64(5577148965131116544, -9223372036854775808), false);
+        assert_eq!(le_si64(5577148965131116544, -9223372036854775807), false);
+        assert_eq!(le_si64(5577148965131116544, -1741927215160008704), false);
+        assert_eq!(le_si64(5577148965131116544, -1328271339354574848), false);
+        assert_eq!(le_si64(5577148965131116544, 0), false);
+        assert_eq!(le_si64(5577148965131116544, 1), false);
+        assert_eq!(le_si64(5577148965131116544, 2), false);
+        assert_eq!(le_si64(5577148965131116544, 3), false);
+        assert_eq!(le_si64(5577148965131116544, 4), false);
+        assert_eq!(le_si64(9223372036854775806, -9223372036854775808), false);
+    }
+    #[test]
+    fn test_313() {
+        assert_eq!(le_si64(9223372036854775806, -9223372036854775807), false);
+        assert_eq!(le_si64(9223372036854775806, -1741927215160008704), false);
+        assert_eq!(le_si64(9223372036854775806, -1328271339354574848), false);
+        assert_eq!(le_si64(9223372036854775806, 0), false);
+        assert_eq!(le_si64(9223372036854775806, 1), false);
+        assert_eq!(le_si64(9223372036854775806, 2), false);
+        assert_eq!(le_si64(9223372036854775806, 3), false);
+        assert_eq!(le_si64(9223372036854775806, 4), false);
+        assert_eq!(le_si64(9223372036854775806, 5577148965131116544), false);
+        assert_eq!(le_si64(9223372036854775807, -9223372036854775808), false);
+    }
+    #[test]
+    fn test_314() {
+        assert_eq!(le_si64(9223372036854775807, -9223372036854775807), false);
+        assert_eq!(le_si64(9223372036854775807, -1741927215160008704), false);
+        assert_eq!(le_si64(9223372036854775807, -1328271339354574848), false);
+        assert_eq!(le_si64(9223372036854775807, 0), false);
+        assert_eq!(le_si64(9223372036854775807, 1), false);
+        assert_eq!(le_si64(9223372036854775807, 2), false);
+        assert_eq!(le_si64(9223372036854775807, 3), false);
+        assert_eq!(le_si64(9223372036854775807, 4), false);
+        assert_eq!(le_si64(9223372036854775807, 5577148965131116544), false);
+        assert_eq!(le_si64(9223372036854775807, 9223372036854775806), false);
+    }
+    #[test]
+    fn test_315() {
+        assert_eq!(le_si64(-9223372036854775808, -9223372036854775808), true);
+        assert_eq!(le_si64(-9223372036854775808, -9223372036854775807), true);
+        assert_eq!(le_si64(-9223372036854775808, -1741927215160008704), true);
+        assert_eq!(le_si64(-9223372036854775808, -1328271339354574848), true);
+        assert_eq!(le_si64(-9223372036854775808, 0), true);
+        assert_eq!(le_si64(-9223372036854775808, 1), true);
+        assert_eq!(le_si64(-9223372036854775808, 2), true);
+        assert_eq!(le_si64(-9223372036854775808, 3), true);
+        assert_eq!(le_si64(-9223372036854775808, 4), true);
+        assert_eq!(le_si64(-9223372036854775808, 5577148965131116544), true);
+    }
+    #[test]
+    fn test_316() {
+        assert_eq!(le_si64(-9223372036854775808, 9223372036854775806), true);
+        assert_eq!(le_si64(-9223372036854775808, 9223372036854775807), true);
+        assert_eq!(le_si64(-9223372036854775807, -9223372036854775807), true);
+        assert_eq!(le_si64(-9223372036854775807, -1741927215160008704), true);
+        assert_eq!(le_si64(-9223372036854775807, -1328271339354574848), true);
+        assert_eq!(le_si64(-9223372036854775807, 0), true);
+        assert_eq!(le_si64(-9223372036854775807, 1), true);
+        assert_eq!(le_si64(-9223372036854775807, 2), true);
+        assert_eq!(le_si64(-9223372036854775807, 3), true);
+        assert_eq!(le_si64(-9223372036854775807, 4), true);
+    }
+    #[test]
+    fn test_317() {
+        assert_eq!(le_si64(-9223372036854775807, 5577148965131116544), true);
+        assert_eq!(le_si64(-9223372036854775807, 9223372036854775806), true);
+        assert_eq!(le_si64(-9223372036854775807, 9223372036854775807), true);
+        assert_eq!(le_si64(-1741927215160008704, -1741927215160008704), true);
+        assert_eq!(le_si64(-1741927215160008704, -1328271339354574848), true);
+        assert_eq!(le_si64(-1741927215160008704, 0), true);
+        assert_eq!(le_si64(-1741927215160008704, 1), true);
+        assert_eq!(le_si64(-1741927215160008704, 2), true);
+        assert_eq!(le_si64(-1741927215160008704, 3), true);
+        assert_eq!(le_si64(-1741927215160008704, 4), true);
+    }
+    #[test]
+    fn test_318() {
+        assert_eq!(le_si64(-1741927215160008704, 5577148965131116544), true);
+        assert_eq!(le_si64(-1741927215160008704, 9223372036854775806), true);
+        assert_eq!(le_si64(-1741927215160008704, 9223372036854775807), true);
+        assert_eq!(le_si64(-1328271339354574848, -1328271339354574848), true);
+        assert_eq!(le_si64(-1328271339354574848, 0), true);
+        assert_eq!(le_si64(-1328271339354574848, 1), true);
+        assert_eq!(le_si64(-1328271339354574848, 2), true);
+        assert_eq!(le_si64(-1328271339354574848, 3), true);
+        assert_eq!(le_si64(-1328271339354574848, 4), true);
+        assert_eq!(le_si64(-1328271339354574848, 5577148965131116544), true);
+    }
+    #[test]
+    fn test_319() {
+        assert_eq!(le_si64(-1328271339354574848, 9223372036854775806), true);
+        assert_eq!(le_si64(-1328271339354574848, 9223372036854775807), true);
+        assert_eq!(le_si64(0, 0), true);
+        assert_eq!(le_si64(0, 1), true);
+        assert_eq!(le_si64(0, 2), true);
+        assert_eq!(le_si64(0, 3), true);
+        assert_eq!(le_si64(0, 4), true);
+        assert_eq!(le_si64(0, 5577148965131116544), true);
+        assert_eq!(le_si64(0, 9223372036854775806), true);
+        assert_eq!(le_si64(0, 9223372036854775807), true);
+    }
+    #[test]
+    fn test_320() {
+        assert_eq!(le_si64(1, 1), true);
+        assert_eq!(le_si64(1, 2), true);
+        assert_eq!(le_si64(1, 3), true);
+        assert_eq!(le_si64(1, 4), true);
+        assert_eq!(le_si64(1, 5577148965131116544), true);
+        assert_eq!(le_si64(1, 9223372036854775806), true);
+        assert_eq!(le_si64(1, 9223372036854775807), true);
+        assert_eq!(le_si64(2, 2), true);
+        assert_eq!(le_si64(2, 3), true);
+        assert_eq!(le_si64(2, 4), true);
+    }
+    #[test]
+    fn test_321() {
+        assert_eq!(le_si64(2, 5577148965131116544), true);
+        assert_eq!(le_si64(2, 9223372036854775806), true);
+        assert_eq!(le_si64(2, 9223372036854775807), true);
+        assert_eq!(le_si64(3, 3), true);
+        assert_eq!(le_si64(3, 4), true);
+        assert_eq!(le_si64(3, 5577148965131116544), true);
+        assert_eq!(le_si64(3, 9223372036854775806), true);
+        assert_eq!(le_si64(3, 9223372036854775807), true);
+        assert_eq!(le_si64(4, 4), true);
+        assert_eq!(le_si64(4, 5577148965131116544), true);
+    }
+    #[test]
+    fn test_322() {
+        assert_eq!(le_si64(4, 9223372036854775806), true);
+        assert_eq!(le_si64(4, 9223372036854775807), true);
+        assert_eq!(le_si64(5577148965131116544, 5577148965131116544), true);
+        assert_eq!(le_si64(5577148965131116544, 9223372036854775806), true);
+        assert_eq!(le_si64(5577148965131116544, 9223372036854775807), true);
+        assert_eq!(le_si64(9223372036854775806, 9223372036854775806), true);
+        assert_eq!(le_si64(9223372036854775806, 9223372036854775807), true);
+        assert_eq!(le_si64(9223372036854775807, 9223372036854775807), true);
+        assert_eq!(le_si8(-127, -128), false);
+        assert_eq!(le_si8(0, -128), false);
+    }
+    #[test]
+    fn test_323() {
+        assert_eq!(le_si8(0, -127), false);
+        assert_eq!(le_si8(1, -128), false);
+        assert_eq!(le_si8(1, -127), false);
+        assert_eq!(le_si8(1, 0), false);
+        assert_eq!(le_si8(2, -128), false);
+        assert_eq!(le_si8(2, -127), false);
+        assert_eq!(le_si8(2, 0), false);
+        assert_eq!(le_si8(2, 1), false);
+        assert_eq!(le_si8(3, -128), false);
+        assert_eq!(le_si8(3, -127), false);
+    }
+    #[test]
+    fn test_324() {
+        assert_eq!(le_si8(3, 0), false);
+        assert_eq!(le_si8(3, 1), false);
+        assert_eq!(le_si8(3, 2), false);
+        assert_eq!(le_si8(4, -128), false);
+        assert_eq!(le_si8(4, -127), false);
+        assert_eq!(le_si8(4, 0), false);
+        assert_eq!(le_si8(4, 1), false);
+        assert_eq!(le_si8(4, 2), false);
+        assert_eq!(le_si8(4, 3), false);
+        assert_eq!(le_si8(16, -128), false);
+    }
+    #[test]
+    fn test_325() {
+        assert_eq!(le_si8(16, -127), false);
+        assert_eq!(le_si8(16, 0), false);
+        assert_eq!(le_si8(16, 1), false);
+        assert_eq!(le_si8(16, 2), false);
+        assert_eq!(le_si8(16, 3), false);
+        assert_eq!(le_si8(16, 4), false);
+        assert_eq!(le_si8(126, -128), false);
+        assert_eq!(le_si8(126, -127), false);
+        assert_eq!(le_si8(126, 0), false);
+        assert_eq!(le_si8(126, 1), false);
+    }
+    #[test]
+    fn test_326() {
+        assert_eq!(le_si8(126, 2), false);
+        assert_eq!(le_si8(126, 3), false);
+        assert_eq!(le_si8(126, 4), false);
+        assert_eq!(le_si8(126, 16), false);
+        assert_eq!(le_si8(127, -128), false);
+        assert_eq!(le_si8(127, -127), false);
+        assert_eq!(le_si8(127, 0), false);
+        assert_eq!(le_si8(127, 1), false);
+        assert_eq!(le_si8(127, 2), false);
+        assert_eq!(le_si8(127, 3), false);
+    }
+    #[test]
+    fn test_327() {
+        assert_eq!(le_si8(127, 4), false);
+        assert_eq!(le_si8(127, 16), false);
+        assert_eq!(le_si8(127, 126), false);
+        assert_eq!(le_si8(-128, -128), true);
+        assert_eq!(le_si8(-128, -127), true);
+        assert_eq!(le_si8(-128, 0), true);
+        assert_eq!(le_si8(-128, 1), true);
+        assert_eq!(le_si8(-128, 2), true);
+        assert_eq!(le_si8(-128, 3), true);
+        assert_eq!(le_si8(-128, 4), true);
+    }
+    #[test]
+    fn test_328() {
+        assert_eq!(le_si8(-128, 16), true);
+        assert_eq!(le_si8(-128, 126), true);
+        assert_eq!(le_si8(-128, 127), true);
+        assert_eq!(le_si8(-127, -127), true);
+        assert_eq!(le_si8(-127, 0), true);
+        assert_eq!(le_si8(-127, 1), true);
+        assert_eq!(le_si8(-127, 2), true);
+        assert_eq!(le_si8(-127, 3), true);
+        assert_eq!(le_si8(-127, 4), true);
+        assert_eq!(le_si8(-127, 16), true);
+    }
+    #[test]
+    fn test_329() {
+        assert_eq!(le_si8(-127, 126), true);
+        assert_eq!(le_si8(-127, 127), true);
+        assert_eq!(le_si8(0, 0), true);
+        assert_eq!(le_si8(0, 1), true);
+        assert_eq!(le_si8(0, 2), true);
+        assert_eq!(le_si8(0, 3), true);
+        assert_eq!(le_si8(0, 4), true);
+        assert_eq!(le_si8(0, 16), true);
+        assert_eq!(le_si8(0, 126), true);
+        assert_eq!(le_si8(0, 127), true);
+    }
+    #[test]
+    fn test_330() {
+        assert_eq!(le_si8(1, 1), true);
+        assert_eq!(le_si8(1, 2), true);
+        assert_eq!(le_si8(1, 3), true);
+        assert_eq!(le_si8(1, 4), true);
+        assert_eq!(le_si8(1, 16), true);
+        assert_eq!(le_si8(1, 126), true);
+        assert_eq!(le_si8(1, 127), true);
+        assert_eq!(le_si8(2, 2), true);
+        assert_eq!(le_si8(2, 3), true);
+        assert_eq!(le_si8(2, 4), true);
+    }
+    #[test]
+    fn test_331() {
+        assert_eq!(le_si8(2, 16), true);
+        assert_eq!(le_si8(2, 126), true);
+        assert_eq!(le_si8(2, 127), true);
+        assert_eq!(le_si8(3, 3), true);
+        assert_eq!(le_si8(3, 4), true);
+        assert_eq!(le_si8(3, 16), true);
+        assert_eq!(le_si8(3, 126), true);
+        assert_eq!(le_si8(3, 127), true);
+        assert_eq!(le_si8(4, 4), true);
+        assert_eq!(le_si8(4, 16), true);
+    }
+    #[test]
+    fn test_332() {
+        assert_eq!(le_si8(4, 126), true);
+        assert_eq!(le_si8(4, 127), true);
+        assert_eq!(le_si8(16, 16), true);
+        assert_eq!(le_si8(16, 126), true);
+        assert_eq!(le_si8(16, 127), true);
+        assert_eq!(le_si8(126, 126), true);
+        assert_eq!(le_si8(126, 127), true);
+        assert_eq!(le_si8(127, 127), true);
+        assert_eq!(le_ui16(1, 0), false);
+        assert_eq!(le_ui16(2, 0), false);
+    }
+    #[test]
+    fn test_333() {
+        assert_eq!(le_ui16(2, 1), false);
+        assert_eq!(le_ui16(3, 0), false);
+        assert_eq!(le_ui16(3, 1), false);
+        assert_eq!(le_ui16(3, 2), false);
+        assert_eq!(le_ui16(4, 0), false);
+        assert_eq!(le_ui16(4, 1), false);
+        assert_eq!(le_ui16(4, 2), false);
+        assert_eq!(le_ui16(4, 3), false);
+        assert_eq!(le_ui16(1717, 0), false);
+        assert_eq!(le_ui16(1717, 1), false);
+    }
+    #[test]
+    fn test_334() {
+        assert_eq!(le_ui16(1717, 2), false);
+        assert_eq!(le_ui16(1717, 3), false);
+        assert_eq!(le_ui16(1717, 4), false);
+        assert_eq!(le_ui16(17988, 0), false);
+        assert_eq!(le_ui16(17988, 1), false);
+        assert_eq!(le_ui16(17988, 2), false);
+        assert_eq!(le_ui16(17988, 3), false);
+        assert_eq!(le_ui16(17988, 4), false);
+        assert_eq!(le_ui16(17988, 1717), false);
+        assert_eq!(le_ui16(65096, 0), false);
+    }
+    #[test]
+    fn test_335() {
+        assert_eq!(le_ui16(65096, 1), false);
+        assert_eq!(le_ui16(65096, 2), false);
+        assert_eq!(le_ui16(65096, 3), false);
+        assert_eq!(le_ui16(65096, 4), false);
+        assert_eq!(le_ui16(65096, 1717), false);
+        assert_eq!(le_ui16(65096, 17988), false);
+        assert_eq!(le_ui16(65534, 0), false);
+        assert_eq!(le_ui16(65534, 1), false);
+        assert_eq!(le_ui16(65534, 2), false);
+        assert_eq!(le_ui16(65534, 3), false);
+    }
+    #[test]
+    fn test_336() {
+        assert_eq!(le_ui16(65534, 4), false);
+        assert_eq!(le_ui16(65534, 1717), false);
+        assert_eq!(le_ui16(65534, 17988), false);
+        assert_eq!(le_ui16(65534, 65096), false);
+        assert_eq!(le_ui16(65535, 0), false);
+        assert_eq!(le_ui16(65535, 1), false);
+        assert_eq!(le_ui16(65535, 2), false);
+        assert_eq!(le_ui16(65535, 3), false);
+        assert_eq!(le_ui16(65535, 4), false);
+        assert_eq!(le_ui16(65535, 1717), false);
+    }
+    #[test]
+    fn test_337() {
+        assert_eq!(le_ui16(65535, 17988), false);
+        assert_eq!(le_ui16(65535, 65096), false);
+        assert_eq!(le_ui16(65535, 65534), false);
+        assert_eq!(le_ui16(0, 0), true);
+        assert_eq!(le_ui16(0, 1), true);
+        assert_eq!(le_ui16(0, 2), true);
+        assert_eq!(le_ui16(0, 3), true);
+        assert_eq!(le_ui16(0, 4), true);
+        assert_eq!(le_ui16(0, 1717), true);
+        assert_eq!(le_ui16(0, 17988), true);
+    }
+    #[test]
+    fn test_338() {
+        assert_eq!(le_ui16(0, 65096), true);
+        assert_eq!(le_ui16(0, 65534), true);
+        assert_eq!(le_ui16(0, 65535), true);
+        assert_eq!(le_ui16(1, 1), true);
+        assert_eq!(le_ui16(1, 2), true);
+        assert_eq!(le_ui16(1, 3), true);
+        assert_eq!(le_ui16(1, 4), true);
+        assert_eq!(le_ui16(1, 1717), true);
+        assert_eq!(le_ui16(1, 17988), true);
+        assert_eq!(le_ui16(1, 65096), true);
+    }
+    #[test]
+    fn test_339() {
+        assert_eq!(le_ui16(1, 65534), true);
+        assert_eq!(le_ui16(1, 65535), true);
+        assert_eq!(le_ui16(2, 2), true);
+        assert_eq!(le_ui16(2, 3), true);
+        assert_eq!(le_ui16(2, 4), true);
+        assert_eq!(le_ui16(2, 1717), true);
+        assert_eq!(le_ui16(2, 17988), true);
+        assert_eq!(le_ui16(2, 65096), true);
+        assert_eq!(le_ui16(2, 65534), true);
+        assert_eq!(le_ui16(2, 65535), true);
+    }
+    #[test]
+    fn test_340() {
+        assert_eq!(le_ui16(3, 3), true);
+        assert_eq!(le_ui16(3, 4), true);
+        assert_eq!(le_ui16(3, 1717), true);
+        assert_eq!(le_ui16(3, 17988), true);
+        assert_eq!(le_ui16(3, 65096), true);
+        assert_eq!(le_ui16(3, 65534), true);
+        assert_eq!(le_ui16(3, 65535), true);
+        assert_eq!(le_ui16(4, 4), true);
+        assert_eq!(le_ui16(4, 1717), true);
+        assert_eq!(le_ui16(4, 17988), true);
+    }
+    #[test]
+    fn test_341() {
+        assert_eq!(le_ui16(4, 65096), true);
+        assert_eq!(le_ui16(4, 65534), true);
+        assert_eq!(le_ui16(4, 65535), true);
+        assert_eq!(le_ui16(1717, 1717), true);
+        assert_eq!(le_ui16(1717, 17988), true);
+        assert_eq!(le_ui16(1717, 65096), true);
+        assert_eq!(le_ui16(1717, 65534), true);
+        assert_eq!(le_ui16(1717, 65535), true);
+        assert_eq!(le_ui16(17988, 17988), true);
+        assert_eq!(le_ui16(17988, 65096), true);
+    }
+    #[test]
+    fn test_342() {
+        assert_eq!(le_ui16(17988, 65534), true);
+        assert_eq!(le_ui16(17988, 65535), true);
+        assert_eq!(le_ui16(65096, 65096), true);
+        assert_eq!(le_ui16(65096, 65534), true);
+        assert_eq!(le_ui16(65096, 65535), true);
+        assert_eq!(le_ui16(65534, 65534), true);
+        assert_eq!(le_ui16(65534, 65535), true);
+        assert_eq!(le_ui16(65535, 65535), true);
+        assert_eq!(le_ui32(1, 0), false);
+        assert_eq!(le_ui32(2, 0), false);
+    }
+    #[test]
+    fn test_343() {
+        assert_eq!(le_ui32(2, 1), false);
+        assert_eq!(le_ui32(3, 0), false);
+        assert_eq!(le_ui32(3, 1), false);
+        assert_eq!(le_ui32(3, 2), false);
+        assert_eq!(le_ui32(4, 0), false);
+        assert_eq!(le_ui32(4, 1), false);
+        assert_eq!(le_ui32(4, 2), false);
+        assert_eq!(le_ui32(4, 3), false);
+        assert_eq!(le_ui32(2119154652, 0), false);
+        assert_eq!(le_ui32(2119154652, 1), false);
+    }
+    #[test]
+    fn test_344() {
+        assert_eq!(le_ui32(2119154652, 2), false);
+        assert_eq!(le_ui32(2119154652, 3), false);
+        assert_eq!(le_ui32(2119154652, 4), false);
+        assert_eq!(le_ui32(3002788344, 0), false);
+        assert_eq!(le_ui32(3002788344, 1), false);
+        assert_eq!(le_ui32(3002788344, 2), false);
+        assert_eq!(le_ui32(3002788344, 3), false);
+        assert_eq!(le_ui32(3002788344, 4), false);
+        assert_eq!(le_ui32(3002788344, 2119154652), false);
+        assert_eq!(le_ui32(3482297128, 0), false);
+    }
+    #[test]
+    fn test_345() {
+        assert_eq!(le_ui32(3482297128, 1), false);
+        assert_eq!(le_ui32(3482297128, 2), false);
+        assert_eq!(le_ui32(3482297128, 3), false);
+        assert_eq!(le_ui32(3482297128, 4), false);
+        assert_eq!(le_ui32(3482297128, 2119154652), false);
+        assert_eq!(le_ui32(3482297128, 3002788344), false);
+        assert_eq!(le_ui32(4294967294, 0), false);
+        assert_eq!(le_ui32(4294967294, 1), false);
+        assert_eq!(le_ui32(4294967294, 2), false);
+        assert_eq!(le_ui32(4294967294, 3), false);
+    }
+    #[test]
+    fn test_346() {
+        assert_eq!(le_ui32(4294967294, 4), false);
+        assert_eq!(le_ui32(4294967294, 2119154652), false);
+        assert_eq!(le_ui32(4294967294, 3002788344), false);
+        assert_eq!(le_ui32(4294967294, 3482297128), false);
+        assert_eq!(le_ui32(4294967295, 0), false);
+        assert_eq!(le_ui32(4294967295, 1), false);
+        assert_eq!(le_ui32(4294967295, 2), false);
+        assert_eq!(le_ui32(4294967295, 3), false);
+        assert_eq!(le_ui32(4294967295, 4), false);
+        assert_eq!(le_ui32(4294967295, 2119154652), false);
+    }
+    #[test]
+    fn test_347() {
+        assert_eq!(le_ui32(4294967295, 3002788344), false);
+        assert_eq!(le_ui32(4294967295, 3482297128), false);
+        assert_eq!(le_ui32(4294967295, 4294967294), false);
+        assert_eq!(le_ui32(0, 0), true);
+        assert_eq!(le_ui32(0, 1), true);
+        assert_eq!(le_ui32(0, 2), true);
+        assert_eq!(le_ui32(0, 3), true);
+        assert_eq!(le_ui32(0, 4), true);
+        assert_eq!(le_ui32(0, 2119154652), true);
+        assert_eq!(le_ui32(0, 3002788344), true);
+    }
+    #[test]
+    fn test_348() {
+        assert_eq!(le_ui32(0, 3482297128), true);
+        assert_eq!(le_ui32(0, 4294967294), true);
+        assert_eq!(le_ui32(0, 4294967295), true);
+        assert_eq!(le_ui32(1, 1), true);
+        assert_eq!(le_ui32(1, 2), true);
+        assert_eq!(le_ui32(1, 3), true);
+        assert_eq!(le_ui32(1, 4), true);
+        assert_eq!(le_ui32(1, 2119154652), true);
+        assert_eq!(le_ui32(1, 3002788344), true);
+        assert_eq!(le_ui32(1, 3482297128), true);
+    }
+    #[test]
+    fn test_349() {
+        assert_eq!(le_ui32(1, 4294967294), true);
+        assert_eq!(le_ui32(1, 4294967295), true);
+        assert_eq!(le_ui32(2, 2), true);
+        assert_eq!(le_ui32(2, 3), true);
+        assert_eq!(le_ui32(2, 4), true);
+        assert_eq!(le_ui32(2, 2119154652), true);
+        assert_eq!(le_ui32(2, 3002788344), true);
+        assert_eq!(le_ui32(2, 3482297128), true);
+        assert_eq!(le_ui32(2, 4294967294), true);
+        assert_eq!(le_ui32(2, 4294967295), true);
+    }
+    #[test]
+    fn test_350() {
+        assert_eq!(le_ui32(3, 3), true);
+        assert_eq!(le_ui32(3, 4), true);
+        assert_eq!(le_ui32(3, 2119154652), true);
+        assert_eq!(le_ui32(3, 3002788344), true);
+        assert_eq!(le_ui32(3, 3482297128), true);
+        assert_eq!(le_ui32(3, 4294967294), true);
+        assert_eq!(le_ui32(3, 4294967295), true);
+        assert_eq!(le_ui32(4, 4), true);
+        assert_eq!(le_ui32(4, 2119154652), true);
+        assert_eq!(le_ui32(4, 3002788344), true);
+    }
+    #[test]
+    fn test_351() {
+        assert_eq!(le_ui32(4, 3482297128), true);
+        assert_eq!(le_ui32(4, 4294967294), true);
+        assert_eq!(le_ui32(4, 4294967295), true);
+        assert_eq!(le_ui32(2119154652, 2119154652), true);
+        assert_eq!(le_ui32(2119154652, 3002788344), true);
+        assert_eq!(le_ui32(2119154652, 3482297128), true);
+        assert_eq!(le_ui32(2119154652, 4294967294), true);
+        assert_eq!(le_ui32(2119154652, 4294967295), true);
+        assert_eq!(le_ui32(3002788344, 3002788344), true);
+        assert_eq!(le_ui32(3002788344, 3482297128), true);
+    }
+    #[test]
+    fn test_352() {
+        assert_eq!(le_ui32(3002788344, 4294967294), true);
+        assert_eq!(le_ui32(3002788344, 4294967295), true);
+        assert_eq!(le_ui32(3482297128, 3482297128), true);
+        assert_eq!(le_ui32(3482297128, 4294967294), true);
+        assert_eq!(le_ui32(3482297128, 4294967295), true);
+        assert_eq!(le_ui32(4294967294, 4294967294), true);
+        assert_eq!(le_ui32(4294967294, 4294967295), true);
+        assert_eq!(le_ui32(4294967295, 4294967295), true);
+        assert_eq!(le_ui64(1, 0), false);
+        assert_eq!(le_ui64(2, 0), false);
+    }
+    #[test]
+    fn test_353() {
+        assert_eq!(le_ui64(2, 1), false);
+        assert_eq!(le_ui64(3, 0), false);
+        assert_eq!(le_ui64(3, 1), false);
+        assert_eq!(le_ui64(3, 2), false);
+        assert_eq!(le_ui64(4, 0), false);
+        assert_eq!(le_ui64(4, 1), false);
+        assert_eq!(le_ui64(4, 2), false);
+        assert_eq!(le_ui64(4, 3), false);
+        assert_eq!(le_ui64(191084152064409600, 0), false);
+        assert_eq!(le_ui64(191084152064409600, 1), false);
+    }
+    #[test]
+    fn test_354() {
+        assert_eq!(le_ui64(191084152064409600, 2), false);
+        assert_eq!(le_ui64(191084152064409600, 3), false);
+        assert_eq!(le_ui64(191084152064409600, 4), false);
+        assert_eq!(le_ui64(11015955194427482112, 0), false);
+        assert_eq!(le_ui64(11015955194427482112, 1), false);
+        assert_eq!(le_ui64(11015955194427482112, 2), false);
+        assert_eq!(le_ui64(11015955194427482112, 3), false);
+        assert_eq!(le_ui64(11015955194427482112, 4), false);
+        assert_eq!(le_ui64(11015955194427482112, 191084152064409600), false);
+        assert_eq!(le_ui64(16990600415051759616, 0), false);
+    }
+    #[test]
+    fn test_355() {
+        assert_eq!(le_ui64(16990600415051759616, 1), false);
+        assert_eq!(le_ui64(16990600415051759616, 2), false);
+        assert_eq!(le_ui64(16990600415051759616, 3), false);
+        assert_eq!(le_ui64(16990600415051759616, 4), false);
+        assert_eq!(le_ui64(16990600415051759616, 191084152064409600), false);
+        assert_eq!(le_ui64(16990600415051759616, 11015955194427482112), false);
+        assert_eq!(le_ui64(18446744073709551614, 0), false);
+        assert_eq!(le_ui64(18446744073709551614, 1), false);
+        assert_eq!(le_ui64(18446744073709551614, 2), false);
+        assert_eq!(le_ui64(18446744073709551614, 3), false);
+    }
+    #[test]
+    fn test_356() {
+        assert_eq!(le_ui64(18446744073709551614, 4), false);
+        assert_eq!(le_ui64(18446744073709551614, 191084152064409600), false);
+        assert_eq!(le_ui64(18446744073709551614, 11015955194427482112), false);
+        assert_eq!(le_ui64(18446744073709551614, 16990600415051759616), false);
+        assert_eq!(le_ui64(18446744073709551615, 0), false);
+        assert_eq!(le_ui64(18446744073709551615, 1), false);
+        assert_eq!(le_ui64(18446744073709551615, 2), false);
+        assert_eq!(le_ui64(18446744073709551615, 3), false);
+        assert_eq!(le_ui64(18446744073709551615, 4), false);
+        assert_eq!(le_ui64(18446744073709551615, 191084152064409600), false);
+    }
+    #[test]
+    fn test_357() {
+        assert_eq!(le_ui64(18446744073709551615, 11015955194427482112), false);
+        assert_eq!(le_ui64(18446744073709551615, 16990600415051759616), false);
+        assert_eq!(le_ui64(18446744073709551615, 18446744073709551614), false);
+        assert_eq!(le_ui64(0, 0), true);
+        assert_eq!(le_ui64(0, 1), true);
+        assert_eq!(le_ui64(0, 2), true);
+        assert_eq!(le_ui64(0, 3), true);
+        assert_eq!(le_ui64(0, 4), true);
+        assert_eq!(le_ui64(0, 191084152064409600), true);
+        assert_eq!(le_ui64(0, 11015955194427482112), true);
+    }
+    #[test]
+    fn test_358() {
+        assert_eq!(le_ui64(0, 16990600415051759616), true);
+        assert_eq!(le_ui64(0, 18446744073709551614), true);
+        assert_eq!(le_ui64(0, 18446744073709551615), true);
+        assert_eq!(le_ui64(1, 1), true);
+        assert_eq!(le_ui64(1, 2), true);
+        assert_eq!(le_ui64(1, 3), true);
+        assert_eq!(le_ui64(1, 4), true);
+        assert_eq!(le_ui64(1, 191084152064409600), true);
+        assert_eq!(le_ui64(1, 11015955194427482112), true);
+        assert_eq!(le_ui64(1, 16990600415051759616), true);
+    }
+    #[test]
+    fn test_359() {
+        assert_eq!(le_ui64(1, 18446744073709551614), true);
+        assert_eq!(le_ui64(1, 18446744073709551615), true);
+        assert_eq!(le_ui64(2, 2), true);
+        assert_eq!(le_ui64(2, 3), true);
+        assert_eq!(le_ui64(2, 4), true);
+        assert_eq!(le_ui64(2, 191084152064409600), true);
+        assert_eq!(le_ui64(2, 11015955194427482112), true);
+        assert_eq!(le_ui64(2, 16990600415051759616), true);
+        assert_eq!(le_ui64(2, 18446744073709551614), true);
+        assert_eq!(le_ui64(2, 18446744073709551615), true);
+    }
+    #[test]
+    fn test_360() {
+        assert_eq!(le_ui64(3, 3), true);
+        assert_eq!(le_ui64(3, 4), true);
+        assert_eq!(le_ui64(3, 191084152064409600), true);
+        assert_eq!(le_ui64(3, 11015955194427482112), true);
+        assert_eq!(le_ui64(3, 16990600415051759616), true);
+        assert_eq!(le_ui64(3, 18446744073709551614), true);
+        assert_eq!(le_ui64(3, 18446744073709551615), true);
+        assert_eq!(le_ui64(4, 4), true);
+        assert_eq!(le_ui64(4, 191084152064409600), true);
+        assert_eq!(le_ui64(4, 11015955194427482112), true);
+    }
+    #[test]
+    fn test_361() {
+        assert_eq!(le_ui64(4, 16990600415051759616), true);
+        assert_eq!(le_ui64(4, 18446744073709551614), true);
+        assert_eq!(le_ui64(4, 18446744073709551615), true);
+        assert_eq!(le_ui64(191084152064409600, 191084152064409600), true);
+        assert_eq!(le_ui64(191084152064409600, 11015955194427482112), true);
+        assert_eq!(le_ui64(191084152064409600, 16990600415051759616), true);
+        assert_eq!(le_ui64(191084152064409600, 18446744073709551614), true);
+        assert_eq!(le_ui64(191084152064409600, 18446744073709551615), true);
+        assert_eq!(le_ui64(11015955194427482112, 11015955194427482112), true);
+        assert_eq!(le_ui64(11015955194427482112, 16990600415051759616), true);
+    }
+    #[test]
+    fn test_362() {
+        assert_eq!(le_ui64(11015955194427482112, 18446744073709551614), true);
+        assert_eq!(le_ui64(11015955194427482112, 18446744073709551615), true);
+        assert_eq!(le_ui64(16990600415051759616, 16990600415051759616), true);
+        assert_eq!(le_ui64(16990600415051759616, 18446744073709551614), true);
+        assert_eq!(le_ui64(16990600415051759616, 18446744073709551615), true);
+        assert_eq!(le_ui64(18446744073709551614, 18446744073709551614), true);
+        assert_eq!(le_ui64(18446744073709551614, 18446744073709551615), true);
+        assert_eq!(le_ui64(18446744073709551615, 18446744073709551615), true);
+        assert_eq!(le_ui8(1, 0), false);
+        assert_eq!(le_ui8(2, 0), false);
+    }
+    #[test]
+    fn test_363() {
+        assert_eq!(le_ui8(2, 1), false);
+        assert_eq!(le_ui8(3, 0), false);
+        assert_eq!(le_ui8(3, 1), false);
+        assert_eq!(le_ui8(3, 2), false);
+        assert_eq!(le_ui8(4, 0), false);
+        assert_eq!(le_ui8(4, 1), false);
+        assert_eq!(le_ui8(4, 2), false);
+        assert_eq!(le_ui8(4, 3), false);
+        assert_eq!(le_ui8(72, 0), false);
+        assert_eq!(le_ui8(72, 1), false);
+    }
+    #[test]
+    fn test_364() {
+        assert_eq!(le_ui8(72, 2), false);
+        assert_eq!(le_ui8(72, 3), false);
+        assert_eq!(le_ui8(72, 4), false);
+        assert_eq!(le_ui8(100, 0), false);
+        assert_eq!(le_ui8(100, 1), false);
+        assert_eq!(le_ui8(100, 2), false);
+        assert_eq!(le_ui8(100, 3), false);
+        assert_eq!(le_ui8(100, 4), false);
+        assert_eq!(le_ui8(100, 72), false);
+        assert_eq!(le_ui8(162, 0), false);
+    }
+    #[test]
+    fn test_365() {
+        assert_eq!(le_ui8(162, 1), false);
+        assert_eq!(le_ui8(162, 2), false);
+        assert_eq!(le_ui8(162, 3), false);
+        assert_eq!(le_ui8(162, 4), false);
+        assert_eq!(le_ui8(162, 72), false);
+        assert_eq!(le_ui8(162, 100), false);
+        assert_eq!(le_ui8(254, 0), false);
+        assert_eq!(le_ui8(254, 1), false);
+        assert_eq!(le_ui8(254, 2), false);
+        assert_eq!(le_ui8(254, 3), false);
+    }
+    #[test]
+    fn test_366() {
+        assert_eq!(le_ui8(254, 4), false);
+        assert_eq!(le_ui8(254, 72), false);
+        assert_eq!(le_ui8(254, 100), false);
+        assert_eq!(le_ui8(254, 162), false);
+        assert_eq!(le_ui8(255, 0), false);
+        assert_eq!(le_ui8(255, 1), false);
+        assert_eq!(le_ui8(255, 2), false);
+        assert_eq!(le_ui8(255, 3), false);
+        assert_eq!(le_ui8(255, 4), false);
+        assert_eq!(le_ui8(255, 72), false);
+    }
+    #[test]
+    fn test_367() {
+        assert_eq!(le_ui8(255, 100), false);
+        assert_eq!(le_ui8(255, 162), false);
+        assert_eq!(le_ui8(255, 254), false);
+        assert_eq!(le_ui8(0, 0), true);
+        assert_eq!(le_ui8(0, 1), true);
+        assert_eq!(le_ui8(0, 2), true);
+        assert_eq!(le_ui8(0, 3), true);
+        assert_eq!(le_ui8(0, 4), true);
+        assert_eq!(le_ui8(0, 72), true);
+        assert_eq!(le_ui8(0, 100), true);
+    }
+    #[test]
+    fn test_368() {
+        assert_eq!(le_ui8(0, 162), true);
+        assert_eq!(le_ui8(0, 254), true);
+        assert_eq!(le_ui8(0, 255), true);
+        assert_eq!(le_ui8(1, 1), true);
+        assert_eq!(le_ui8(1, 2), true);
+        assert_eq!(le_ui8(1, 3), true);
+        assert_eq!(le_ui8(1, 4), true);
+        assert_eq!(le_ui8(1, 72), true);
+        assert_eq!(le_ui8(1, 100), true);
+        assert_eq!(le_ui8(1, 162), true);
+    }
+    #[test]
+    fn test_369() {
+        assert_eq!(le_ui8(1, 254), true);
+        assert_eq!(le_ui8(1, 255), true);
+        assert_eq!(le_ui8(2, 2), true);
+        assert_eq!(le_ui8(2, 3), true);
+        assert_eq!(le_ui8(2, 4), true);
+        assert_eq!(le_ui8(2, 72), true);
+        assert_eq!(le_ui8(2, 100), true);
+        assert_eq!(le_ui8(2, 162), true);
+        assert_eq!(le_ui8(2, 254), true);
+        assert_eq!(le_ui8(2, 255), true);
+    }
+    #[test]
+    fn test_370() {
+        assert_eq!(le_ui8(3, 3), true);
+        assert_eq!(le_ui8(3, 4), true);
+        assert_eq!(le_ui8(3, 72), true);
+        assert_eq!(le_ui8(3, 100), true);
+        assert_eq!(le_ui8(3, 162), true);
+        assert_eq!(le_ui8(3, 254), true);
+        assert_eq!(le_ui8(3, 255), true);
+        assert_eq!(le_ui8(4, 4), true);
+        assert_eq!(le_ui8(4, 72), true);
+        assert_eq!(le_ui8(4, 100), true);
+    }
+    #[test]
+    fn test_371() {
+        assert_eq!(le_ui8(4, 162), true);
+        assert_eq!(le_ui8(4, 254), true);
+        assert_eq!(le_ui8(4, 255), true);
+        assert_eq!(le_ui8(72, 72), true);
+        assert_eq!(le_ui8(72, 100), true);
+        assert_eq!(le_ui8(72, 162), true);
+        assert_eq!(le_ui8(72, 254), true);
+        assert_eq!(le_ui8(72, 255), true);
+        assert_eq!(le_ui8(100, 100), true);
+        assert_eq!(le_ui8(100, 162), true);
+    }
+    #[test]
+    fn test_372() {
+        assert_eq!(le_ui8(100, 254), true);
+        assert_eq!(le_ui8(100, 255), true);
+        assert_eq!(le_ui8(162, 162), true);
+        assert_eq!(le_ui8(162, 254), true);
+        assert_eq!(le_ui8(162, 255), true);
+        assert_eq!(le_ui8(254, 254), true);
+        assert_eq!(le_ui8(254, 255), true);
+        assert_eq!(le_ui8(255, 255), true);
+        assert_eq!(lt_si16(-32768, -32768), false);
+        assert_eq!(lt_si16(-32767, -32768), false);
+    }
+    #[test]
+    fn test_373() {
+        assert_eq!(lt_si16(-32767, -32767), false);
+        assert_eq!(lt_si16(-32547, -32768), false);
+        assert_eq!(lt_si16(-32547, -32767), false);
+        assert_eq!(lt_si16(-32547, -32547), false);
+        assert_eq!(lt_si16(0, -32768), false);
+        assert_eq!(lt_si16(0, -32767), false);
+        assert_eq!(lt_si16(0, -32547), false);
+        assert_eq!(lt_si16(0, 0), false);
+        assert_eq!(lt_si16(1, -32768), false);
+        assert_eq!(lt_si16(1, -32767), false);
+    }
+    #[test]
+    fn test_374() {
+        assert_eq!(lt_si16(1, -32547), false);
+        assert_eq!(lt_si16(1, 0), false);
+        assert_eq!(lt_si16(1, 1), false);
+        assert_eq!(lt_si16(2, -32768), false);
+        assert_eq!(lt_si16(2, -32767), false);
+        assert_eq!(lt_si16(2, -32547), false);
+        assert_eq!(lt_si16(2, 0), false);
+        assert_eq!(lt_si16(2, 1), false);
+        assert_eq!(lt_si16(2, 2), false);
+        assert_eq!(lt_si16(3, -32768), false);
+    }
+    #[test]
+    fn test_375() {
+        assert_eq!(lt_si16(3, -32767), false);
+        assert_eq!(lt_si16(3, -32547), false);
+        assert_eq!(lt_si16(3, 0), false);
+        assert_eq!(lt_si16(3, 1), false);
+        assert_eq!(lt_si16(3, 2), false);
+        assert_eq!(lt_si16(3, 3), false);
+        assert_eq!(lt_si16(4, -32768), false);
+        assert_eq!(lt_si16(4, -32767), false);
+        assert_eq!(lt_si16(4, -32547), false);
+        assert_eq!(lt_si16(4, 0), false);
+    }
+    #[test]
+    fn test_376() {
+        assert_eq!(lt_si16(4, 1), false);
+        assert_eq!(lt_si16(4, 2), false);
+        assert_eq!(lt_si16(4, 3), false);
+        assert_eq!(lt_si16(4, 4), false);
+        assert_eq!(lt_si16(10486, -32768), false);
+        assert_eq!(lt_si16(10486, -32767), false);
+        assert_eq!(lt_si16(10486, -32547), false);
+        assert_eq!(lt_si16(10486, 0), false);
+        assert_eq!(lt_si16(10486, 1), false);
+        assert_eq!(lt_si16(10486, 2), false);
+    }
+    #[test]
+    fn test_377() {
+        assert_eq!(lt_si16(10486, 3), false);
+        assert_eq!(lt_si16(10486, 4), false);
+        assert_eq!(lt_si16(10486, 10486), false);
+        assert_eq!(lt_si16(16514, -32768), false);
+        assert_eq!(lt_si16(16514, -32767), false);
+        assert_eq!(lt_si16(16514, -32547), false);
+        assert_eq!(lt_si16(16514, 0), false);
+        assert_eq!(lt_si16(16514, 1), false);
+        assert_eq!(lt_si16(16514, 2), false);
+        assert_eq!(lt_si16(16514, 3), false);
+    }
+    #[test]
+    fn test_378() {
+        assert_eq!(lt_si16(16514, 4), false);
+        assert_eq!(lt_si16(16514, 10486), false);
+        assert_eq!(lt_si16(16514, 16514), false);
+        assert_eq!(lt_si16(32766, -32768), false);
+        assert_eq!(lt_si16(32766, -32767), false);
+        assert_eq!(lt_si16(32766, -32547), false);
+        assert_eq!(lt_si16(32766, 0), false);
+        assert_eq!(lt_si16(32766, 1), false);
+        assert_eq!(lt_si16(32766, 2), false);
+        assert_eq!(lt_si16(32766, 3), false);
+    }
+    #[test]
+    fn test_379() {
+        assert_eq!(lt_si16(32766, 4), false);
+        assert_eq!(lt_si16(32766, 10486), false);
+        assert_eq!(lt_si16(32766, 16514), false);
+        assert_eq!(lt_si16(32766, 32766), false);
+        assert_eq!(lt_si16(32767, -32768), false);
+        assert_eq!(lt_si16(32767, -32767), false);
+        assert_eq!(lt_si16(32767, -32547), false);
+        assert_eq!(lt_si16(32767, 0), false);
+        assert_eq!(lt_si16(32767, 1), false);
+        assert_eq!(lt_si16(32767, 2), false);
+    }
+    #[test]
+    fn test_380() {
+        assert_eq!(lt_si16(32767, 3), false);
+        assert_eq!(lt_si16(32767, 4), false);
+        assert_eq!(lt_si16(32767, 10486), false);
+        assert_eq!(lt_si16(32767, 16514), false);
+        assert_eq!(lt_si16(32767, 32766), false);
+        assert_eq!(lt_si16(32767, 32767), false);
+        assert_eq!(lt_si16(-32768, -32767), true);
+        assert_eq!(lt_si16(-32768, -32547), true);
+        assert_eq!(lt_si16(-32768, 0), true);
+        assert_eq!(lt_si16(-32768, 1), true);
+    }
+    #[test]
+    fn test_381() {
+        assert_eq!(lt_si16(-32768, 2), true);
+        assert_eq!(lt_si16(-32768, 3), true);
+        assert_eq!(lt_si16(-32768, 4), true);
+        assert_eq!(lt_si16(-32768, 10486), true);
+        assert_eq!(lt_si16(-32768, 16514), true);
+        assert_eq!(lt_si16(-32768, 32766), true);
+        assert_eq!(lt_si16(-32768, 32767), true);
+        assert_eq!(lt_si16(-32767, -32547), true);
+        assert_eq!(lt_si16(-32767, 0), true);
+        assert_eq!(lt_si16(-32767, 1), true);
+    }
+    #[test]
+    fn test_382() {
+        assert_eq!(lt_si16(-32767, 2), true);
+        assert_eq!(lt_si16(-32767, 3), true);
+        assert_eq!(lt_si16(-32767, 4), true);
+        assert_eq!(lt_si16(-32767, 10486), true);
+        assert_eq!(lt_si16(-32767, 16514), true);
+        assert_eq!(lt_si16(-32767, 32766), true);
+        assert_eq!(lt_si16(-32767, 32767), true);
+        assert_eq!(lt_si16(-32547, 0), true);
+        assert_eq!(lt_si16(-32547, 1), true);
+        assert_eq!(lt_si16(-32547, 2), true);
+    }
+    #[test]
+    fn test_383() {
+        assert_eq!(lt_si16(-32547, 3), true);
+        assert_eq!(lt_si16(-32547, 4), true);
+        assert_eq!(lt_si16(-32547, 10486), true);
+        assert_eq!(lt_si16(-32547, 16514), true);
+        assert_eq!(lt_si16(-32547, 32766), true);
+        assert_eq!(lt_si16(-32547, 32767), true);
+        assert_eq!(lt_si16(0, 1), true);
+        assert_eq!(lt_si16(0, 2), true);
+        assert_eq!(lt_si16(0, 3), true);
+        assert_eq!(lt_si16(0, 4), true);
+    }
+    #[test]
+    fn test_384() {
+        assert_eq!(lt_si16(0, 10486), true);
+        assert_eq!(lt_si16(0, 16514), true);
+        assert_eq!(lt_si16(0, 32766), true);
+        assert_eq!(lt_si16(0, 32767), true);
+        assert_eq!(lt_si16(1, 2), true);
+        assert_eq!(lt_si16(1, 3), true);
+        assert_eq!(lt_si16(1, 4), true);
+        assert_eq!(lt_si16(1, 10486), true);
+        assert_eq!(lt_si16(1, 16514), true);
+        assert_eq!(lt_si16(1, 32766), true);
+    }
+    #[test]
+    fn test_385() {
+        assert_eq!(lt_si16(1, 32767), true);
+        assert_eq!(lt_si16(2, 3), true);
+        assert_eq!(lt_si16(2, 4), true);
+        assert_eq!(lt_si16(2, 10486), true);
+        assert_eq!(lt_si16(2, 16514), true);
+        assert_eq!(lt_si16(2, 32766), true);
+        assert_eq!(lt_si16(2, 32767), true);
+        assert_eq!(lt_si16(3, 4), true);
+        assert_eq!(lt_si16(3, 10486), true);
+        assert_eq!(lt_si16(3, 16514), true);
+    }
+    #[test]
+    fn test_386() {
+        assert_eq!(lt_si16(3, 32766), true);
+        assert_eq!(lt_si16(3, 32767), true);
+        assert_eq!(lt_si16(4, 10486), true);
+        assert_eq!(lt_si16(4, 16514), true);
+        assert_eq!(lt_si16(4, 32766), true);
+        assert_eq!(lt_si16(4, 32767), true);
+        assert_eq!(lt_si16(10486, 16514), true);
+        assert_eq!(lt_si16(10486, 32766), true);
+        assert_eq!(lt_si16(10486, 32767), true);
+        assert_eq!(lt_si16(16514, 32766), true);
+    }
+    #[test]
+    fn test_387() {
+        assert_eq!(lt_si16(16514, 32767), true);
+        assert_eq!(lt_si16(32766, 32767), true);
+        assert_eq!(lt_si32(-2147483648, -2147483648), false);
+        assert_eq!(lt_si32(-2147483647, -2147483648), false);
+        assert_eq!(lt_si32(-2147483647, -2147483647), false);
+        assert_eq!(lt_si32(-1713183800, -2147483648), false);
+        assert_eq!(lt_si32(-1713183800, -2147483647), false);
+        assert_eq!(lt_si32(-1713183800, -1713183800), false);
+        assert_eq!(lt_si32(-1252582164, -2147483648), false);
+        assert_eq!(lt_si32(-1252582164, -2147483647), false);
+    }
+    #[test]
+    fn test_388() {
+        assert_eq!(lt_si32(-1252582164, -1713183800), false);
+        assert_eq!(lt_si32(-1252582164, -1252582164), false);
+        assert_eq!(lt_si32(-1035405763, -2147483648), false);
+        assert_eq!(lt_si32(-1035405763, -2147483647), false);
+        assert_eq!(lt_si32(-1035405763, -1713183800), false);
+        assert_eq!(lt_si32(-1035405763, -1252582164), false);
+        assert_eq!(lt_si32(-1035405763, -1035405763), false);
+        assert_eq!(lt_si32(0, -2147483648), false);
+        assert_eq!(lt_si32(0, -2147483647), false);
+        assert_eq!(lt_si32(0, -1713183800), false);
+    }
+    #[test]
+    fn test_389() {
+        assert_eq!(lt_si32(0, -1252582164), false);
+        assert_eq!(lt_si32(0, -1035405763), false);
+        assert_eq!(lt_si32(0, 0), false);
+        assert_eq!(lt_si32(1, -2147483648), false);
+        assert_eq!(lt_si32(1, -2147483647), false);
+        assert_eq!(lt_si32(1, -1713183800), false);
+        assert_eq!(lt_si32(1, -1252582164), false);
+        assert_eq!(lt_si32(1, -1035405763), false);
+        assert_eq!(lt_si32(1, 0), false);
+        assert_eq!(lt_si32(1, 1), false);
+    }
+    #[test]
+    fn test_390() {
+        assert_eq!(lt_si32(2, -2147483648), false);
+        assert_eq!(lt_si32(2, -2147483647), false);
+        assert_eq!(lt_si32(2, -1713183800), false);
+        assert_eq!(lt_si32(2, -1252582164), false);
+        assert_eq!(lt_si32(2, -1035405763), false);
+        assert_eq!(lt_si32(2, 0), false);
+        assert_eq!(lt_si32(2, 1), false);
+        assert_eq!(lt_si32(2, 2), false);
+        assert_eq!(lt_si32(3, -2147483648), false);
+        assert_eq!(lt_si32(3, -2147483647), false);
+    }
+    #[test]
+    fn test_391() {
+        assert_eq!(lt_si32(3, -1713183800), false);
+        assert_eq!(lt_si32(3, -1252582164), false);
+        assert_eq!(lt_si32(3, -1035405763), false);
+        assert_eq!(lt_si32(3, 0), false);
+        assert_eq!(lt_si32(3, 1), false);
+        assert_eq!(lt_si32(3, 2), false);
+        assert_eq!(lt_si32(3, 3), false);
+        assert_eq!(lt_si32(4, -2147483648), false);
+        assert_eq!(lt_si32(4, -2147483647), false);
+        assert_eq!(lt_si32(4, -1713183800), false);
+    }
+    #[test]
+    fn test_392() {
+        assert_eq!(lt_si32(4, -1252582164), false);
+        assert_eq!(lt_si32(4, -1035405763), false);
+        assert_eq!(lt_si32(4, 0), false);
+        assert_eq!(lt_si32(4, 1), false);
+        assert_eq!(lt_si32(4, 2), false);
+        assert_eq!(lt_si32(4, 3), false);
+        assert_eq!(lt_si32(4, 4), false);
+        assert_eq!(lt_si32(2147483646, -2147483648), false);
+        assert_eq!(lt_si32(2147483646, -2147483647), false);
+        assert_eq!(lt_si32(2147483646, -1713183800), false);
+    }
+    #[test]
+    fn test_393() {
+        assert_eq!(lt_si32(2147483646, -1252582164), false);
+        assert_eq!(lt_si32(2147483646, -1035405763), false);
+        assert_eq!(lt_si32(2147483646, 0), false);
+        assert_eq!(lt_si32(2147483646, 1), false);
+        assert_eq!(lt_si32(2147483646, 2), false);
+        assert_eq!(lt_si32(2147483646, 3), false);
+        assert_eq!(lt_si32(2147483646, 4), false);
+        assert_eq!(lt_si32(2147483646, 2147483646), false);
+        assert_eq!(lt_si32(2147483647, -2147483648), false);
+        assert_eq!(lt_si32(2147483647, -2147483647), false);
+    }
+    #[test]
+    fn test_394() {
+        assert_eq!(lt_si32(2147483647, -1713183800), false);
+        assert_eq!(lt_si32(2147483647, -1252582164), false);
+        assert_eq!(lt_si32(2147483647, -1035405763), false);
+        assert_eq!(lt_si32(2147483647, 0), false);
+        assert_eq!(lt_si32(2147483647, 1), false);
+        assert_eq!(lt_si32(2147483647, 2), false);
+        assert_eq!(lt_si32(2147483647, 3), false);
+        assert_eq!(lt_si32(2147483647, 4), false);
+        assert_eq!(lt_si32(2147483647, 2147483646), false);
+        assert_eq!(lt_si32(2147483647, 2147483647), false);
+    }
+    #[test]
+    fn test_395() {
+        assert_eq!(lt_si32(-2147483648, -2147483647), true);
+        assert_eq!(lt_si32(-2147483648, -1713183800), true);
+        assert_eq!(lt_si32(-2147483648, -1252582164), true);
+        assert_eq!(lt_si32(-2147483648, -1035405763), true);
+        assert_eq!(lt_si32(-2147483648, 0), true);
+        assert_eq!(lt_si32(-2147483648, 1), true);
+        assert_eq!(lt_si32(-2147483648, 2), true);
+        assert_eq!(lt_si32(-2147483648, 3), true);
+        assert_eq!(lt_si32(-2147483648, 4), true);
+        assert_eq!(lt_si32(-2147483648, 2147483646), true);
+    }
+    #[test]
+    fn test_396() {
+        assert_eq!(lt_si32(-2147483648, 2147483647), true);
+        assert_eq!(lt_si32(-2147483647, -1713183800), true);
+        assert_eq!(lt_si32(-2147483647, -1252582164), true);
+        assert_eq!(lt_si32(-2147483647, -1035405763), true);
+        assert_eq!(lt_si32(-2147483647, 0), true);
+        assert_eq!(lt_si32(-2147483647, 1), true);
+        assert_eq!(lt_si32(-2147483647, 2), true);
+        assert_eq!(lt_si32(-2147483647, 3), true);
+        assert_eq!(lt_si32(-2147483647, 4), true);
+        assert_eq!(lt_si32(-2147483647, 2147483646), true);
+    }
+    #[test]
+    fn test_397() {
+        assert_eq!(lt_si32(-2147483647, 2147483647), true);
+        assert_eq!(lt_si32(-1713183800, -1252582164), true);
+        assert_eq!(lt_si32(-1713183800, -1035405763), true);
+        assert_eq!(lt_si32(-1713183800, 0), true);
+        assert_eq!(lt_si32(-1713183800, 1), true);
+        assert_eq!(lt_si32(-1713183800, 2), true);
+        assert_eq!(lt_si32(-1713183800, 3), true);
+        assert_eq!(lt_si32(-1713183800, 4), true);
+        assert_eq!(lt_si32(-1713183800, 2147483646), true);
+        assert_eq!(lt_si32(-1713183800, 2147483647), true);
+    }
+    #[test]
+    fn test_398() {
+        assert_eq!(lt_si32(-1252582164, -1035405763), true);
+        assert_eq!(lt_si32(-1252582164, 0), true);
+        assert_eq!(lt_si32(-1252582164, 1), true);
+        assert_eq!(lt_si32(-1252582164, 2), true);
+        assert_eq!(lt_si32(-1252582164, 3), true);
+        assert_eq!(lt_si32(-1252582164, 4), true);
+        assert_eq!(lt_si32(-1252582164, 2147483646), true);
+        assert_eq!(lt_si32(-1252582164, 2147483647), true);
+        assert_eq!(lt_si32(-1035405763, 0), true);
+        assert_eq!(lt_si32(-1035405763, 1), true);
+    }
+    #[test]
+    fn test_399() {
+        assert_eq!(lt_si32(-1035405763, 2), true);
+        assert_eq!(lt_si32(-1035405763, 3), true);
+        assert_eq!(lt_si32(-1035405763, 4), true);
+        assert_eq!(lt_si32(-1035405763, 2147483646), true);
+        assert_eq!(lt_si32(-1035405763, 2147483647), true);
+        assert_eq!(lt_si32(0, 1), true);
+        assert_eq!(lt_si32(0, 2), true);
+        assert_eq!(lt_si32(0, 3), true);
+        assert_eq!(lt_si32(0, 4), true);
+        assert_eq!(lt_si32(0, 2147483646), true);
+    }
+    #[test]
+    fn test_400() {
+        assert_eq!(lt_si32(0, 2147483647), true);
+        assert_eq!(lt_si32(1, 2), true);
+        assert_eq!(lt_si32(1, 3), true);
+        assert_eq!(lt_si32(1, 4), true);
+        assert_eq!(lt_si32(1, 2147483646), true);
+        assert_eq!(lt_si32(1, 2147483647), true);
+        assert_eq!(lt_si32(2, 3), true);
+        assert_eq!(lt_si32(2, 4), true);
+        assert_eq!(lt_si32(2, 2147483646), true);
+        assert_eq!(lt_si32(2, 2147483647), true);
+    }
+    #[test]
+    fn test_401() {
+        assert_eq!(lt_si32(3, 4), true);
+        assert_eq!(lt_si32(3, 2147483646), true);
+        assert_eq!(lt_si32(3, 2147483647), true);
+        assert_eq!(lt_si32(4, 2147483646), true);
+        assert_eq!(lt_si32(4, 2147483647), true);
+        assert_eq!(lt_si32(2147483646, 2147483647), true);
+        assert_eq!(lt_si64(-9223372036854775808, -9223372036854775808), false);
+        assert_eq!(lt_si64(-9223372036854775807, -9223372036854775808), false);
+        assert_eq!(lt_si64(-9223372036854775807, -9223372036854775807), false);
+        assert_eq!(lt_si64(-1741927215160008704, -9223372036854775808), false);
+    }
+    #[test]
+    fn test_402() {
+        assert_eq!(lt_si64(-1741927215160008704, -9223372036854775807), false);
+        assert_eq!(lt_si64(-1741927215160008704, -1741927215160008704), false);
+        assert_eq!(lt_si64(-1328271339354574848, -9223372036854775808), false);
+        assert_eq!(lt_si64(-1328271339354574848, -9223372036854775807), false);
+        assert_eq!(lt_si64(-1328271339354574848, -1741927215160008704), false);
+        assert_eq!(lt_si64(-1328271339354574848, -1328271339354574848), false);
+        assert_eq!(lt_si64(0, -9223372036854775808), false);
+        assert_eq!(lt_si64(0, -9223372036854775807), false);
+        assert_eq!(lt_si64(0, -1741927215160008704), false);
+        assert_eq!(lt_si64(0, -1328271339354574848), false);
+    }
+    #[test]
+    fn test_403() {
+        assert_eq!(lt_si64(0, 0), false);
+        assert_eq!(lt_si64(1, -9223372036854775808), false);
+        assert_eq!(lt_si64(1, -9223372036854775807), false);
+        assert_eq!(lt_si64(1, -1741927215160008704), false);
+        assert_eq!(lt_si64(1, -1328271339354574848), false);
+        assert_eq!(lt_si64(1, 0), false);
+        assert_eq!(lt_si64(1, 1), false);
+        assert_eq!(lt_si64(2, -9223372036854775808), false);
+        assert_eq!(lt_si64(2, -9223372036854775807), false);
+        assert_eq!(lt_si64(2, -1741927215160008704), false);
+    }
+    #[test]
+    fn test_404() {
+        assert_eq!(lt_si64(2, -1328271339354574848), false);
+        assert_eq!(lt_si64(2, 0), false);
+        assert_eq!(lt_si64(2, 1), false);
+        assert_eq!(lt_si64(2, 2), false);
+        assert_eq!(lt_si64(3, -9223372036854775808), false);
+        assert_eq!(lt_si64(3, -9223372036854775807), false);
+        assert_eq!(lt_si64(3, -1741927215160008704), false);
+        assert_eq!(lt_si64(3, -1328271339354574848), false);
+        assert_eq!(lt_si64(3, 0), false);
+        assert_eq!(lt_si64(3, 1), false);
+    }
+    #[test]
+    fn test_405() {
+        assert_eq!(lt_si64(3, 2), false);
+        assert_eq!(lt_si64(3, 3), false);
+        assert_eq!(lt_si64(4, -9223372036854775808), false);
+        assert_eq!(lt_si64(4, -9223372036854775807), false);
+        assert_eq!(lt_si64(4, -1741927215160008704), false);
+        assert_eq!(lt_si64(4, -1328271339354574848), false);
+        assert_eq!(lt_si64(4, 0), false);
+        assert_eq!(lt_si64(4, 1), false);
+        assert_eq!(lt_si64(4, 2), false);
+        assert_eq!(lt_si64(4, 3), false);
+    }
+    #[test]
+    fn test_406() {
+        assert_eq!(lt_si64(4, 4), false);
+        assert_eq!(lt_si64(5577148965131116544, -9223372036854775808), false);
+        assert_eq!(lt_si64(5577148965131116544, -9223372036854775807), false);
+        assert_eq!(lt_si64(5577148965131116544, -1741927215160008704), false);
+        assert_eq!(lt_si64(5577148965131116544, -1328271339354574848), false);
+        assert_eq!(lt_si64(5577148965131116544, 0), false);
+        assert_eq!(lt_si64(5577148965131116544, 1), false);
+        assert_eq!(lt_si64(5577148965131116544, 2), false);
+        assert_eq!(lt_si64(5577148965131116544, 3), false);
+        assert_eq!(lt_si64(5577148965131116544, 4), false);
+    }
+    #[test]
+    fn test_407() {
+        assert_eq!(lt_si64(5577148965131116544, 5577148965131116544), false);
+        assert_eq!(lt_si64(9223372036854775806, -9223372036854775808), false);
+        assert_eq!(lt_si64(9223372036854775806, -9223372036854775807), false);
+        assert_eq!(lt_si64(9223372036854775806, -1741927215160008704), false);
+        assert_eq!(lt_si64(9223372036854775806, -1328271339354574848), false);
+        assert_eq!(lt_si64(9223372036854775806, 0), false);
+        assert_eq!(lt_si64(9223372036854775806, 1), false);
+        assert_eq!(lt_si64(9223372036854775806, 2), false);
+        assert_eq!(lt_si64(9223372036854775806, 3), false);
+        assert_eq!(lt_si64(9223372036854775806, 4), false);
+    }
+    #[test]
+    fn test_408() {
+        assert_eq!(lt_si64(9223372036854775806, 5577148965131116544), false);
+        assert_eq!(lt_si64(9223372036854775806, 9223372036854775806), false);
+        assert_eq!(lt_si64(9223372036854775807, -9223372036854775808), false);
+        assert_eq!(lt_si64(9223372036854775807, -9223372036854775807), false);
+        assert_eq!(lt_si64(9223372036854775807, -1741927215160008704), false);
+        assert_eq!(lt_si64(9223372036854775807, -1328271339354574848), false);
+        assert_eq!(lt_si64(9223372036854775807, 0), false);
+        assert_eq!(lt_si64(9223372036854775807, 1), false);
+        assert_eq!(lt_si64(9223372036854775807, 2), false);
+        assert_eq!(lt_si64(9223372036854775807, 3), false);
+    }
+    #[test]
+    fn test_409() {
+        assert_eq!(lt_si64(9223372036854775807, 4), false);
+        assert_eq!(lt_si64(9223372036854775807, 5577148965131116544), false);
+        assert_eq!(lt_si64(9223372036854775807, 9223372036854775806), false);
+        assert_eq!(lt_si64(9223372036854775807, 9223372036854775807), false);
+        assert_eq!(lt_si64(-9223372036854775808, -9223372036854775807), true);
+        assert_eq!(lt_si64(-9223372036854775808, -1741927215160008704), true);
+        assert_eq!(lt_si64(-9223372036854775808, -1328271339354574848), true);
+        assert_eq!(lt_si64(-9223372036854775808, 0), true);
+        assert_eq!(lt_si64(-9223372036854775808, 1), true);
+        assert_eq!(lt_si64(-9223372036854775808, 2), true);
+    }
+    #[test]
+    fn test_410() {
+        assert_eq!(lt_si64(-9223372036854775808, 3), true);
+        assert_eq!(lt_si64(-9223372036854775808, 4), true);
+        assert_eq!(lt_si64(-9223372036854775808, 5577148965131116544), true);
+        assert_eq!(lt_si64(-9223372036854775808, 9223372036854775806), true);
+        assert_eq!(lt_si64(-9223372036854775808, 9223372036854775807), true);
+        assert_eq!(lt_si64(-9223372036854775807, -1741927215160008704), true);
+        assert_eq!(lt_si64(-9223372036854775807, -1328271339354574848), true);
+        assert_eq!(lt_si64(-9223372036854775807, 0), true);
+        assert_eq!(lt_si64(-9223372036854775807, 1), true);
+        assert_eq!(lt_si64(-9223372036854775807, 2), true);
+    }
+    #[test]
+    fn test_411() {
+        assert_eq!(lt_si64(-9223372036854775807, 3), true);
+        assert_eq!(lt_si64(-9223372036854775807, 4), true);
+        assert_eq!(lt_si64(-9223372036854775807, 5577148965131116544), true);
+        assert_eq!(lt_si64(-9223372036854775807, 9223372036854775806), true);
+        assert_eq!(lt_si64(-9223372036854775807, 9223372036854775807), true);
+        assert_eq!(lt_si64(-1741927215160008704, -1328271339354574848), true);
+        assert_eq!(lt_si64(-1741927215160008704, 0), true);
+        assert_eq!(lt_si64(-1741927215160008704, 1), true);
+        assert_eq!(lt_si64(-1741927215160008704, 2), true);
+        assert_eq!(lt_si64(-1741927215160008704, 3), true);
+    }
+    #[test]
+    fn test_412() {
+        assert_eq!(lt_si64(-1741927215160008704, 4), true);
+        assert_eq!(lt_si64(-1741927215160008704, 5577148965131116544), true);
+        assert_eq!(lt_si64(-1741927215160008704, 9223372036854775806), true);
+        assert_eq!(lt_si64(-1741927215160008704, 9223372036854775807), true);
+        assert_eq!(lt_si64(-1328271339354574848, 0), true);
+        assert_eq!(lt_si64(-1328271339354574848, 1), true);
+        assert_eq!(lt_si64(-1328271339354574848, 2), true);
+        assert_eq!(lt_si64(-1328271339354574848, 3), true);
+        assert_eq!(lt_si64(-1328271339354574848, 4), true);
+        assert_eq!(lt_si64(-1328271339354574848, 5577148965131116544), true);
+    }
+    #[test]
+    fn test_413() {
+        assert_eq!(lt_si64(-1328271339354574848, 9223372036854775806), true);
+        assert_eq!(lt_si64(-1328271339354574848, 9223372036854775807), true);
+        assert_eq!(lt_si64(0, 1), true);
+        assert_eq!(lt_si64(0, 2), true);
+        assert_eq!(lt_si64(0, 3), true);
+        assert_eq!(lt_si64(0, 4), true);
+        assert_eq!(lt_si64(0, 5577148965131116544), true);
+        assert_eq!(lt_si64(0, 9223372036854775806), true);
+        assert_eq!(lt_si64(0, 9223372036854775807), true);
+        assert_eq!(lt_si64(1, 2), true);
+    }
+    #[test]
+    fn test_414() {
+        assert_eq!(lt_si64(1, 3), true);
+        assert_eq!(lt_si64(1, 4), true);
+        assert_eq!(lt_si64(1, 5577148965131116544), true);
+        assert_eq!(lt_si64(1, 9223372036854775806), true);
+        assert_eq!(lt_si64(1, 9223372036854775807), true);
+        assert_eq!(lt_si64(2, 3), true);
+        assert_eq!(lt_si64(2, 4), true);
+        assert_eq!(lt_si64(2, 5577148965131116544), true);
+        assert_eq!(lt_si64(2, 9223372036854775806), true);
+        assert_eq!(lt_si64(2, 9223372036854775807), true);
+    }
+    #[test]
+    fn test_415() {
+        assert_eq!(lt_si64(3, 4), true);
+        assert_eq!(lt_si64(3, 5577148965131116544), true);
+        assert_eq!(lt_si64(3, 9223372036854775806), true);
+        assert_eq!(lt_si64(3, 9223372036854775807), true);
+        assert_eq!(lt_si64(4, 5577148965131116544), true);
+        assert_eq!(lt_si64(4, 9223372036854775806), true);
+        assert_eq!(lt_si64(4, 9223372036854775807), true);
+        assert_eq!(lt_si64(5577148965131116544, 9223372036854775806), true);
+        assert_eq!(lt_si64(5577148965131116544, 9223372036854775807), true);
+        assert_eq!(lt_si64(9223372036854775806, 9223372036854775807), true);
+    }
+    #[test]
+    fn test_416() {
+        assert_eq!(lt_si8(-128, -128), false);
+        assert_eq!(lt_si8(-127, -128), false);
+        assert_eq!(lt_si8(-127, -127), false);
+        assert_eq!(lt_si8(0, -128), false);
+        assert_eq!(lt_si8(0, -127), false);
+        assert_eq!(lt_si8(0, 0), false);
+        assert_eq!(lt_si8(1, -128), false);
+        assert_eq!(lt_si8(1, -127), false);
+        assert_eq!(lt_si8(1, 0), false);
+        assert_eq!(lt_si8(1, 1), false);
+    }
+    #[test]
+    fn test_417() {
+        assert_eq!(lt_si8(2, -128), false);
+        assert_eq!(lt_si8(2, -127), false);
+        assert_eq!(lt_si8(2, 0), false);
+        assert_eq!(lt_si8(2, 1), false);
+        assert_eq!(lt_si8(2, 2), false);
+        assert_eq!(lt_si8(3, -128), false);
+        assert_eq!(lt_si8(3, -127), false);
+        assert_eq!(lt_si8(3, 0), false);
+        assert_eq!(lt_si8(3, 1), false);
+        assert_eq!(lt_si8(3, 2), false);
+    }
+    #[test]
+    fn test_418() {
+        assert_eq!(lt_si8(3, 3), false);
+        assert_eq!(lt_si8(4, -128), false);
+        assert_eq!(lt_si8(4, -127), false);
+        assert_eq!(lt_si8(4, 0), false);
+        assert_eq!(lt_si8(4, 1), false);
+        assert_eq!(lt_si8(4, 2), false);
+        assert_eq!(lt_si8(4, 3), false);
+        assert_eq!(lt_si8(4, 4), false);
+        assert_eq!(lt_si8(16, -128), false);
+        assert_eq!(lt_si8(16, -127), false);
+    }
+    #[test]
+    fn test_419() {
+        assert_eq!(lt_si8(16, 0), false);
+        assert_eq!(lt_si8(16, 1), false);
+        assert_eq!(lt_si8(16, 2), false);
+        assert_eq!(lt_si8(16, 3), false);
+        assert_eq!(lt_si8(16, 4), false);
+        assert_eq!(lt_si8(16, 16), false);
+        assert_eq!(lt_si8(126, -128), false);
+        assert_eq!(lt_si8(126, -127), false);
+        assert_eq!(lt_si8(126, 0), false);
+        assert_eq!(lt_si8(126, 1), false);
+    }
+    #[test]
+    fn test_420() {
+        assert_eq!(lt_si8(126, 2), false);
+        assert_eq!(lt_si8(126, 3), false);
+        assert_eq!(lt_si8(126, 4), false);
+        assert_eq!(lt_si8(126, 16), false);
+        assert_eq!(lt_si8(126, 126), false);
+        assert_eq!(lt_si8(127, -128), false);
+        assert_eq!(lt_si8(127, -127), false);
+        assert_eq!(lt_si8(127, 0), false);
+        assert_eq!(lt_si8(127, 1), false);
+        assert_eq!(lt_si8(127, 2), false);
+    }
+    #[test]
+    fn test_421() {
+        assert_eq!(lt_si8(127, 3), false);
+        assert_eq!(lt_si8(127, 4), false);
+        assert_eq!(lt_si8(127, 16), false);
+        assert_eq!(lt_si8(127, 126), false);
+        assert_eq!(lt_si8(127, 127), false);
+        assert_eq!(lt_si8(-128, -127), true);
+        assert_eq!(lt_si8(-128, 0), true);
+        assert_eq!(lt_si8(-128, 1), true);
+        assert_eq!(lt_si8(-128, 2), true);
+        assert_eq!(lt_si8(-128, 3), true);
+    }
+    #[test]
+    fn test_422() {
+        assert_eq!(lt_si8(-128, 4), true);
+        assert_eq!(lt_si8(-128, 16), true);
+        assert_eq!(lt_si8(-128, 126), true);
+        assert_eq!(lt_si8(-128, 127), true);
+        assert_eq!(lt_si8(-127, 0), true);
+        assert_eq!(lt_si8(-127, 1), true);
+        assert_eq!(lt_si8(-127, 2), true);
+        assert_eq!(lt_si8(-127, 3), true);
+        assert_eq!(lt_si8(-127, 4), true);
+        assert_eq!(lt_si8(-127, 16), true);
+    }
+    #[test]
+    fn test_423() {
+        assert_eq!(lt_si8(-127, 126), true);
+        assert_eq!(lt_si8(-127, 127), true);
+        assert_eq!(lt_si8(0, 1), true);
+        assert_eq!(lt_si8(0, 2), true);
+        assert_eq!(lt_si8(0, 3), true);
+        assert_eq!(lt_si8(0, 4), true);
+        assert_eq!(lt_si8(0, 16), true);
+        assert_eq!(lt_si8(0, 126), true);
+        assert_eq!(lt_si8(0, 127), true);
+        assert_eq!(lt_si8(1, 2), true);
+    }
+    #[test]
+    fn test_424() {
+        assert_eq!(lt_si8(1, 3), true);
+        assert_eq!(lt_si8(1, 4), true);
+        assert_eq!(lt_si8(1, 16), true);
+        assert_eq!(lt_si8(1, 126), true);
+        assert_eq!(lt_si8(1, 127), true);
+        assert_eq!(lt_si8(2, 3), true);
+        assert_eq!(lt_si8(2, 4), true);
+        assert_eq!(lt_si8(2, 16), true);
+        assert_eq!(lt_si8(2, 126), true);
+        assert_eq!(lt_si8(2, 127), true);
+    }
+    #[test]
+    fn test_425() {
+        assert_eq!(lt_si8(3, 4), true);
+        assert_eq!(lt_si8(3, 16), true);
+        assert_eq!(lt_si8(3, 126), true);
+        assert_eq!(lt_si8(3, 127), true);
+        assert_eq!(lt_si8(4, 16), true);
+        assert_eq!(lt_si8(4, 126), true);
+        assert_eq!(lt_si8(4, 127), true);
+        assert_eq!(lt_si8(16, 126), true);
+        assert_eq!(lt_si8(16, 127), true);
+        assert_eq!(lt_si8(126, 127), true);
+    }
+    #[test]
+    fn test_426() {
+        assert_eq!(lt_ui16(0, 0), false);
+        assert_eq!(lt_ui16(1, 0), false);
+        assert_eq!(lt_ui16(1, 1), false);
+        assert_eq!(lt_ui16(2, 0), false);
+        assert_eq!(lt_ui16(2, 1), false);
+        assert_eq!(lt_ui16(2, 2), false);
+        assert_eq!(lt_ui16(3, 0), false);
+        assert_eq!(lt_ui16(3, 1), false);
+        assert_eq!(lt_ui16(3, 2), false);
+        assert_eq!(lt_ui16(3, 3), false);
+    }
+    #[test]
+    fn test_427() {
+        assert_eq!(lt_ui16(4, 0), false);
+        assert_eq!(lt_ui16(4, 1), false);
+        assert_eq!(lt_ui16(4, 2), false);
+        assert_eq!(lt_ui16(4, 3), false);
+        assert_eq!(lt_ui16(4, 4), false);
+        assert_eq!(lt_ui16(1717, 0), false);
+        assert_eq!(lt_ui16(1717, 1), false);
+        assert_eq!(lt_ui16(1717, 2), false);
+        assert_eq!(lt_ui16(1717, 3), false);
+        assert_eq!(lt_ui16(1717, 4), false);
+    }
+    #[test]
+    fn test_428() {
+        assert_eq!(lt_ui16(1717, 1717), false);
+        assert_eq!(lt_ui16(17988, 0), false);
+        assert_eq!(lt_ui16(17988, 1), false);
+        assert_eq!(lt_ui16(17988, 2), false);
+        assert_eq!(lt_ui16(17988, 3), false);
+        assert_eq!(lt_ui16(17988, 4), false);
+        assert_eq!(lt_ui16(17988, 1717), false);
+        assert_eq!(lt_ui16(17988, 17988), false);
+        assert_eq!(lt_ui16(65096, 0), false);
+        assert_eq!(lt_ui16(65096, 1), false);
+    }
+    #[test]
+    fn test_429() {
+        assert_eq!(lt_ui16(65096, 2), false);
+        assert_eq!(lt_ui16(65096, 3), false);
+        assert_eq!(lt_ui16(65096, 4), false);
+        assert_eq!(lt_ui16(65096, 1717), false);
+        assert_eq!(lt_ui16(65096, 17988), false);
+        assert_eq!(lt_ui16(65096, 65096), false);
+        assert_eq!(lt_ui16(65534, 0), false);
+        assert_eq!(lt_ui16(65534, 1), false);
+        assert_eq!(lt_ui16(65534, 2), false);
+        assert_eq!(lt_ui16(65534, 3), false);
+    }
+    #[test]
+    fn test_430() {
+        assert_eq!(lt_ui16(65534, 4), false);
+        assert_eq!(lt_ui16(65534, 1717), false);
+        assert_eq!(lt_ui16(65534, 17988), false);
+        assert_eq!(lt_ui16(65534, 65096), false);
+        assert_eq!(lt_ui16(65534, 65534), false);
+        assert_eq!(lt_ui16(65535, 0), false);
+        assert_eq!(lt_ui16(65535, 1), false);
+        assert_eq!(lt_ui16(65535, 2), false);
+        assert_eq!(lt_ui16(65535, 3), false);
+        assert_eq!(lt_ui16(65535, 4), false);
+    }
+    #[test]
+    fn test_431() {
+        assert_eq!(lt_ui16(65535, 1717), false);
+        assert_eq!(lt_ui16(65535, 17988), false);
+        assert_eq!(lt_ui16(65535, 65096), false);
+        assert_eq!(lt_ui16(65535, 65534), false);
+        assert_eq!(lt_ui16(65535, 65535), false);
+        assert_eq!(lt_ui16(0, 1), true);
+        assert_eq!(lt_ui16(0, 2), true);
+        assert_eq!(lt_ui16(0, 3), true);
+        assert_eq!(lt_ui16(0, 4), true);
+        assert_eq!(lt_ui16(0, 1717), true);
+    }
+    #[test]
+    fn test_432() {
+        assert_eq!(lt_ui16(0, 17988), true);
+        assert_eq!(lt_ui16(0, 65096), true);
+        assert_eq!(lt_ui16(0, 65534), true);
+        assert_eq!(lt_ui16(0, 65535), true);
+        assert_eq!(lt_ui16(1, 2), true);
+        assert_eq!(lt_ui16(1, 3), true);
+        assert_eq!(lt_ui16(1, 4), true);
+        assert_eq!(lt_ui16(1, 1717), true);
+        assert_eq!(lt_ui16(1, 17988), true);
+        assert_eq!(lt_ui16(1, 65096), true);
+    }
+    #[test]
+    fn test_433() {
+        assert_eq!(lt_ui16(1, 65534), true);
+        assert_eq!(lt_ui16(1, 65535), true);
+        assert_eq!(lt_ui16(2, 3), true);
+        assert_eq!(lt_ui16(2, 4), true);
+        assert_eq!(lt_ui16(2, 1717), true);
+        assert_eq!(lt_ui16(2, 17988), true);
+        assert_eq!(lt_ui16(2, 65096), true);
+        assert_eq!(lt_ui16(2, 65534), true);
+        assert_eq!(lt_ui16(2, 65535), true);
+        assert_eq!(lt_ui16(3, 4), true);
+    }
+    #[test]
+    fn test_434() {
+        assert_eq!(lt_ui16(3, 1717), true);
+        assert_eq!(lt_ui16(3, 17988), true);
+        assert_eq!(lt_ui16(3, 65096), true);
+        assert_eq!(lt_ui16(3, 65534), true);
+        assert_eq!(lt_ui16(3, 65535), true);
+        assert_eq!(lt_ui16(4, 1717), true);
+        assert_eq!(lt_ui16(4, 17988), true);
+        assert_eq!(lt_ui16(4, 65096), true);
+        assert_eq!(lt_ui16(4, 65534), true);
+        assert_eq!(lt_ui16(4, 65535), true);
+    }
+    #[test]
+    fn test_435() {
+        assert_eq!(lt_ui16(1717, 17988), true);
+        assert_eq!(lt_ui16(1717, 65096), true);
+        assert_eq!(lt_ui16(1717, 65534), true);
+        assert_eq!(lt_ui16(1717, 65535), true);
+        assert_eq!(lt_ui16(17988, 65096), true);
+        assert_eq!(lt_ui16(17988, 65534), true);
+        assert_eq!(lt_ui16(17988, 65535), true);
+        assert_eq!(lt_ui16(65096, 65534), true);
+        assert_eq!(lt_ui16(65096, 65535), true);
+        assert_eq!(lt_ui16(65534, 65535), true);
+    }
+    #[test]
+    fn test_436() {
+        assert_eq!(lt_ui32(0, 0), false);
+        assert_eq!(lt_ui32(1, 0), false);
+        assert_eq!(lt_ui32(1, 1), false);
+        assert_eq!(lt_ui32(2, 0), false);
+        assert_eq!(lt_ui32(2, 1), false);
+        assert_eq!(lt_ui32(2, 2), false);
+        assert_eq!(lt_ui32(3, 0), false);
+        assert_eq!(lt_ui32(3, 1), false);
+        assert_eq!(lt_ui32(3, 2), false);
+        assert_eq!(lt_ui32(3, 3), false);
+    }
+    #[test]
+    fn test_437() {
+        assert_eq!(lt_ui32(4, 0), false);
+        assert_eq!(lt_ui32(4, 1), false);
+        assert_eq!(lt_ui32(4, 2), false);
+        assert_eq!(lt_ui32(4, 3), false);
+        assert_eq!(lt_ui32(4, 4), false);
+        assert_eq!(lt_ui32(2119154652, 0), false);
+        assert_eq!(lt_ui32(2119154652, 1), false);
+        assert_eq!(lt_ui32(2119154652, 2), false);
+        assert_eq!(lt_ui32(2119154652, 3), false);
+        assert_eq!(lt_ui32(2119154652, 4), false);
+    }
+    #[test]
+    fn test_438() {
+        assert_eq!(lt_ui32(2119154652, 2119154652), false);
+        assert_eq!(lt_ui32(3002788344, 0), false);
+        assert_eq!(lt_ui32(3002788344, 1), false);
+        assert_eq!(lt_ui32(3002788344, 2), false);
+        assert_eq!(lt_ui32(3002788344, 3), false);
+        assert_eq!(lt_ui32(3002788344, 4), false);
+        assert_eq!(lt_ui32(3002788344, 2119154652), false);
+        assert_eq!(lt_ui32(3002788344, 3002788344), false);
+        assert_eq!(lt_ui32(3482297128, 0), false);
+        assert_eq!(lt_ui32(3482297128, 1), false);
+    }
+    #[test]
+    fn test_439() {
+        assert_eq!(lt_ui32(3482297128, 2), false);
+        assert_eq!(lt_ui32(3482297128, 3), false);
+        assert_eq!(lt_ui32(3482297128, 4), false);
+        assert_eq!(lt_ui32(3482297128, 2119154652), false);
+        assert_eq!(lt_ui32(3482297128, 3002788344), false);
+        assert_eq!(lt_ui32(3482297128, 3482297128), false);
+        assert_eq!(lt_ui32(4294967294, 0), false);
+        assert_eq!(lt_ui32(4294967294, 1), false);
+        assert_eq!(lt_ui32(4294967294, 2), false);
+        assert_eq!(lt_ui32(4294967294, 3), false);
+    }
+    #[test]
+    fn test_440() {
+        assert_eq!(lt_ui32(4294967294, 4), false);
+        assert_eq!(lt_ui32(4294967294, 2119154652), false);
+        assert_eq!(lt_ui32(4294967294, 3002788344), false);
+        assert_eq!(lt_ui32(4294967294, 3482297128), false);
+        assert_eq!(lt_ui32(4294967294, 4294967294), false);
+        assert_eq!(lt_ui32(4294967295, 0), false);
+        assert_eq!(lt_ui32(4294967295, 1), false);
+        assert_eq!(lt_ui32(4294967295, 2), false);
+        assert_eq!(lt_ui32(4294967295, 3), false);
+        assert_eq!(lt_ui32(4294967295, 4), false);
+    }
+    #[test]
+    fn test_441() {
+        assert_eq!(lt_ui32(4294967295, 2119154652), false);
+        assert_eq!(lt_ui32(4294967295, 3002788344), false);
+        assert_eq!(lt_ui32(4294967295, 3482297128), false);
+        assert_eq!(lt_ui32(4294967295, 4294967294), false);
+        assert_eq!(lt_ui32(4294967295, 4294967295), false);
+        assert_eq!(lt_ui32(0, 1), true);
+        assert_eq!(lt_ui32(0, 2), true);
+        assert_eq!(lt_ui32(0, 3), true);
+        assert_eq!(lt_ui32(0, 4), true);
+        assert_eq!(lt_ui32(0, 2119154652), true);
+    }
+    #[test]
+    fn test_442() {
+        assert_eq!(lt_ui32(0, 3002788344), true);
+        assert_eq!(lt_ui32(0, 3482297128), true);
+        assert_eq!(lt_ui32(0, 4294967294), true);
+        assert_eq!(lt_ui32(0, 4294967295), true);
+        assert_eq!(lt_ui32(1, 2), true);
+        assert_eq!(lt_ui32(1, 3), true);
+        assert_eq!(lt_ui32(1, 4), true);
+        assert_eq!(lt_ui32(1, 2119154652), true);
+        assert_eq!(lt_ui32(1, 3002788344), true);
+        assert_eq!(lt_ui32(1, 3482297128), true);
+    }
+    #[test]
+    fn test_443() {
+        assert_eq!(lt_ui32(1, 4294967294), true);
+        assert_eq!(lt_ui32(1, 4294967295), true);
+        assert_eq!(lt_ui32(2, 3), true);
+        assert_eq!(lt_ui32(2, 4), true);
+        assert_eq!(lt_ui32(2, 2119154652), true);
+        assert_eq!(lt_ui32(2, 3002788344), true);
+        assert_eq!(lt_ui32(2, 3482297128), true);
+        assert_eq!(lt_ui32(2, 4294967294), true);
+        assert_eq!(lt_ui32(2, 4294967295), true);
+        assert_eq!(lt_ui32(3, 4), true);
+    }
+    #[test]
+    fn test_444() {
+        assert_eq!(lt_ui32(3, 2119154652), true);
+        assert_eq!(lt_ui32(3, 3002788344), true);
+        assert_eq!(lt_ui32(3, 3482297128), true);
+        assert_eq!(lt_ui32(3, 4294967294), true);
+        assert_eq!(lt_ui32(3, 4294967295), true);
+        assert_eq!(lt_ui32(4, 2119154652), true);
+        assert_eq!(lt_ui32(4, 3002788344), true);
+        assert_eq!(lt_ui32(4, 3482297128), true);
+        assert_eq!(lt_ui32(4, 4294967294), true);
+        assert_eq!(lt_ui32(4, 4294967295), true);
+    }
+    #[test]
+    fn test_445() {
+        assert_eq!(lt_ui32(2119154652, 3002788344), true);
+        assert_eq!(lt_ui32(2119154652, 3482297128), true);
+        assert_eq!(lt_ui32(2119154652, 4294967294), true);
+        assert_eq!(lt_ui32(2119154652, 4294967295), true);
+        assert_eq!(lt_ui32(3002788344, 3482297128), true);
+        assert_eq!(lt_ui32(3002788344, 4294967294), true);
+        assert_eq!(lt_ui32(3002788344, 4294967295), true);
+        assert_eq!(lt_ui32(3482297128, 4294967294), true);
+        assert_eq!(lt_ui32(3482297128, 4294967295), true);
+        assert_eq!(lt_ui32(4294967294, 4294967295), true);
+    }
+    #[test]
+    fn test_446() {
+        assert_eq!(lt_ui64(0, 0), false);
+        assert_eq!(lt_ui64(1, 0), false);
+        assert_eq!(lt_ui64(1, 1), false);
+        assert_eq!(lt_ui64(2, 0), false);
+        assert_eq!(lt_ui64(2, 1), false);
+        assert_eq!(lt_ui64(2, 2), false);
+        assert_eq!(lt_ui64(3, 0), false);
+        assert_eq!(lt_ui64(3, 1), false);
+        assert_eq!(lt_ui64(3, 2), false);
+        assert_eq!(lt_ui64(3, 3), false);
+    }
+    #[test]
+    fn test_447() {
+        assert_eq!(lt_ui64(4, 0), false);
+        assert_eq!(lt_ui64(4, 1), false);
+        assert_eq!(lt_ui64(4, 2), false);
+        assert_eq!(lt_ui64(4, 3), false);
+        assert_eq!(lt_ui64(4, 4), false);
+        assert_eq!(lt_ui64(191084152064409600, 0), false);
+        assert_eq!(lt_ui64(191084152064409600, 1), false);
+        assert_eq!(lt_ui64(191084152064409600, 2), false);
+        assert_eq!(lt_ui64(191084152064409600, 3), false);
+        assert_eq!(lt_ui64(191084152064409600, 4), false);
+    }
+    #[test]
+    fn test_448() {
+        assert_eq!(lt_ui64(191084152064409600, 191084152064409600), false);
+        assert_eq!(lt_ui64(11015955194427482112, 0), false);
+        assert_eq!(lt_ui64(11015955194427482112, 1), false);
+        assert_eq!(lt_ui64(11015955194427482112, 2), false);
+        assert_eq!(lt_ui64(11015955194427482112, 3), false);
+        assert_eq!(lt_ui64(11015955194427482112, 4), false);
+        assert_eq!(lt_ui64(11015955194427482112, 191084152064409600), false);
+        assert_eq!(lt_ui64(11015955194427482112, 11015955194427482112), false);
+        assert_eq!(lt_ui64(16990600415051759616, 0), false);
+        assert_eq!(lt_ui64(16990600415051759616, 1), false);
+    }
+    #[test]
+    fn test_449() {
+        assert_eq!(lt_ui64(16990600415051759616, 2), false);
+        assert_eq!(lt_ui64(16990600415051759616, 3), false);
+        assert_eq!(lt_ui64(16990600415051759616, 4), false);
+        assert_eq!(lt_ui64(16990600415051759616, 191084152064409600), false);
+        assert_eq!(lt_ui64(16990600415051759616, 11015955194427482112), false);
+        assert_eq!(lt_ui64(16990600415051759616, 16990600415051759616), false);
+        assert_eq!(lt_ui64(18446744073709551614, 0), false);
+        assert_eq!(lt_ui64(18446744073709551614, 1), false);
+        assert_eq!(lt_ui64(18446744073709551614, 2), false);
+        assert_eq!(lt_ui64(18446744073709551614, 3), false);
+    }
+    #[test]
+    fn test_450() {
+        assert_eq!(lt_ui64(18446744073709551614, 4), false);
+        assert_eq!(lt_ui64(18446744073709551614, 191084152064409600), false);
+        assert_eq!(lt_ui64(18446744073709551614, 11015955194427482112), false);
+        assert_eq!(lt_ui64(18446744073709551614, 16990600415051759616), false);
+        assert_eq!(lt_ui64(18446744073709551614, 18446744073709551614), false);
+        assert_eq!(lt_ui64(18446744073709551615, 0), false);
+        assert_eq!(lt_ui64(18446744073709551615, 1), false);
+        assert_eq!(lt_ui64(18446744073709551615, 2), false);
+        assert_eq!(lt_ui64(18446744073709551615, 3), false);
+        assert_eq!(lt_ui64(18446744073709551615, 4), false);
+    }
+    #[test]
+    fn test_451() {
+        assert_eq!(lt_ui64(18446744073709551615, 191084152064409600), false);
+        assert_eq!(lt_ui64(18446744073709551615, 11015955194427482112), false);
+        assert_eq!(lt_ui64(18446744073709551615, 16990600415051759616), false);
+        assert_eq!(lt_ui64(18446744073709551615, 18446744073709551614), false);
+        assert_eq!(lt_ui64(18446744073709551615, 18446744073709551615), false);
+        assert_eq!(lt_ui64(0, 1), true);
+        assert_eq!(lt_ui64(0, 2), true);
+        assert_eq!(lt_ui64(0, 3), true);
+        assert_eq!(lt_ui64(0, 4), true);
+        assert_eq!(lt_ui64(0, 191084152064409600), true);
+    }
+    #[test]
+    fn test_452() {
+        assert_eq!(lt_ui64(0, 11015955194427482112), true);
+        assert_eq!(lt_ui64(0, 16990600415051759616), true);
+        assert_eq!(lt_ui64(0, 18446744073709551614), true);
+        assert_eq!(lt_ui64(0, 18446744073709551615), true);
+        assert_eq!(lt_ui64(1, 2), true);
+        assert_eq!(lt_ui64(1, 3), true);
+        assert_eq!(lt_ui64(1, 4), true);
+        assert_eq!(lt_ui64(1, 191084152064409600), true);
+        assert_eq!(lt_ui64(1, 11015955194427482112), true);
+        assert_eq!(lt_ui64(1, 16990600415051759616), true);
+    }
+    #[test]
+    fn test_453() {
+        assert_eq!(lt_ui64(1, 18446744073709551614), true);
+        assert_eq!(lt_ui64(1, 18446744073709551615), true);
+        assert_eq!(lt_ui64(2, 3), true);
+        assert_eq!(lt_ui64(2, 4), true);
+        assert_eq!(lt_ui64(2, 191084152064409600), true);
+        assert_eq!(lt_ui64(2, 11015955194427482112), true);
+        assert_eq!(lt_ui64(2, 16990600415051759616), true);
+        assert_eq!(lt_ui64(2, 18446744073709551614), true);
+        assert_eq!(lt_ui64(2, 18446744073709551615), true);
+        assert_eq!(lt_ui64(3, 4), true);
+    }
+    #[test]
+    fn test_454() {
+        assert_eq!(lt_ui64(3, 191084152064409600), true);
+        assert_eq!(lt_ui64(3, 11015955194427482112), true);
+        assert_eq!(lt_ui64(3, 16990600415051759616), true);
+        assert_eq!(lt_ui64(3, 18446744073709551614), true);
+        assert_eq!(lt_ui64(3, 18446744073709551615), true);
+        assert_eq!(lt_ui64(4, 191084152064409600), true);
+        assert_eq!(lt_ui64(4, 11015955194427482112), true);
+        assert_eq!(lt_ui64(4, 16990600415051759616), true);
+        assert_eq!(lt_ui64(4, 18446744073709551614), true);
+        assert_eq!(lt_ui64(4, 18446744073709551615), true);
+    }
+    #[test]
+    fn test_455() {
+        assert_eq!(lt_ui64(191084152064409600, 11015955194427482112), true);
+        assert_eq!(lt_ui64(191084152064409600, 16990600415051759616), true);
+        assert_eq!(lt_ui64(191084152064409600, 18446744073709551614), true);
+        assert_eq!(lt_ui64(191084152064409600, 18446744073709551615), true);
+        assert_eq!(lt_ui64(11015955194427482112, 16990600415051759616), true);
+        assert_eq!(lt_ui64(11015955194427482112, 18446744073709551614), true);
+        assert_eq!(lt_ui64(11015955194427482112, 18446744073709551615), true);
+        assert_eq!(lt_ui64(16990600415051759616, 18446744073709551614), true);
+        assert_eq!(lt_ui64(16990600415051759616, 18446744073709551615), true);
+        assert_eq!(lt_ui64(18446744073709551614, 18446744073709551615), true);
+    }
+    #[test]
+    fn test_456() {
+        assert_eq!(lt_ui8(0, 0), false);
+        assert_eq!(lt_ui8(1, 0), false);
+        assert_eq!(lt_ui8(1, 1), false);
+        assert_eq!(lt_ui8(2, 0), false);
+        assert_eq!(lt_ui8(2, 1), false);
+        assert_eq!(lt_ui8(2, 2), false);
+        assert_eq!(lt_ui8(3, 0), false);
+        assert_eq!(lt_ui8(3, 1), false);
+        assert_eq!(lt_ui8(3, 2), false);
+        assert_eq!(lt_ui8(3, 3), false);
+    }
+    #[test]
+    fn test_457() {
+        assert_eq!(lt_ui8(4, 0), false);
+        assert_eq!(lt_ui8(4, 1), false);
+        assert_eq!(lt_ui8(4, 2), false);
+        assert_eq!(lt_ui8(4, 3), false);
+        assert_eq!(lt_ui8(4, 4), false);
+        assert_eq!(lt_ui8(72, 0), false);
+        assert_eq!(lt_ui8(72, 1), false);
+        assert_eq!(lt_ui8(72, 2), false);
+        assert_eq!(lt_ui8(72, 3), false);
+        assert_eq!(lt_ui8(72, 4), false);
+    }
+    #[test]
+    fn test_458() {
+        assert_eq!(lt_ui8(72, 72), false);
+        assert_eq!(lt_ui8(100, 0), false);
+        assert_eq!(lt_ui8(100, 1), false);
+        assert_eq!(lt_ui8(100, 2), false);
+        assert_eq!(lt_ui8(100, 3), false);
+        assert_eq!(lt_ui8(100, 4), false);
+        assert_eq!(lt_ui8(100, 72), false);
+        assert_eq!(lt_ui8(100, 100), false);
+        assert_eq!(lt_ui8(162, 0), false);
+        assert_eq!(lt_ui8(162, 1), false);
+    }
+    #[test]
+    fn test_459() {
+        assert_eq!(lt_ui8(162, 2), false);
+        assert_eq!(lt_ui8(162, 3), false);
+        assert_eq!(lt_ui8(162, 4), false);
+        assert_eq!(lt_ui8(162, 72), false);
+        assert_eq!(lt_ui8(162, 100), false);
+        assert_eq!(lt_ui8(162, 162), false);
+        assert_eq!(lt_ui8(254, 0), false);
+        assert_eq!(lt_ui8(254, 1), false);
+        assert_eq!(lt_ui8(254, 2), false);
+        assert_eq!(lt_ui8(254, 3), false);
+    }
+    #[test]
+    fn test_460() {
+        assert_eq!(lt_ui8(254, 4), false);
+        assert_eq!(lt_ui8(254, 72), false);
+        assert_eq!(lt_ui8(254, 100), false);
+        assert_eq!(lt_ui8(254, 162), false);
+        assert_eq!(lt_ui8(254, 254), false);
+        assert_eq!(lt_ui8(255, 0), false);
+        assert_eq!(lt_ui8(255, 1), false);
+        assert_eq!(lt_ui8(255, 2), false);
+        assert_eq!(lt_ui8(255, 3), false);
+        assert_eq!(lt_ui8(255, 4), false);
+    }
+    #[test]
+    fn test_461() {
+        assert_eq!(lt_ui8(255, 72), false);
+        assert_eq!(lt_ui8(255, 100), false);
+        assert_eq!(lt_ui8(255, 162), false);
+        assert_eq!(lt_ui8(255, 254), false);
+        assert_eq!(lt_ui8(255, 255), false);
+        assert_eq!(lt_ui8(0, 1), true);
+        assert_eq!(lt_ui8(0, 2), true);
+        assert_eq!(lt_ui8(0, 3), true);
+        assert_eq!(lt_ui8(0, 4), true);
+        assert_eq!(lt_ui8(0, 72), true);
+    }
+    #[test]
+    fn test_462() {
+        assert_eq!(lt_ui8(0, 100), true);
+        assert_eq!(lt_ui8(0, 162), true);
+        assert_eq!(lt_ui8(0, 254), true);
+        assert_eq!(lt_ui8(0, 255), true);
+        assert_eq!(lt_ui8(1, 2), true);
+        assert_eq!(lt_ui8(1, 3), true);
+        assert_eq!(lt_ui8(1, 4), true);
+        assert_eq!(lt_ui8(1, 72), true);
+        assert_eq!(lt_ui8(1, 100), true);
+        assert_eq!(lt_ui8(1, 162), true);
+    }
+    #[test]
+    fn test_463() {
+        assert_eq!(lt_ui8(1, 254), true);
+        assert_eq!(lt_ui8(1, 255), true);
+        assert_eq!(lt_ui8(2, 3), true);
+        assert_eq!(lt_ui8(2, 4), true);
+        assert_eq!(lt_ui8(2, 72), true);
+        assert_eq!(lt_ui8(2, 100), true);
+        assert_eq!(lt_ui8(2, 162), true);
+        assert_eq!(lt_ui8(2, 254), true);
+        assert_eq!(lt_ui8(2, 255), true);
+        assert_eq!(lt_ui8(3, 4), true);
+    }
+    #[test]
+    fn test_464() {
+        assert_eq!(lt_ui8(3, 72), true);
+        assert_eq!(lt_ui8(3, 100), true);
+        assert_eq!(lt_ui8(3, 162), true);
+        assert_eq!(lt_ui8(3, 254), true);
+        assert_eq!(lt_ui8(3, 255), true);
+        assert_eq!(lt_ui8(4, 72), true);
+        assert_eq!(lt_ui8(4, 100), true);
+        assert_eq!(lt_ui8(4, 162), true);
+        assert_eq!(lt_ui8(4, 254), true);
+        assert_eq!(lt_ui8(4, 255), true);
+    }
+    #[test]
+    fn test_465() {
+        assert_eq!(lt_ui8(72, 100), true);
+        assert_eq!(lt_ui8(72, 162), true);
+        assert_eq!(lt_ui8(72, 254), true);
+        assert_eq!(lt_ui8(72, 255), true);
+        assert_eq!(lt_ui8(100, 162), true);
+        assert_eq!(lt_ui8(100, 254), true);
+        assert_eq!(lt_ui8(100, 255), true);
+        assert_eq!(lt_ui8(162, 254), true);
+        assert_eq!(lt_ui8(162, 255), true);
+        assert_eq!(lt_ui8(254, 255), true);
+    }
+    #[test]
+    fn test_466() {
+        assert_eq!(ne_si16(-32768, -32768), false);
+        assert_eq!(ne_si16(-32767, -32767), false);
+        assert_eq!(ne_si16(-32547, -32547), false);
+        assert_eq!(ne_si16(0, 0), false);
+        assert_eq!(ne_si16(1, 1), false);
+        assert_eq!(ne_si16(2, 2), false);
+        assert_eq!(ne_si16(3, 3), false);
+        assert_eq!(ne_si16(4, 4), false);
+        assert_eq!(ne_si16(10486, 10486), false);
+        assert_eq!(ne_si16(16514, 16514), false);
+    }
+    #[test]
+    fn test_467() {
+        assert_eq!(ne_si16(32766, 32766), false);
+        assert_eq!(ne_si16(32767, 32767), false);
+        assert_eq!(ne_si16(-32768, -32767), true);
+        assert_eq!(ne_si16(-32768, -32547), true);
+        assert_eq!(ne_si16(-32768, 0), true);
+        assert_eq!(ne_si16(-32768, 1), true);
+        assert_eq!(ne_si16(-32768, 2), true);
+        assert_eq!(ne_si16(-32768, 3), true);
+        assert_eq!(ne_si16(-32768, 4), true);
+        assert_eq!(ne_si16(-32768, 10486), true);
+    }
+    #[test]
+    fn test_468() {
+        assert_eq!(ne_si16(-32768, 16514), true);
+        assert_eq!(ne_si16(-32768, 32766), true);
+        assert_eq!(ne_si16(-32768, 32767), true);
+        assert_eq!(ne_si16(-32767, -32768), true);
+        assert_eq!(ne_si16(-32767, -32547), true);
+        assert_eq!(ne_si16(-32767, 0), true);
+        assert_eq!(ne_si16(-32767, 1), true);
+        assert_eq!(ne_si16(-32767, 2), true);
+        assert_eq!(ne_si16(-32767, 3), true);
+        assert_eq!(ne_si16(-32767, 4), true);
+    }
+    #[test]
+    fn test_469() {
+        assert_eq!(ne_si16(-32767, 10486), true);
+        assert_eq!(ne_si16(-32767, 16514), true);
+        assert_eq!(ne_si16(-32767, 32766), true);
+        assert_eq!(ne_si16(-32767, 32767), true);
+        assert_eq!(ne_si16(-32547, -32768), true);
+        assert_eq!(ne_si16(-32547, -32767), true);
+        assert_eq!(ne_si16(-32547, 0), true);
+        assert_eq!(ne_si16(-32547, 1), true);
+        assert_eq!(ne_si16(-32547, 2), true);
+        assert_eq!(ne_si16(-32547, 3), true);
+    }
+    #[test]
+    fn test_470() {
+        assert_eq!(ne_si16(-32547, 4), true);
+        assert_eq!(ne_si16(-32547, 10486), true);
+        assert_eq!(ne_si16(-32547, 16514), true);
+        assert_eq!(ne_si16(-32547, 32766), true);
+        assert_eq!(ne_si16(-32547, 32767), true);
+        assert_eq!(ne_si16(0, -32768), true);
+        assert_eq!(ne_si16(0, -32767), true);
+        assert_eq!(ne_si16(0, -32547), true);
+        assert_eq!(ne_si16(0, 1), true);
+        assert_eq!(ne_si16(0, 2), true);
+    }
+    #[test]
+    fn test_471() {
+        assert_eq!(ne_si16(0, 3), true);
+        assert_eq!(ne_si16(0, 4), true);
+        assert_eq!(ne_si16(0, 10486), true);
+        assert_eq!(ne_si16(0, 16514), true);
+        assert_eq!(ne_si16(0, 32766), true);
+        assert_eq!(ne_si16(0, 32767), true);
+        assert_eq!(ne_si16(1, -32768), true);
+        assert_eq!(ne_si16(1, -32767), true);
+        assert_eq!(ne_si16(1, -32547), true);
+        assert_eq!(ne_si16(1, 0), true);
+    }
+    #[test]
+    fn test_472() {
+        assert_eq!(ne_si16(1, 2), true);
+        assert_eq!(ne_si16(1, 3), true);
+        assert_eq!(ne_si16(1, 4), true);
+        assert_eq!(ne_si16(1, 10486), true);
+        assert_eq!(ne_si16(1, 16514), true);
+        assert_eq!(ne_si16(1, 32766), true);
+        assert_eq!(ne_si16(1, 32767), true);
+        assert_eq!(ne_si16(2, -32768), true);
+        assert_eq!(ne_si16(2, -32767), true);
+        assert_eq!(ne_si16(2, -32547), true);
+    }
+    #[test]
+    fn test_473() {
+        assert_eq!(ne_si16(2, 0), true);
+        assert_eq!(ne_si16(2, 1), true);
+        assert_eq!(ne_si16(2, 3), true);
+        assert_eq!(ne_si16(2, 4), true);
+        assert_eq!(ne_si16(2, 10486), true);
+        assert_eq!(ne_si16(2, 16514), true);
+        assert_eq!(ne_si16(2, 32766), true);
+        assert_eq!(ne_si16(2, 32767), true);
+        assert_eq!(ne_si16(3, -32768), true);
+        assert_eq!(ne_si16(3, -32767), true);
+    }
+    #[test]
+    fn test_474() {
+        assert_eq!(ne_si16(3, -32547), true);
+        assert_eq!(ne_si16(3, 0), true);
+        assert_eq!(ne_si16(3, 1), true);
+        assert_eq!(ne_si16(3, 2), true);
+        assert_eq!(ne_si16(3, 4), true);
+        assert_eq!(ne_si16(3, 10486), true);
+        assert_eq!(ne_si16(3, 16514), true);
+        assert_eq!(ne_si16(3, 32766), true);
+        assert_eq!(ne_si16(3, 32767), true);
+        assert_eq!(ne_si16(4, -32768), true);
+    }
+    #[test]
+    fn test_475() {
+        assert_eq!(ne_si16(4, -32767), true);
+        assert_eq!(ne_si16(4, -32547), true);
+        assert_eq!(ne_si16(4, 0), true);
+        assert_eq!(ne_si16(4, 1), true);
+        assert_eq!(ne_si16(4, 2), true);
+        assert_eq!(ne_si16(4, 3), true);
+        assert_eq!(ne_si16(4, 10486), true);
+        assert_eq!(ne_si16(4, 16514), true);
+        assert_eq!(ne_si16(4, 32766), true);
+        assert_eq!(ne_si16(4, 32767), true);
+    }
+    #[test]
+    fn test_476() {
+        assert_eq!(ne_si16(10486, -32768), true);
+        assert_eq!(ne_si16(10486, -32767), true);
+        assert_eq!(ne_si16(10486, -32547), true);
+        assert_eq!(ne_si16(10486, 0), true);
+        assert_eq!(ne_si16(10486, 1), true);
+        assert_eq!(ne_si16(10486, 2), true);
+        assert_eq!(ne_si16(10486, 3), true);
+        assert_eq!(ne_si16(10486, 4), true);
+        assert_eq!(ne_si16(10486, 16514), true);
+        assert_eq!(ne_si16(10486, 32766), true);
+    }
+    #[test]
+    fn test_477() {
+        assert_eq!(ne_si16(10486, 32767), true);
+        assert_eq!(ne_si16(16514, -32768), true);
+        assert_eq!(ne_si16(16514, -32767), true);
+        assert_eq!(ne_si16(16514, -32547), true);
+        assert_eq!(ne_si16(16514, 0), true);
+        assert_eq!(ne_si16(16514, 1), true);
+        assert_eq!(ne_si16(16514, 2), true);
+        assert_eq!(ne_si16(16514, 3), true);
+        assert_eq!(ne_si16(16514, 4), true);
+        assert_eq!(ne_si16(16514, 10486), true);
+    }
+    #[test]
+    fn test_478() {
+        assert_eq!(ne_si16(16514, 32766), true);
+        assert_eq!(ne_si16(16514, 32767), true);
+        assert_eq!(ne_si16(32766, -32768), true);
+        assert_eq!(ne_si16(32766, -32767), true);
+        assert_eq!(ne_si16(32766, -32547), true);
+        assert_eq!(ne_si16(32766, 0), true);
+        assert_eq!(ne_si16(32766, 1), true);
+        assert_eq!(ne_si16(32766, 2), true);
+        assert_eq!(ne_si16(32766, 3), true);
+        assert_eq!(ne_si16(32766, 4), true);
+    }
+    #[test]
+    fn test_479() {
+        assert_eq!(ne_si16(32766, 10486), true);
+        assert_eq!(ne_si16(32766, 16514), true);
+        assert_eq!(ne_si16(32766, 32767), true);
+        assert_eq!(ne_si16(32767, -32768), true);
+        assert_eq!(ne_si16(32767, -32767), true);
+        assert_eq!(ne_si16(32767, -32547), true);
+        assert_eq!(ne_si16(32767, 0), true);
+        assert_eq!(ne_si16(32767, 1), true);
+        assert_eq!(ne_si16(32767, 2), true);
+        assert_eq!(ne_si16(32767, 3), true);
+    }
+    #[test]
+    fn test_480() {
+        assert_eq!(ne_si16(32767, 4), true);
+        assert_eq!(ne_si16(32767, 10486), true);
+        assert_eq!(ne_si16(32767, 16514), true);
+        assert_eq!(ne_si16(32767, 32766), true);
+        assert_eq!(ne_si32(-2147483648, -2147483648), false);
+        assert_eq!(ne_si32(-2147483647, -2147483647), false);
+        assert_eq!(ne_si32(-1713183800, -1713183800), false);
+        assert_eq!(ne_si32(-1252582164, -1252582164), false);
+        assert_eq!(ne_si32(-1035405763, -1035405763), false);
+        assert_eq!(ne_si32(0, 0), false);
+    }
+    #[test]
+    fn test_481() {
+        assert_eq!(ne_si32(1, 1), false);
+        assert_eq!(ne_si32(2, 2), false);
+        assert_eq!(ne_si32(3, 3), false);
+        assert_eq!(ne_si32(4, 4), false);
+        assert_eq!(ne_si32(2147483646, 2147483646), false);
+        assert_eq!(ne_si32(2147483647, 2147483647), false);
+        assert_eq!(ne_si32(-2147483648, -2147483647), true);
+        assert_eq!(ne_si32(-2147483648, -1713183800), true);
+        assert_eq!(ne_si32(-2147483648, -1252582164), true);
+        assert_eq!(ne_si32(-2147483648, -1035405763), true);
+    }
+    #[test]
+    fn test_482() {
+        assert_eq!(ne_si32(-2147483648, 0), true);
+        assert_eq!(ne_si32(-2147483648, 1), true);
+        assert_eq!(ne_si32(-2147483648, 2), true);
+        assert_eq!(ne_si32(-2147483648, 3), true);
+        assert_eq!(ne_si32(-2147483648, 4), true);
+        assert_eq!(ne_si32(-2147483648, 2147483646), true);
+        assert_eq!(ne_si32(-2147483648, 2147483647), true);
+        assert_eq!(ne_si32(-2147483647, -2147483648), true);
+        assert_eq!(ne_si32(-2147483647, -1713183800), true);
+        assert_eq!(ne_si32(-2147483647, -1252582164), true);
+    }
+    #[test]
+    fn test_483() {
+        assert_eq!(ne_si32(-2147483647, -1035405763), true);
+        assert_eq!(ne_si32(-2147483647, 0), true);
+        assert_eq!(ne_si32(-2147483647, 1), true);
+        assert_eq!(ne_si32(-2147483647, 2), true);
+        assert_eq!(ne_si32(-2147483647, 3), true);
+        assert_eq!(ne_si32(-2147483647, 4), true);
+        assert_eq!(ne_si32(-2147483647, 2147483646), true);
+        assert_eq!(ne_si32(-2147483647, 2147483647), true);
+        assert_eq!(ne_si32(-1713183800, -2147483648), true);
+        assert_eq!(ne_si32(-1713183800, -2147483647), true);
+    }
+    #[test]
+    fn test_484() {
+        assert_eq!(ne_si32(-1713183800, -1252582164), true);
+        assert_eq!(ne_si32(-1713183800, -1035405763), true);
+        assert_eq!(ne_si32(-1713183800, 0), true);
+        assert_eq!(ne_si32(-1713183800, 1), true);
+        assert_eq!(ne_si32(-1713183800, 2), true);
+        assert_eq!(ne_si32(-1713183800, 3), true);
+        assert_eq!(ne_si32(-1713183800, 4), true);
+        assert_eq!(ne_si32(-1713183800, 2147483646), true);
+        assert_eq!(ne_si32(-1713183800, 2147483647), true);
+        assert_eq!(ne_si32(-1252582164, -2147483648), true);
+    }
+    #[test]
+    fn test_485() {
+        assert_eq!(ne_si32(-1252582164, -2147483647), true);
+        assert_eq!(ne_si32(-1252582164, -1713183800), true);
+        assert_eq!(ne_si32(-1252582164, -1035405763), true);
+        assert_eq!(ne_si32(-1252582164, 0), true);
+        assert_eq!(ne_si32(-1252582164, 1), true);
+        assert_eq!(ne_si32(-1252582164, 2), true);
+        assert_eq!(ne_si32(-1252582164, 3), true);
+        assert_eq!(ne_si32(-1252582164, 4), true);
+        assert_eq!(ne_si32(-1252582164, 2147483646), true);
+        assert_eq!(ne_si32(-1252582164, 2147483647), true);
+    }
+    #[test]
+    fn test_486() {
+        assert_eq!(ne_si32(-1035405763, -2147483648), true);
+        assert_eq!(ne_si32(-1035405763, -2147483647), true);
+        assert_eq!(ne_si32(-1035405763, -1713183800), true);
+        assert_eq!(ne_si32(-1035405763, -1252582164), true);
+        assert_eq!(ne_si32(-1035405763, 0), true);
+        assert_eq!(ne_si32(-1035405763, 1), true);
+        assert_eq!(ne_si32(-1035405763, 2), true);
+        assert_eq!(ne_si32(-1035405763, 3), true);
+        assert_eq!(ne_si32(-1035405763, 4), true);
+        assert_eq!(ne_si32(-1035405763, 2147483646), true);
+    }
+    #[test]
+    fn test_487() {
+        assert_eq!(ne_si32(-1035405763, 2147483647), true);
+        assert_eq!(ne_si32(0, -2147483648), true);
+        assert_eq!(ne_si32(0, -2147483647), true);
+        assert_eq!(ne_si32(0, -1713183800), true);
+        assert_eq!(ne_si32(0, -1252582164), true);
+        assert_eq!(ne_si32(0, -1035405763), true);
+        assert_eq!(ne_si32(0, 1), true);
+        assert_eq!(ne_si32(0, 2), true);
+        assert_eq!(ne_si32(0, 3), true);
+        assert_eq!(ne_si32(0, 4), true);
+    }
+    #[test]
+    fn test_488() {
+        assert_eq!(ne_si32(0, 2147483646), true);
+        assert_eq!(ne_si32(0, 2147483647), true);
+        assert_eq!(ne_si32(1, -2147483648), true);
+        assert_eq!(ne_si32(1, -2147483647), true);
+        assert_eq!(ne_si32(1, -1713183800), true);
+        assert_eq!(ne_si32(1, -1252582164), true);
+        assert_eq!(ne_si32(1, -1035405763), true);
+        assert_eq!(ne_si32(1, 0), true);
+        assert_eq!(ne_si32(1, 2), true);
+        assert_eq!(ne_si32(1, 3), true);
+    }
+    #[test]
+    fn test_489() {
+        assert_eq!(ne_si32(1, 4), true);
+        assert_eq!(ne_si32(1, 2147483646), true);
+        assert_eq!(ne_si32(1, 2147483647), true);
+        assert_eq!(ne_si32(2, -2147483648), true);
+        assert_eq!(ne_si32(2, -2147483647), true);
+        assert_eq!(ne_si32(2, -1713183800), true);
+        assert_eq!(ne_si32(2, -1252582164), true);
+        assert_eq!(ne_si32(2, -1035405763), true);
+        assert_eq!(ne_si32(2, 0), true);
+        assert_eq!(ne_si32(2, 1), true);
+    }
+    #[test]
+    fn test_490() {
+        assert_eq!(ne_si32(2, 3), true);
+        assert_eq!(ne_si32(2, 4), true);
+        assert_eq!(ne_si32(2, 2147483646), true);
+        assert_eq!(ne_si32(2, 2147483647), true);
+        assert_eq!(ne_si32(3, -2147483648), true);
+        assert_eq!(ne_si32(3, -2147483647), true);
+        assert_eq!(ne_si32(3, -1713183800), true);
+        assert_eq!(ne_si32(3, -1252582164), true);
+        assert_eq!(ne_si32(3, -1035405763), true);
+        assert_eq!(ne_si32(3, 0), true);
+    }
+    #[test]
+    fn test_491() {
+        assert_eq!(ne_si32(3, 1), true);
+        assert_eq!(ne_si32(3, 2), true);
+        assert_eq!(ne_si32(3, 4), true);
+        assert_eq!(ne_si32(3, 2147483646), true);
+        assert_eq!(ne_si32(3, 2147483647), true);
+        assert_eq!(ne_si32(4, -2147483648), true);
+        assert_eq!(ne_si32(4, -2147483647), true);
+        assert_eq!(ne_si32(4, -1713183800), true);
+        assert_eq!(ne_si32(4, -1252582164), true);
+        assert_eq!(ne_si32(4, -1035405763), true);
+    }
+    #[test]
+    fn test_492() {
+        assert_eq!(ne_si32(4, 0), true);
+        assert_eq!(ne_si32(4, 1), true);
+        assert_eq!(ne_si32(4, 2), true);
+        assert_eq!(ne_si32(4, 3), true);
+        assert_eq!(ne_si32(4, 2147483646), true);
+        assert_eq!(ne_si32(4, 2147483647), true);
+        assert_eq!(ne_si32(2147483646, -2147483648), true);
+        assert_eq!(ne_si32(2147483646, -2147483647), true);
+        assert_eq!(ne_si32(2147483646, -1713183800), true);
+        assert_eq!(ne_si32(2147483646, -1252582164), true);
+    }
+    #[test]
+    fn test_493() {
+        assert_eq!(ne_si32(2147483646, -1035405763), true);
+        assert_eq!(ne_si32(2147483646, 0), true);
+        assert_eq!(ne_si32(2147483646, 1), true);
+        assert_eq!(ne_si32(2147483646, 2), true);
+        assert_eq!(ne_si32(2147483646, 3), true);
+        assert_eq!(ne_si32(2147483646, 4), true);
+        assert_eq!(ne_si32(2147483646, 2147483647), true);
+        assert_eq!(ne_si32(2147483647, -2147483648), true);
+        assert_eq!(ne_si32(2147483647, -2147483647), true);
+        assert_eq!(ne_si32(2147483647, -1713183800), true);
+    }
+    #[test]
+    fn test_494() {
+        assert_eq!(ne_si32(2147483647, -1252582164), true);
+        assert_eq!(ne_si32(2147483647, -1035405763), true);
+        assert_eq!(ne_si32(2147483647, 0), true);
+        assert_eq!(ne_si32(2147483647, 1), true);
+        assert_eq!(ne_si32(2147483647, 2), true);
+        assert_eq!(ne_si32(2147483647, 3), true);
+        assert_eq!(ne_si32(2147483647, 4), true);
+        assert_eq!(ne_si32(2147483647, 2147483646), true);
+        assert_eq!(ne_si64(-9223372036854775808, -9223372036854775808), false);
+        assert_eq!(ne_si64(-9223372036854775807, -9223372036854775807), false);
+    }
+    #[test]
+    fn test_495() {
+        assert_eq!(ne_si64(-1741927215160008704, -1741927215160008704), false);
+        assert_eq!(ne_si64(-1328271339354574848, -1328271339354574848), false);
+        assert_eq!(ne_si64(0, 0), false);
+        assert_eq!(ne_si64(1, 1), false);
+        assert_eq!(ne_si64(2, 2), false);
+        assert_eq!(ne_si64(3, 3), false);
+        assert_eq!(ne_si64(4, 4), false);
+        assert_eq!(ne_si64(5577148965131116544, 5577148965131116544), false);
+        assert_eq!(ne_si64(9223372036854775806, 9223372036854775806), false);
+        assert_eq!(ne_si64(9223372036854775807, 9223372036854775807), false);
+    }
+    #[test]
+    fn test_496() {
+        assert_eq!(ne_si64(-9223372036854775808, -9223372036854775807), true);
+        assert_eq!(ne_si64(-9223372036854775808, -1741927215160008704), true);
+        assert_eq!(ne_si64(-9223372036854775808, -1328271339354574848), true);
+        assert_eq!(ne_si64(-9223372036854775808, 0), true);
+        assert_eq!(ne_si64(-9223372036854775808, 1), true);
+        assert_eq!(ne_si64(-9223372036854775808, 2), true);
+        assert_eq!(ne_si64(-9223372036854775808, 3), true);
+        assert_eq!(ne_si64(-9223372036854775808, 4), true);
+        assert_eq!(ne_si64(-9223372036854775808, 5577148965131116544), true);
+        assert_eq!(ne_si64(-9223372036854775808, 9223372036854775806), true);
+    }
+    #[test]
+    fn test_497() {
+        assert_eq!(ne_si64(-9223372036854775808, 9223372036854775807), true);
+        assert_eq!(ne_si64(-9223372036854775807, -9223372036854775808), true);
+        assert_eq!(ne_si64(-9223372036854775807, -1741927215160008704), true);
+        assert_eq!(ne_si64(-9223372036854775807, -1328271339354574848), true);
+        assert_eq!(ne_si64(-9223372036854775807, 0), true);
+        assert_eq!(ne_si64(-9223372036854775807, 1), true);
+        assert_eq!(ne_si64(-9223372036854775807, 2), true);
+        assert_eq!(ne_si64(-9223372036854775807, 3), true);
+        assert_eq!(ne_si64(-9223372036854775807, 4), true);
+        assert_eq!(ne_si64(-9223372036854775807, 5577148965131116544), true);
+    }
+    #[test]
+    fn test_498() {
+        assert_eq!(ne_si64(-9223372036854775807, 9223372036854775806), true);
+        assert_eq!(ne_si64(-9223372036854775807, 9223372036854775807), true);
+        assert_eq!(ne_si64(-1741927215160008704, -9223372036854775808), true);
+        assert_eq!(ne_si64(-1741927215160008704, -9223372036854775807), true);
+        assert_eq!(ne_si64(-1741927215160008704, -1328271339354574848), true);
+        assert_eq!(ne_si64(-1741927215160008704, 0), true);
+        assert_eq!(ne_si64(-1741927215160008704, 1), true);
+        assert_eq!(ne_si64(-1741927215160008704, 2), true);
+        assert_eq!(ne_si64(-1741927215160008704, 3), true);
+        assert_eq!(ne_si64(-1741927215160008704, 4), true);
+    }
+    #[test]
+    fn test_499() {
+        assert_eq!(ne_si64(-1741927215160008704, 5577148965131116544), true);
+        assert_eq!(ne_si64(-1741927215160008704, 9223372036854775806), true);
+        assert_eq!(ne_si64(-1741927215160008704, 9223372036854775807), true);
+        assert_eq!(ne_si64(-1328271339354574848, -9223372036854775808), true);
+        assert_eq!(ne_si64(-1328271339354574848, -9223372036854775807), true);
+        assert_eq!(ne_si64(-1328271339354574848, -1741927215160008704), true);
+        assert_eq!(ne_si64(-1328271339354574848, 0), true);
+        assert_eq!(ne_si64(-1328271339354574848, 1), true);
+        assert_eq!(ne_si64(-1328271339354574848, 2), true);
+        assert_eq!(ne_si64(-1328271339354574848, 3), true);
+    }
+    #[test]
+    fn test_500() {
+        assert_eq!(ne_si64(-1328271339354574848, 4), true);
+        assert_eq!(ne_si64(-1328271339354574848, 5577148965131116544), true);
+        assert_eq!(ne_si64(-1328271339354574848, 9223372036854775806), true);
+        assert_eq!(ne_si64(-1328271339354574848, 9223372036854775807), true);
+        assert_eq!(ne_si64(0, -9223372036854775808), true);
+        assert_eq!(ne_si64(0, -9223372036854775807), true);
+        assert_eq!(ne_si64(0, -1741927215160008704), true);
+        assert_eq!(ne_si64(0, -1328271339354574848), true);
+        assert_eq!(ne_si64(0, 1), true);
+        assert_eq!(ne_si64(0, 2), true);
+    }
+    #[test]
+    fn test_501() {
+        assert_eq!(ne_si64(0, 3), true);
+        assert_eq!(ne_si64(0, 4), true);
+        assert_eq!(ne_si64(0, 5577148965131116544), true);
+        assert_eq!(ne_si64(0, 9223372036854775806), true);
+        assert_eq!(ne_si64(0, 9223372036854775807), true);
+        assert_eq!(ne_si64(1, -9223372036854775808), true);
+        assert_eq!(ne_si64(1, -9223372036854775807), true);
+        assert_eq!(ne_si64(1, -1741927215160008704), true);
+        assert_eq!(ne_si64(1, -1328271339354574848), true);
+        assert_eq!(ne_si64(1, 0), true);
+    }
+    #[test]
+    fn test_502() {
+        assert_eq!(ne_si64(1, 2), true);
+        assert_eq!(ne_si64(1, 3), true);
+        assert_eq!(ne_si64(1, 4), true);
+        assert_eq!(ne_si64(1, 5577148965131116544), true);
+        assert_eq!(ne_si64(1, 9223372036854775806), true);
+        assert_eq!(ne_si64(1, 9223372036854775807), true);
+        assert_eq!(ne_si64(2, -9223372036854775808), true);
+        assert_eq!(ne_si64(2, -9223372036854775807), true);
+        assert_eq!(ne_si64(2, -1741927215160008704), true);
+        assert_eq!(ne_si64(2, -1328271339354574848), true);
+    }
+    #[test]
+    fn test_503() {
+        assert_eq!(ne_si64(2, 0), true);
+        assert_eq!(ne_si64(2, 1), true);
+        assert_eq!(ne_si64(2, 3), true);
+        assert_eq!(ne_si64(2, 4), true);
+        assert_eq!(ne_si64(2, 5577148965131116544), true);
+        assert_eq!(ne_si64(2, 9223372036854775806), true);
+        assert_eq!(ne_si64(2, 9223372036854775807), true);
+        assert_eq!(ne_si64(3, -9223372036854775808), true);
+        assert_eq!(ne_si64(3, -9223372036854775807), true);
+        assert_eq!(ne_si64(3, -1741927215160008704), true);
+    }
+    #[test]
+    fn test_504() {
+        assert_eq!(ne_si64(3, -1328271339354574848), true);
+        assert_eq!(ne_si64(3, 0), true);
+        assert_eq!(ne_si64(3, 1), true);
+        assert_eq!(ne_si64(3, 2), true);
+        assert_eq!(ne_si64(3, 4), true);
+        assert_eq!(ne_si64(3, 5577148965131116544), true);
+        assert_eq!(ne_si64(3, 9223372036854775806), true);
+        assert_eq!(ne_si64(3, 9223372036854775807), true);
+        assert_eq!(ne_si64(4, -9223372036854775808), true);
+        assert_eq!(ne_si64(4, -9223372036854775807), true);
+    }
+    #[test]
+    fn test_505() {
+        assert_eq!(ne_si64(4, -1741927215160008704), true);
+        assert_eq!(ne_si64(4, -1328271339354574848), true);
+        assert_eq!(ne_si64(4, 0), true);
+        assert_eq!(ne_si64(4, 1), true);
+        assert_eq!(ne_si64(4, 2), true);
+        assert_eq!(ne_si64(4, 3), true);
+        assert_eq!(ne_si64(4, 5577148965131116544), true);
+        assert_eq!(ne_si64(4, 9223372036854775806), true);
+        assert_eq!(ne_si64(4, 9223372036854775807), true);
+        assert_eq!(ne_si64(5577148965131116544, -9223372036854775808), true);
+    }
+    #[test]
+    fn test_506() {
+        assert_eq!(ne_si64(5577148965131116544, -9223372036854775807), true);
+        assert_eq!(ne_si64(5577148965131116544, -1741927215160008704), true);
+        assert_eq!(ne_si64(5577148965131116544, -1328271339354574848), true);
+        assert_eq!(ne_si64(5577148965131116544, 0), true);
+        assert_eq!(ne_si64(5577148965131116544, 1), true);
+        assert_eq!(ne_si64(5577148965131116544, 2), true);
+        assert_eq!(ne_si64(5577148965131116544, 3), true);
+        assert_eq!(ne_si64(5577148965131116544, 4), true);
+        assert_eq!(ne_si64(5577148965131116544, 9223372036854775806), true);
+        assert_eq!(ne_si64(5577148965131116544, 9223372036854775807), true);
+    }
+    #[test]
+    fn test_507() {
+        assert_eq!(ne_si64(9223372036854775806, -9223372036854775808), true);
+        assert_eq!(ne_si64(9223372036854775806, -9223372036854775807), true);
+        assert_eq!(ne_si64(9223372036854775806, -1741927215160008704), true);
+        assert_eq!(ne_si64(9223372036854775806, -1328271339354574848), true);
+        assert_eq!(ne_si64(9223372036854775806, 0), true);
+        assert_eq!(ne_si64(9223372036854775806, 1), true);
+        assert_eq!(ne_si64(9223372036854775806, 2), true);
+        assert_eq!(ne_si64(9223372036854775806, 3), true);
+        assert_eq!(ne_si64(9223372036854775806, 4), true);
+        assert_eq!(ne_si64(9223372036854775806, 5577148965131116544), true);
+    }
+    #[test]
+    fn test_508() {
+        assert_eq!(ne_si64(9223372036854775806, 9223372036854775807), true);
+        assert_eq!(ne_si64(9223372036854775807, -9223372036854775808), true);
+        assert_eq!(ne_si64(9223372036854775807, -9223372036854775807), true);
+        assert_eq!(ne_si64(9223372036854775807, -1741927215160008704), true);
+        assert_eq!(ne_si64(9223372036854775807, -1328271339354574848), true);
+        assert_eq!(ne_si64(9223372036854775807, 0), true);
+        assert_eq!(ne_si64(9223372036854775807, 1), true);
+        assert_eq!(ne_si64(9223372036854775807, 2), true);
+        assert_eq!(ne_si64(9223372036854775807, 3), true);
+        assert_eq!(ne_si64(9223372036854775807, 4), true);
+    }
+    #[test]
+    fn test_509() {
+        assert_eq!(ne_si64(9223372036854775807, 5577148965131116544), true);
+        assert_eq!(ne_si64(9223372036854775807, 9223372036854775806), true);
+        assert_eq!(ne_si8(-128, -128), false);
+        assert_eq!(ne_si8(-127, -127), false);
+        assert_eq!(ne_si8(0, 0), false);
+        assert_eq!(ne_si8(1, 1), false);
+        assert_eq!(ne_si8(2, 2), false);
+        assert_eq!(ne_si8(3, 3), false);
+        assert_eq!(ne_si8(4, 4), false);
+        assert_eq!(ne_si8(16, 16), false);
+    }
+    #[test]
+    fn test_510() {
+        assert_eq!(ne_si8(126, 126), false);
+        assert_eq!(ne_si8(127, 127), false);
+        assert_eq!(ne_si8(-128, -127), true);
+        assert_eq!(ne_si8(-128, 0), true);
+        assert_eq!(ne_si8(-128, 1), true);
+        assert_eq!(ne_si8(-128, 2), true);
+        assert_eq!(ne_si8(-128, 3), true);
+        assert_eq!(ne_si8(-128, 4), true);
+        assert_eq!(ne_si8(-128, 16), true);
+        assert_eq!(ne_si8(-128, 126), true);
+    }
+    #[test]
+    fn test_511() {
+        assert_eq!(ne_si8(-128, 127), true);
+        assert_eq!(ne_si8(-127, -128), true);
+        assert_eq!(ne_si8(-127, 0), true);
+        assert_eq!(ne_si8(-127, 1), true);
+        assert_eq!(ne_si8(-127, 2), true);
+        assert_eq!(ne_si8(-127, 3), true);
+        assert_eq!(ne_si8(-127, 4), true);
+        assert_eq!(ne_si8(-127, 16), true);
+        assert_eq!(ne_si8(-127, 126), true);
+        assert_eq!(ne_si8(-127, 127), true);
+    }
+    #[test]
+    fn test_512() {
+        assert_eq!(ne_si8(0, -128), true);
+        assert_eq!(ne_si8(0, -127), true);
+        assert_eq!(ne_si8(0, 1), true);
+        assert_eq!(ne_si8(0, 2), true);
+        assert_eq!(ne_si8(0, 3), true);
+        assert_eq!(ne_si8(0, 4), true);
+        assert_eq!(ne_si8(0, 16), true);
+        assert_eq!(ne_si8(0, 126), true);
+        assert_eq!(ne_si8(0, 127), true);
+        assert_eq!(ne_si8(1, -128), true);
+    }
+    #[test]
+    fn test_513() {
+        assert_eq!(ne_si8(1, -127), true);
+        assert_eq!(ne_si8(1, 0), true);
+        assert_eq!(ne_si8(1, 2), true);
+        assert_eq!(ne_si8(1, 3), true);
+        assert_eq!(ne_si8(1, 4), true);
+        assert_eq!(ne_si8(1, 16), true);
+        assert_eq!(ne_si8(1, 126), true);
+        assert_eq!(ne_si8(1, 127), true);
+        assert_eq!(ne_si8(2, -128), true);
+        assert_eq!(ne_si8(2, -127), true);
+    }
+    #[test]
+    fn test_514() {
+        assert_eq!(ne_si8(2, 0), true);
+        assert_eq!(ne_si8(2, 1), true);
+        assert_eq!(ne_si8(2, 3), true);
+        assert_eq!(ne_si8(2, 4), true);
+        assert_eq!(ne_si8(2, 16), true);
+        assert_eq!(ne_si8(2, 126), true);
+        assert_eq!(ne_si8(2, 127), true);
+        assert_eq!(ne_si8(3, -128), true);
+        assert_eq!(ne_si8(3, -127), true);
+        assert_eq!(ne_si8(3, 0), true);
+    }
+    #[test]
+    fn test_515() {
+        assert_eq!(ne_si8(3, 1), true);
+        assert_eq!(ne_si8(3, 2), true);
+        assert_eq!(ne_si8(3, 4), true);
+        assert_eq!(ne_si8(3, 16), true);
+        assert_eq!(ne_si8(3, 126), true);
+        assert_eq!(ne_si8(3, 127), true);
+        assert_eq!(ne_si8(4, -128), true);
+        assert_eq!(ne_si8(4, -127), true);
+        assert_eq!(ne_si8(4, 0), true);
+        assert_eq!(ne_si8(4, 1), true);
+    }
+    #[test]
+    fn test_516() {
+        assert_eq!(ne_si8(4, 2), true);
+        assert_eq!(ne_si8(4, 3), true);
+        assert_eq!(ne_si8(4, 16), true);
+        assert_eq!(ne_si8(4, 126), true);
+        assert_eq!(ne_si8(4, 127), true);
+        assert_eq!(ne_si8(16, -128), true);
+        assert_eq!(ne_si8(16, -127), true);
+        assert_eq!(ne_si8(16, 0), true);
+        assert_eq!(ne_si8(16, 1), true);
+        assert_eq!(ne_si8(16, 2), true);
+    }
+    #[test]
+    fn test_517() {
+        assert_eq!(ne_si8(16, 3), true);
+        assert_eq!(ne_si8(16, 4), true);
+        assert_eq!(ne_si8(16, 126), true);
+        assert_eq!(ne_si8(16, 127), true);
+        assert_eq!(ne_si8(126, -128), true);
+        assert_eq!(ne_si8(126, -127), true);
+        assert_eq!(ne_si8(126, 0), true);
+        assert_eq!(ne_si8(126, 1), true);
+        assert_eq!(ne_si8(126, 2), true);
+        assert_eq!(ne_si8(126, 3), true);
+    }
+    #[test]
+    fn test_518() {
+        assert_eq!(ne_si8(126, 4), true);
+        assert_eq!(ne_si8(126, 16), true);
+        assert_eq!(ne_si8(126, 127), true);
+        assert_eq!(ne_si8(127, -128), true);
+        assert_eq!(ne_si8(127, -127), true);
+        assert_eq!(ne_si8(127, 0), true);
+        assert_eq!(ne_si8(127, 1), true);
+        assert_eq!(ne_si8(127, 2), true);
+        assert_eq!(ne_si8(127, 3), true);
+        assert_eq!(ne_si8(127, 4), true);
+    }
+    #[test]
+    fn test_519() {
+        assert_eq!(ne_si8(127, 16), true);
+        assert_eq!(ne_si8(127, 126), true);
+        assert_eq!(ne_ui16(0, 0), false);
+        assert_eq!(ne_ui16(1, 1), false);
+        assert_eq!(ne_ui16(2, 2), false);
+        assert_eq!(ne_ui16(3, 3), false);
+        assert_eq!(ne_ui16(4, 4), false);
+        assert_eq!(ne_ui16(1717, 1717), false);
+        assert_eq!(ne_ui16(17988, 17988), false);
+        assert_eq!(ne_ui16(65096, 65096), false);
+    }
+    #[test]
+    fn test_520() {
+        assert_eq!(ne_ui16(65534, 65534), false);
+        assert_eq!(ne_ui16(65535, 65535), false);
+        assert_eq!(ne_ui16(0, 1), true);
+        assert_eq!(ne_ui16(0, 2), true);
+        assert_eq!(ne_ui16(0, 3), true);
+        assert_eq!(ne_ui16(0, 4), true);
+        assert_eq!(ne_ui16(0, 1717), true);
+        assert_eq!(ne_ui16(0, 17988), true);
+        assert_eq!(ne_ui16(0, 65096), true);
+        assert_eq!(ne_ui16(0, 65534), true);
+    }
+    #[test]
+    fn test_521() {
+        assert_eq!(ne_ui16(0, 65535), true);
+        assert_eq!(ne_ui16(1, 0), true);
+        assert_eq!(ne_ui16(1, 2), true);
+        assert_eq!(ne_ui16(1, 3), true);
+        assert_eq!(ne_ui16(1, 4), true);
+        assert_eq!(ne_ui16(1, 1717), true);
+        assert_eq!(ne_ui16(1, 17988), true);
+        assert_eq!(ne_ui16(1, 65096), true);
+        assert_eq!(ne_ui16(1, 65534), true);
+        assert_eq!(ne_ui16(1, 65535), true);
+    }
+    #[test]
+    fn test_522() {
+        assert_eq!(ne_ui16(2, 0), true);
+        assert_eq!(ne_ui16(2, 1), true);
+        assert_eq!(ne_ui16(2, 3), true);
+        assert_eq!(ne_ui16(2, 4), true);
+        assert_eq!(ne_ui16(2, 1717), true);
+        assert_eq!(ne_ui16(2, 17988), true);
+        assert_eq!(ne_ui16(2, 65096), true);
+        assert_eq!(ne_ui16(2, 65534), true);
+        assert_eq!(ne_ui16(2, 65535), true);
+        assert_eq!(ne_ui16(3, 0), true);
+    }
+    #[test]
+    fn test_523() {
+        assert_eq!(ne_ui16(3, 1), true);
+        assert_eq!(ne_ui16(3, 2), true);
+        assert_eq!(ne_ui16(3, 4), true);
+        assert_eq!(ne_ui16(3, 1717), true);
+        assert_eq!(ne_ui16(3, 17988), true);
+        assert_eq!(ne_ui16(3, 65096), true);
+        assert_eq!(ne_ui16(3, 65534), true);
+        assert_eq!(ne_ui16(3, 65535), true);
+        assert_eq!(ne_ui16(4, 0), true);
+        assert_eq!(ne_ui16(4, 1), true);
+    }
+    #[test]
+    fn test_524() {
+        assert_eq!(ne_ui16(4, 2), true);
+        assert_eq!(ne_ui16(4, 3), true);
+        assert_eq!(ne_ui16(4, 1717), true);
+        assert_eq!(ne_ui16(4, 17988), true);
+        assert_eq!(ne_ui16(4, 65096), true);
+        assert_eq!(ne_ui16(4, 65534), true);
+        assert_eq!(ne_ui16(4, 65535), true);
+        assert_eq!(ne_ui16(1717, 0), true);
+        assert_eq!(ne_ui16(1717, 1), true);
+        assert_eq!(ne_ui16(1717, 2), true);
+    }
+    #[test]
+    fn test_525() {
+        assert_eq!(ne_ui16(1717, 3), true);
+        assert_eq!(ne_ui16(1717, 4), true);
+        assert_eq!(ne_ui16(1717, 17988), true);
+        assert_eq!(ne_ui16(1717, 65096), true);
+        assert_eq!(ne_ui16(1717, 65534), true);
+        assert_eq!(ne_ui16(1717, 65535), true);
+        assert_eq!(ne_ui16(17988, 0), true);
+        assert_eq!(ne_ui16(17988, 1), true);
+        assert_eq!(ne_ui16(17988, 2), true);
+        assert_eq!(ne_ui16(17988, 3), true);
+    }
+    #[test]
+    fn test_526() {
+        assert_eq!(ne_ui16(17988, 4), true);
+        assert_eq!(ne_ui16(17988, 1717), true);
+        assert_eq!(ne_ui16(17988, 65096), true);
+        assert_eq!(ne_ui16(17988, 65534), true);
+        assert_eq!(ne_ui16(17988, 65535), true);
+        assert_eq!(ne_ui16(65096, 0), true);
+        assert_eq!(ne_ui16(65096, 1), true);
+        assert_eq!(ne_ui16(65096, 2), true);
+        assert_eq!(ne_ui16(65096, 3), true);
+        assert_eq!(ne_ui16(65096, 4), true);
+    }
+    #[test]
+    fn test_527() {
+        assert_eq!(ne_ui16(65096, 1717), true);
+        assert_eq!(ne_ui16(65096, 17988), true);
+        assert_eq!(ne_ui16(65096, 65534), true);
+        assert_eq!(ne_ui16(65096, 65535), true);
+        assert_eq!(ne_ui16(65534, 0), true);
+        assert_eq!(ne_ui16(65534, 1), true);
+        assert_eq!(ne_ui16(65534, 2), true);
+        assert_eq!(ne_ui16(65534, 3), true);
+        assert_eq!(ne_ui16(65534, 4), true);
+        assert_eq!(ne_ui16(65534, 1717), true);
+    }
+    #[test]
+    fn test_528() {
+        assert_eq!(ne_ui16(65534, 17988), true);
+        assert_eq!(ne_ui16(65534, 65096), true);
+        assert_eq!(ne_ui16(65534, 65535), true);
+        assert_eq!(ne_ui16(65535, 0), true);
+        assert_eq!(ne_ui16(65535, 1), true);
+        assert_eq!(ne_ui16(65535, 2), true);
+        assert_eq!(ne_ui16(65535, 3), true);
+        assert_eq!(ne_ui16(65535, 4), true);
+        assert_eq!(ne_ui16(65535, 1717), true);
+        assert_eq!(ne_ui16(65535, 17988), true);
+    }
+    #[test]
+    fn test_529() {
+        assert_eq!(ne_ui16(65535, 65096), true);
+        assert_eq!(ne_ui16(65535, 65534), true);
+        assert_eq!(ne_ui32(0, 0), false);
+        assert_eq!(ne_ui32(1, 1), false);
+        assert_eq!(ne_ui32(2, 2), false);
+        assert_eq!(ne_ui32(3, 3), false);
+        assert_eq!(ne_ui32(4, 4), false);
+        assert_eq!(ne_ui32(2119154652, 2119154652), false);
+        assert_eq!(ne_ui32(3002788344, 3002788344), false);
+        assert_eq!(ne_ui32(3482297128, 3482297128), false);
+    }
+    #[test]
+    fn test_530() {
+        assert_eq!(ne_ui32(4294967294, 4294967294), false);
+        assert_eq!(ne_ui32(4294967295, 4294967295), false);
+        assert_eq!(ne_ui32(0, 1), true);
+        assert_eq!(ne_ui32(0, 2), true);
+        assert_eq!(ne_ui32(0, 3), true);
+        assert_eq!(ne_ui32(0, 4), true);
+        assert_eq!(ne_ui32(0, 2119154652), true);
+        assert_eq!(ne_ui32(0, 3002788344), true);
+        assert_eq!(ne_ui32(0, 3482297128), true);
+        assert_eq!(ne_ui32(0, 4294967294), true);
+    }
+    #[test]
+    fn test_531() {
+        assert_eq!(ne_ui32(0, 4294967295), true);
+        assert_eq!(ne_ui32(1, 0), true);
+        assert_eq!(ne_ui32(1, 2), true);
+        assert_eq!(ne_ui32(1, 3), true);
+        assert_eq!(ne_ui32(1, 4), true);
+        assert_eq!(ne_ui32(1, 2119154652), true);
+        assert_eq!(ne_ui32(1, 3002788344), true);
+        assert_eq!(ne_ui32(1, 3482297128), true);
+        assert_eq!(ne_ui32(1, 4294967294), true);
+        assert_eq!(ne_ui32(1, 4294967295), true);
+    }
+    #[test]
+    fn test_532() {
+        assert_eq!(ne_ui32(2, 0), true);
+        assert_eq!(ne_ui32(2, 1), true);
+        assert_eq!(ne_ui32(2, 3), true);
+        assert_eq!(ne_ui32(2, 4), true);
+        assert_eq!(ne_ui32(2, 2119154652), true);
+        assert_eq!(ne_ui32(2, 3002788344), true);
+        assert_eq!(ne_ui32(2, 3482297128), true);
+        assert_eq!(ne_ui32(2, 4294967294), true);
+        assert_eq!(ne_ui32(2, 4294967295), true);
+        assert_eq!(ne_ui32(3, 0), true);
+    }
+    #[test]
+    fn test_533() {
+        assert_eq!(ne_ui32(3, 1), true);
+        assert_eq!(ne_ui32(3, 2), true);
+        assert_eq!(ne_ui32(3, 4), true);
+        assert_eq!(ne_ui32(3, 2119154652), true);
+        assert_eq!(ne_ui32(3, 3002788344), true);
+        assert_eq!(ne_ui32(3, 3482297128), true);
+        assert_eq!(ne_ui32(3, 4294967294), true);
+        assert_eq!(ne_ui32(3, 4294967295), true);
+        assert_eq!(ne_ui32(4, 0), true);
+        assert_eq!(ne_ui32(4, 1), true);
+    }
+    #[test]
+    fn test_534() {
+        assert_eq!(ne_ui32(4, 2), true);
+        assert_eq!(ne_ui32(4, 3), true);
+        assert_eq!(ne_ui32(4, 2119154652), true);
+        assert_eq!(ne_ui32(4, 3002788344), true);
+        assert_eq!(ne_ui32(4, 3482297128), true);
+        assert_eq!(ne_ui32(4, 4294967294), true);
+        assert_eq!(ne_ui32(4, 4294967295), true);
+        assert_eq!(ne_ui32(2119154652, 0), true);
+        assert_eq!(ne_ui32(2119154652, 1), true);
+        assert_eq!(ne_ui32(2119154652, 2), true);
+    }
+    #[test]
+    fn test_535() {
+        assert_eq!(ne_ui32(2119154652, 3), true);
+        assert_eq!(ne_ui32(2119154652, 4), true);
+        assert_eq!(ne_ui32(2119154652, 3002788344), true);
+        assert_eq!(ne_ui32(2119154652, 3482297128), true);
+        assert_eq!(ne_ui32(2119154652, 4294967294), true);
+        assert_eq!(ne_ui32(2119154652, 4294967295), true);
+        assert_eq!(ne_ui32(3002788344, 0), true);
+        assert_eq!(ne_ui32(3002788344, 1), true);
+        assert_eq!(ne_ui32(3002788344, 2), true);
+        assert_eq!(ne_ui32(3002788344, 3), true);
+    }
+    #[test]
+    fn test_536() {
+        assert_eq!(ne_ui32(3002788344, 4), true);
+        assert_eq!(ne_ui32(3002788344, 2119154652), true);
+        assert_eq!(ne_ui32(3002788344, 3482297128), true);
+        assert_eq!(ne_ui32(3002788344, 4294967294), true);
+        assert_eq!(ne_ui32(3002788344, 4294967295), true);
+        assert_eq!(ne_ui32(3482297128, 0), true);
+        assert_eq!(ne_ui32(3482297128, 1), true);
+        assert_eq!(ne_ui32(3482297128, 2), true);
+        assert_eq!(ne_ui32(3482297128, 3), true);
+        assert_eq!(ne_ui32(3482297128, 4), true);
+    }
+    #[test]
+    fn test_537() {
+        assert_eq!(ne_ui32(3482297128, 2119154652), true);
+        assert_eq!(ne_ui32(3482297128, 3002788344), true);
+        assert_eq!(ne_ui32(3482297128, 4294967294), true);
+        assert_eq!(ne_ui32(3482297128, 4294967295), true);
+        assert_eq!(ne_ui32(4294967294, 0), true);
+        assert_eq!(ne_ui32(4294967294, 1), true);
+        assert_eq!(ne_ui32(4294967294, 2), true);
+        assert_eq!(ne_ui32(4294967294, 3), true);
+        assert_eq!(ne_ui32(4294967294, 4), true);
+        assert_eq!(ne_ui32(4294967294, 2119154652), true);
+    }
+    #[test]
+    fn test_538() {
+        assert_eq!(ne_ui32(4294967294, 3002788344), true);
+        assert_eq!(ne_ui32(4294967294, 3482297128), true);
+        assert_eq!(ne_ui32(4294967294, 4294967295), true);
+        assert_eq!(ne_ui32(4294967295, 0), true);
+        assert_eq!(ne_ui32(4294967295, 1), true);
+        assert_eq!(ne_ui32(4294967295, 2), true);
+        assert_eq!(ne_ui32(4294967295, 3), true);
+        assert_eq!(ne_ui32(4294967295, 4), true);
+        assert_eq!(ne_ui32(4294967295, 2119154652), true);
+        assert_eq!(ne_ui32(4294967295, 3002788344), true);
+    }
+    #[test]
+    fn test_539() {
+        assert_eq!(ne_ui32(4294967295, 3482297128), true);
+        assert_eq!(ne_ui32(4294967295, 4294967294), true);
+        assert_eq!(ne_ui64(0, 0), false);
+        assert_eq!(ne_ui64(1, 1), false);
+        assert_eq!(ne_ui64(2, 2), false);
+        assert_eq!(ne_ui64(3, 3), false);
+        assert_eq!(ne_ui64(4, 4), false);
+        assert_eq!(ne_ui64(191084152064409600, 191084152064409600), false);
+        assert_eq!(ne_ui64(11015955194427482112, 11015955194427482112), false);
+        assert_eq!(ne_ui64(16990600415051759616, 16990600415051759616), false);
+    }
+    #[test]
+    fn test_540() {
+        assert_eq!(ne_ui64(18446744073709551614, 18446744073709551614), false);
+        assert_eq!(ne_ui64(18446744073709551615, 18446744073709551615), false);
+        assert_eq!(ne_ui64(0, 1), true);
+        assert_eq!(ne_ui64(0, 2), true);
+        assert_eq!(ne_ui64(0, 3), true);
+        assert_eq!(ne_ui64(0, 4), true);
+        assert_eq!(ne_ui64(0, 191084152064409600), true);
+        assert_eq!(ne_ui64(0, 11015955194427482112), true);
+        assert_eq!(ne_ui64(0, 16990600415051759616), true);
+        assert_eq!(ne_ui64(0, 18446744073709551614), true);
+    }
+    #[test]
+    fn test_541() {
+        assert_eq!(ne_ui64(0, 18446744073709551615), true);
+        assert_eq!(ne_ui64(1, 0), true);
+        assert_eq!(ne_ui64(1, 2), true);
+        assert_eq!(ne_ui64(1, 3), true);
+        assert_eq!(ne_ui64(1, 4), true);
+        assert_eq!(ne_ui64(1, 191084152064409600), true);
+        assert_eq!(ne_ui64(1, 11015955194427482112), true);
+        assert_eq!(ne_ui64(1, 16990600415051759616), true);
+        assert_eq!(ne_ui64(1, 18446744073709551614), true);
+        assert_eq!(ne_ui64(1, 18446744073709551615), true);
+    }
+    #[test]
+    fn test_542() {
+        assert_eq!(ne_ui64(2, 0), true);
+        assert_eq!(ne_ui64(2, 1), true);
+        assert_eq!(ne_ui64(2, 3), true);
+        assert_eq!(ne_ui64(2, 4), true);
+        assert_eq!(ne_ui64(2, 191084152064409600), true);
+        assert_eq!(ne_ui64(2, 11015955194427482112), true);
+        assert_eq!(ne_ui64(2, 16990600415051759616), true);
+        assert_eq!(ne_ui64(2, 18446744073709551614), true);
+        assert_eq!(ne_ui64(2, 18446744073709551615), true);
+        assert_eq!(ne_ui64(3, 0), true);
+    }
+    #[test]
+    fn test_543() {
+        assert_eq!(ne_ui64(3, 1), true);
+        assert_eq!(ne_ui64(3, 2), true);
+        assert_eq!(ne_ui64(3, 4), true);
+        assert_eq!(ne_ui64(3, 191084152064409600), true);
+        assert_eq!(ne_ui64(3, 11015955194427482112), true);
+        assert_eq!(ne_ui64(3, 16990600415051759616), true);
+        assert_eq!(ne_ui64(3, 18446744073709551614), true);
+        assert_eq!(ne_ui64(3, 18446744073709551615), true);
+        assert_eq!(ne_ui64(4, 0), true);
+        assert_eq!(ne_ui64(4, 1), true);
+    }
+    #[test]
+    fn test_544() {
+        assert_eq!(ne_ui64(4, 2), true);
+        assert_eq!(ne_ui64(4, 3), true);
+        assert_eq!(ne_ui64(4, 191084152064409600), true);
+        assert_eq!(ne_ui64(4, 11015955194427482112), true);
+        assert_eq!(ne_ui64(4, 16990600415051759616), true);
+        assert_eq!(ne_ui64(4, 18446744073709551614), true);
+        assert_eq!(ne_ui64(4, 18446744073709551615), true);
+        assert_eq!(ne_ui64(191084152064409600, 0), true);
+        assert_eq!(ne_ui64(191084152064409600, 1), true);
+        assert_eq!(ne_ui64(191084152064409600, 2), true);
+    }
+    #[test]
+    fn test_545() {
+        assert_eq!(ne_ui64(191084152064409600, 3), true);
+        assert_eq!(ne_ui64(191084152064409600, 4), true);
+        assert_eq!(ne_ui64(191084152064409600, 11015955194427482112), true);
+        assert_eq!(ne_ui64(191084152064409600, 16990600415051759616), true);
+        assert_eq!(ne_ui64(191084152064409600, 18446744073709551614), true);
+        assert_eq!(ne_ui64(191084152064409600, 18446744073709551615), true);
+        assert_eq!(ne_ui64(11015955194427482112, 0), true);
+        assert_eq!(ne_ui64(11015955194427482112, 1), true);
+        assert_eq!(ne_ui64(11015955194427482112, 2), true);
+        assert_eq!(ne_ui64(11015955194427482112, 3), true);
+    }
+    #[test]
+    fn test_546() {
+        assert_eq!(ne_ui64(11015955194427482112, 4), true);
+        assert_eq!(ne_ui64(11015955194427482112, 191084152064409600), true);
+        assert_eq!(ne_ui64(11015955194427482112, 16990600415051759616), true);
+        assert_eq!(ne_ui64(11015955194427482112, 18446744073709551614), true);
+        assert_eq!(ne_ui64(11015955194427482112, 18446744073709551615), true);
+        assert_eq!(ne_ui64(16990600415051759616, 0), true);
+        assert_eq!(ne_ui64(16990600415051759616, 1), true);
+        assert_eq!(ne_ui64(16990600415051759616, 2), true);
+        assert_eq!(ne_ui64(16990600415051759616, 3), true);
+        assert_eq!(ne_ui64(16990600415051759616, 4), true);
+    }
+    #[test]
+    fn test_547() {
+        assert_eq!(ne_ui64(16990600415051759616, 191084152064409600), true);
+        assert_eq!(ne_ui64(16990600415051759616, 11015955194427482112), true);
+        assert_eq!(ne_ui64(16990600415051759616, 18446744073709551614), true);
+        assert_eq!(ne_ui64(16990600415051759616, 18446744073709551615), true);
+        assert_eq!(ne_ui64(18446744073709551614, 0), true);
+        assert_eq!(ne_ui64(18446744073709551614, 1), true);
+        assert_eq!(ne_ui64(18446744073709551614, 2), true);
+        assert_eq!(ne_ui64(18446744073709551614, 3), true);
+        assert_eq!(ne_ui64(18446744073709551614, 4), true);
+        assert_eq!(ne_ui64(18446744073709551614, 191084152064409600), true);
+    }
+    #[test]
+    fn test_548() {
+        assert_eq!(ne_ui64(18446744073709551614, 11015955194427482112), true);
+        assert_eq!(ne_ui64(18446744073709551614, 16990600415051759616), true);
+        assert_eq!(ne_ui64(18446744073709551614, 18446744073709551615), true);
+        assert_eq!(ne_ui64(18446744073709551615, 0), true);
+        assert_eq!(ne_ui64(18446744073709551615, 1), true);
+        assert_eq!(ne_ui64(18446744073709551615, 2), true);
+        assert_eq!(ne_ui64(18446744073709551615, 3), true);
+        assert_eq!(ne_ui64(18446744073709551615, 4), true);
+        assert_eq!(ne_ui64(18446744073709551615, 191084152064409600), true);
+        assert_eq!(ne_ui64(18446744073709551615, 11015955194427482112), true);
+    }
+    #[test]
+    fn test_549() {
+        assert_eq!(ne_ui64(18446744073709551615, 16990600415051759616), true);
+        assert_eq!(ne_ui64(18446744073709551615, 18446744073709551614), true);
+        assert_eq!(ne_ui8(0, 0), false);
+        assert_eq!(ne_ui8(1, 1), false);
+        assert_eq!(ne_ui8(2, 2), false);
+        assert_eq!(ne_ui8(3, 3), false);
+        assert_eq!(ne_ui8(4, 4), false);
+        assert_eq!(ne_ui8(72, 72), false);
+        assert_eq!(ne_ui8(100, 100), false);
+        assert_eq!(ne_ui8(162, 162), false);
+    }
+    #[test]
+    fn test_550() {
+        assert_eq!(ne_ui8(254, 254), false);
+        assert_eq!(ne_ui8(255, 255), false);
+        assert_eq!(ne_ui8(0, 1), true);
+        assert_eq!(ne_ui8(0, 2), true);
+        assert_eq!(ne_ui8(0, 3), true);
+        assert_eq!(ne_ui8(0, 4), true);
+        assert_eq!(ne_ui8(0, 72), true);
+        assert_eq!(ne_ui8(0, 100), true);
+        assert_eq!(ne_ui8(0, 162), true);
+        assert_eq!(ne_ui8(0, 254), true);
+    }
+    #[test]
+    fn test_551() {
+        assert_eq!(ne_ui8(0, 255), true);
+        assert_eq!(ne_ui8(1, 0), true);
+        assert_eq!(ne_ui8(1, 2), true);
+        assert_eq!(ne_ui8(1, 3), true);
+        assert_eq!(ne_ui8(1, 4), true);
+        assert_eq!(ne_ui8(1, 72), true);
+        assert_eq!(ne_ui8(1, 100), true);
+        assert_eq!(ne_ui8(1, 162), true);
+        assert_eq!(ne_ui8(1, 254), true);
+        assert_eq!(ne_ui8(1, 255), true);
+    }
+    #[test]
+    fn test_552() {
+        assert_eq!(ne_ui8(2, 0), true);
+        assert_eq!(ne_ui8(2, 1), true);
+        assert_eq!(ne_ui8(2, 3), true);
+        assert_eq!(ne_ui8(2, 4), true);
+        assert_eq!(ne_ui8(2, 72), true);
+        assert_eq!(ne_ui8(2, 100), true);
+        assert_eq!(ne_ui8(2, 162), true);
+        assert_eq!(ne_ui8(2, 254), true);
+        assert_eq!(ne_ui8(2, 255), true);
+        assert_eq!(ne_ui8(3, 0), true);
+    }
+    #[test]
+    fn test_553() {
+        assert_eq!(ne_ui8(3, 1), true);
+        assert_eq!(ne_ui8(3, 2), true);
+        assert_eq!(ne_ui8(3, 4), true);
+        assert_eq!(ne_ui8(3, 72), true);
+        assert_eq!(ne_ui8(3, 100), true);
+        assert_eq!(ne_ui8(3, 162), true);
+        assert_eq!(ne_ui8(3, 254), true);
+        assert_eq!(ne_ui8(3, 255), true);
+        assert_eq!(ne_ui8(4, 0), true);
+        assert_eq!(ne_ui8(4, 1), true);
+    }
+    #[test]
+    fn test_554() {
+        assert_eq!(ne_ui8(4, 2), true);
+        assert_eq!(ne_ui8(4, 3), true);
+        assert_eq!(ne_ui8(4, 72), true);
+        assert_eq!(ne_ui8(4, 100), true);
+        assert_eq!(ne_ui8(4, 162), true);
+        assert_eq!(ne_ui8(4, 254), true);
+        assert_eq!(ne_ui8(4, 255), true);
+        assert_eq!(ne_ui8(72, 0), true);
+        assert_eq!(ne_ui8(72, 1), true);
+        assert_eq!(ne_ui8(72, 2), true);
+    }
+    #[test]
+    fn test_555() {
+        assert_eq!(ne_ui8(72, 3), true);
+        assert_eq!(ne_ui8(72, 4), true);
+        assert_eq!(ne_ui8(72, 100), true);
+        assert_eq!(ne_ui8(72, 162), true);
+        assert_eq!(ne_ui8(72, 254), true);
+        assert_eq!(ne_ui8(72, 255), true);
+        assert_eq!(ne_ui8(100, 0), true);
+        assert_eq!(ne_ui8(100, 1), true);
+        assert_eq!(ne_ui8(100, 2), true);
+        assert_eq!(ne_ui8(100, 3), true);
+    }
+    #[test]
+    fn test_556() {
+        assert_eq!(ne_ui8(100, 4), true);
+        assert_eq!(ne_ui8(100, 72), true);
+        assert_eq!(ne_ui8(100, 162), true);
+        assert_eq!(ne_ui8(100, 254), true);
+        assert_eq!(ne_ui8(100, 255), true);
+        assert_eq!(ne_ui8(162, 0), true);
+        assert_eq!(ne_ui8(162, 1), true);
+        assert_eq!(ne_ui8(162, 2), true);
+        assert_eq!(ne_ui8(162, 3), true);
+        assert_eq!(ne_ui8(162, 4), true);
+    }
+    #[test]
+    fn test_557() {
+        assert_eq!(ne_ui8(162, 72), true);
+        assert_eq!(ne_ui8(162, 100), true);
+        assert_eq!(ne_ui8(162, 254), true);
+        assert_eq!(ne_ui8(162, 255), true);
+        assert_eq!(ne_ui8(254, 0), true);
+        assert_eq!(ne_ui8(254, 1), true);
+        assert_eq!(ne_ui8(254, 2), true);
+        assert_eq!(ne_ui8(254, 3), true);
+        assert_eq!(ne_ui8(254, 4), true);
+        assert_eq!(ne_ui8(254, 72), true);
+    }
+    #[test]
+    fn test_558() {
+        assert_eq!(ne_ui8(254, 100), true);
+        assert_eq!(ne_ui8(254, 162), true);
+        assert_eq!(ne_ui8(254, 255), true);
+        assert_eq!(ne_ui8(255, 0), true);
+        assert_eq!(ne_ui8(255, 1), true);
+        assert_eq!(ne_ui8(255, 2), true);
+        assert_eq!(ne_ui8(255, 3), true);
+        assert_eq!(ne_ui8(255, 4), true);
+        assert_eq!(ne_ui8(255, 72), true);
+        assert_eq!(ne_ui8(255, 100), true);
+    }
+    #[test]
+    fn test_559() {
+        assert_eq!(ne_ui8(255, 162), true);
+        assert_eq!(ne_ui8(255, 254), true);
+    }
 }
diff --git a/arc-mlir/src/tests/arc-to-rust/bool-ops.mlir b/arc-mlir/src/tests/arc-to-rust/bool-ops.mlir
index 3b5a9c78a..57d7c9921 100644
--- a/arc-mlir/src/tests/arc-to-rust/bool-ops.mlir
+++ b/arc-mlir/src/tests/arc-to-rust/bool-ops.mlir
@@ -15,11 +15,11 @@ module @toplevel {
     %0 = arith.xori %arg0, %arg1 : i1
     return %0 : i1
   }
-  func.func @eq_i1(%a : i1, %b : i1) -> i1 attributes {rust.declare} {
+  func.func @eq_i1(%a : i1, %b : i1) -> i1 {
     %r = arith.cmpi "eq", %a, %b : i1
     return %r : i1
   }
-  func.func @ne_i1(%a : i1, %b : i1) -> i1 attributes {rust.declare} {
+  func.func @ne_i1(%a : i1, %b : i1) -> i1 {
     %r = arith.cmpi "ne", %a, %b : i1
     return %r : i1
   }
diff --git a/arc-mlir/src/tests/arc-to-rust/bool-ops.mlir.rust-tests b/arc-mlir/src/tests/arc-to-rust/bool-ops.mlir.rust-tests
index 62f30c9b6..61a9a27fd 100644
--- a/arc-mlir/src/tests/arc-to-rust/bool-ops.mlir.rust-tests
+++ b/arc-mlir/src/tests/arc-to-rust/bool-ops.mlir.rust-tests
@@ -1,24 +1,23 @@
 #[cfg(test)]
 mod tests {
 
-  use crate::toplevel::*;
-  #[rewrite(main)]
-  #[test]
-  fn it_works() {
-    assert_eq!(call!(and_i1(true, true)), true);
-    assert_eq!(call!(or_i1(false, true)), true);
-    assert_eq!(call!(xor_i1(true, true)), false);
-    assert_eq!(call!(eq_i1(true, true)), true);
-    assert_eq!(call!(eq_i1(false, true)), false);
-    assert_eq!(call!(eq_i1(true, false)), false);
-    assert_eq!(call!(eq_i1(false, false)), true);
-    assert_eq!(call!(ne_i1(true, true)), false);
-    assert_eq!(call!(ne_i1(false, true)), true);
-    assert_eq!(call!(ne_i1(true, false)), true);
-    assert_eq!(call!(ne_i1(false, false)), false);
-    assert_eq!(call!(not_i1(false)), true);
-    assert_eq!(call!(not_i1(true)), false);
-    assert_eq!(call!(not_select_i1(false)), true);
-    assert_eq!(call!(not_select_i1(true)), false);
-  }
+    use crate::toplevel::*;
+    #[test]
+    fn it_works() {
+        assert_eq!(and_i1(true, true), true);
+        assert_eq!(or_i1(false, true), true);
+        assert_eq!(xor_i1(true, true), false);
+        assert_eq!(eq_i1(true, true), true);
+        assert_eq!(eq_i1(false, true), false);
+        assert_eq!(eq_i1(true, false), false);
+        assert_eq!(eq_i1(false, false), true);
+        assert_eq!(ne_i1(true, true), false);
+        assert_eq!(ne_i1(false, true), true);
+        assert_eq!(ne_i1(true, false), true);
+        assert_eq!(ne_i1(false, false), false);
+        assert_eq!(not_i1(false), true);
+        assert_eq!(not_i1(true), false);
+        assert_eq!(not_select_i1(false), true);
+        assert_eq!(not_select_i1(true), false);
+    }
 }
diff --git a/arc-mlir/src/tests/arc-to-rust/calls-streams.mlir b/arc-mlir/src/tests/arc-to-rust/calls-streams.mlir
deleted file mode 100644
index 82254d42a..000000000
--- a/arc-mlir/src/tests/arc-to-rust/calls-streams.mlir
+++ /dev/null
@@ -1,17 +0,0 @@
-// XFAIL: *
-// RUN: arc-mlir-rust-test %t %s -rustinclude %s.rust-tests
-// RUN: arc-mlir-rust-test %t-canon %s -rustinclude %s.rust-tests -canonicalize
-// RUN: arc-mlir-rust-test %t-roundtrip-scf %s -rustinclude %s.rust-tests -canonicalize -remove-scf -canonicalize -to-scf -canonicalize
-
-module @toplevel {
-
-  func.func private @crate_Identity() -> ((!arc.stream.source<!arc.struct<key: si32, value: si32>>) -> !arc.stream.source<!arc.struct<key: si32, value: si32>>)
-
-    func.func @crate_main(%input_0: !arc.stream.source<!arc.struct<key: si32, value: si32>>) -> !arc.stream.source<!arc.struct<key: si32, value: si32>> {
-        %x_8 = constant @crate_Identity : () -> ((!arc.stream.source<!arc.struct<key: si32, value: si32>>) -> !arc.stream.source<!arc.struct<key: si32, value: si32>>)
-        %x_9 = call_indirect %x_8() : () -> ((!arc.stream.source<!arc.struct<key: si32, value: si32>>) -> !arc.stream.source<!arc.struct<key: si32, value: si32>>)
-        %x_A = call_indirect %x_9(%input_0) : (!arc.stream.source<!arc.struct<key: si32, value: si32>>) -> !arc.stream.source<!arc.struct<key: si32, value: si32>>
-        return %x_A : !arc.stream.source<!arc.struct<key: si32, value: si32>>
-    }
-
-}
diff --git a/arc-mlir/src/tests/arc-to-rust/calls-streams.mlir.rust-tests b/arc-mlir/src/tests/arc-to-rust/calls-streams.mlir.rust-tests
deleted file mode 100644
index cdfd9dc21..000000000
--- a/arc-mlir/src/tests/arc-to-rust/calls-streams.mlir.rust-tests
+++ /dev/null
@@ -1,17 +0,0 @@
-use arc_runtime::data::channels::local::multicast::Pullable;
-use arc_runtime::data::channels::local::multicast::Pushable;
-
-#[rewrite]
-pub fn an_external_fun2(i : Pullable<Struct3keyi325valuei32End>) -> Pullable<Struct3keyi325valuei32End> {
-  return i;
-}
-
-#[rewrite]
-pub fn crate_Identity() -> function!((Pullable<Struct3keyi325valuei32End>) -> Pullable<Struct3keyi325valuei32End>) {
-  return an_external_fun2;
-}
-
-#[cfg(test)]
-mod tests {
-  use crate::toplevel::*;
-}
diff --git a/arc-mlir/src/tests/arc-to-rust/calls.mlir b/arc-mlir/src/tests/arc-to-rust/calls.mlir
index 4d8adf8c9..23c949b73 100644
--- a/arc-mlir/src/tests/arc-to-rust/calls.mlir
+++ b/arc-mlir/src/tests/arc-to-rust/calls.mlir
@@ -4,39 +4,38 @@
 
 module @toplevel {
 
-  func.func @callee_void_void() -> () attributes { rust.declare } {
+  func.func @callee_void_void() -> () {
     return
   }
 
-  func.func @callee_si32_si32(%in : si32) -> si32 attributes { rust.declare } {
+  func.func @callee_si32_si32(%in : si32) -> si32 {
     return %in : si32
   }
 
-  func.func @callee_si32_x2_si32(%a : si32, %b : si32) -> si32 attributes { rust.declare } {
+  func.func @callee_si32_x2_si32(%a : si32, %b : si32) -> si32 {
     return %b : si32
   }
 
   func.func @callee_struct(%in : !arc.struct<foo : si32>)
-       -> !arc.struct<foo : si32> attributes { rust.declare } {
+       -> !arc.struct<foo : si32> {
     return %in : !arc.struct<foo : si32>
   }
 
-  func.func @caller0() -> () attributes { rust.declare }  {
+  func.func @caller0() -> ()  {
     call @callee_void_void() : () -> ()
     return
   }
 
-  func.func @caller1(%in : si32) -> (si32) attributes { rust.declare }  {
+  func.func @caller1(%in : si32) -> (si32)  {
     %r = call @callee_si32_si32(%in) : (si32) -> si32
     return %r : si32
   }
 
-  func.func @caller2(%in0 : si32, %in1 : si32) -> (si32) attributes { rust.declare }  {
+  func.func @caller2(%in0 : si32, %in1 : si32) -> (si32)  {
     %r = call @callee_si32_x2_si32(%in0, %in1) : (si32,si32) -> si32
     return %r : si32
   }
 
-
   func.func @caller_struct(%in : !arc.struct<foo : si32>)
        -> !arc.struct<foo : si32> {
     %r = call @callee_struct(%in) : (!arc.struct<foo : si32>)
@@ -45,12 +44,12 @@ module @toplevel {
   }
 
   func.func @enumfun(%in : !arc.enum<ea : si32, eb : f32>)
-       -> !arc.enum<ea : si32, eb : f32> attributes { rust.declare } {
+       -> !arc.enum<ea : si32, eb : f32> {
     return %in : !arc.enum<ea : si32, eb : f32>
   }
 
   func.func @indir_call1(%in : !arc.enum<ea : si32, eb : f32>)
-       -> !arc.enum<ea : si32, eb : f32> attributes { rust.declare } {
+       -> !arc.enum<ea : si32, eb : f32> {
     %f = constant @enumfun : (!arc.enum<ea : si32, eb : f32>)
          -> !arc.enum<ea : si32, eb : f32>
     %r = call_indirect %f(%in) : (!arc.enum<ea : si32, eb : f32>)
@@ -58,52 +57,35 @@ module @toplevel {
     return %r : !arc.enum<ea : si32, eb : f32>
   }
 
-  // func.func @tensorfun(%in : tensor<5xi32>)
-  //      -> tensor<5xi32> attributes { rust.declare } {
-  //   return %in : tensor<5xi32>
-  // }
-
-  // func.func @indir_call2(%in : tensor<5xi32>)
-  //      -> tensor<5xi32> attributes { rust.declare } {
-  //   %f = constant @tensorfun : (tensor<5xi32>)
-  //        -> tensor<5xi32>
-  //   %r = call_indirect %f(%in) : (tensor<5xi32>)
-  //        -> tensor<5xi32>
-  //   return %r : tensor<5xi32>
-  // }
-
-  func.func private @an_external_fun0(si32) -> f32 attributes { rust.declare }
-
-  func.func @call_external0(%in : si32) -> f32 attributes { rust.declare } {
+  func.func private @an_external_fun0(si32) -> f32 
+  func.func @call_external0(%in : si32) -> f32 {
     %r = call @an_external_fun0(%in) : (si32) -> f32
     return %r : f32
   }
 
-  func.func @call_external_indirect0(%in : si32) -> f32 attributes { rust.declare } {
+  func.func @call_external_indirect0(%in : si32) -> f32 {
     %f = constant @an_external_fun0 : (si32) -> f32
     %r = call_indirect %f(%in) : (si32) -> f32
     return %r : f32
   }
 
-  // TODO: Try to find a way to support returning functions into Arc-Lang
-  // func private @an_external_fun1() -> ((si32) -> si32) attributes { rust.declare }
-
-  // func.func @call_external1(%in : si32) -> si32 attributes { rust.declare } {
-  //   %f = call @an_external_fun1() : () -> ((si32) -> si32)
-  //   %r = call_indirect %f(%in) : (si32) -> si32
-  //   return %r : si32
-  // }
+  func.func private @an_external_fun1() -> ((si32) -> si32) 
+  func.func @call_external1(%in : si32) -> si32 {
+    %f = call @an_external_fun1() : () -> ((si32) -> si32)
+    %r = call_indirect %f(%in) : (si32) -> si32
+    return %r : si32
+  }
 
-  // func.func @call_external_indirect1(%in : si32) -> si32 attributes { rust.declare } {
-  //   %thunk = constant @an_external_fun1 : () -> ((si32) -> si32)
-  //   %f = call_indirect %thunk() : () -> ((si32) -> si32)
-  //   %r = call_indirect %f(%in) : (si32) -> si32
-  //   return %r : si32
-  // }
+  func.func @call_external_indirect1(%in : si32) -> si32 {
+    %thunk = constant @an_external_fun1 : () -> ((si32) -> si32)
+    %f = call_indirect %thunk() : () -> ((si32) -> si32)
+    %r = call_indirect %f(%in) : (si32) -> si32
+    return %r : si32
+  }
 
-  func.func private @an_external_fun_with_other_name0(si32) -> si32 attributes { rust.declare, "arc.rust_name" = "the_name_on_the_rust_side" }
+  func.func private @an_external_fun_with_other_name0(si32) -> si32 attributes { "arc.rust_name" = "the_name_on_the_rust_side" }
 
-  func.func @call_external2(%in : si32) -> si32 attributes { rust.declare } {
+  func.func @call_external2(%in : si32) -> si32 {
     %r = call @an_external_fun_with_other_name0(%in) : (si32) -> si32
     return %r : si32
   }
@@ -113,19 +95,8 @@ module @toplevel {
     return %in : si32
   }
 
-  func.func @call_renamed_local(%in : si32) -> si32 attributes { rust.declare } {
+  func.func @call_renamed_local(%in : si32) -> si32 {
     %r = call @a_function_called_something_else_in_rust(%in) : (si32) -> si32
     return %r : si32
   }
-
-  // func private @an_external_fun3(si32) -> si32 attributes { rust.declare }
-
-  // Async functions
-  func.func private @an_external_async_fun() -> si32 attributes { rust.async }
-
-  func.func @call_external_async() -> si32 attributes { rust.declare, rust.async } {
-    %r = call @an_external_async_fun() : () -> si32
-    return %r : si32
-  }
-
 }
diff --git a/arc-mlir/src/tests/arc-to-rust/calls.mlir.rust-tests b/arc-mlir/src/tests/arc-to-rust/calls.mlir.rust-tests
index 57b7cb30c..9b42a7198 100644
--- a/arc-mlir/src/tests/arc-to-rust/calls.mlir.rust-tests
+++ b/arc-mlir/src/tests/arc-to-rust/calls.mlir.rust-tests
@@ -1,37 +1,26 @@
-#[rewrite]
 pub fn an_external_fun0(i: i32) -> f32 {
-  return 3.14;
+    return 3.14;
 }
 
-#[rewrite]
 pub fn an_external_fun3(i: i32) -> i32 {
-  return i;
+    return i;
 }
 
-// TODO: Try to find a way to support returning functions into Arc-Lang
-// #[rewrite]
-// pub fn an_external_fun1() -> function!((i32) -> i32) {
-//   return function!(an_external_fun3);
-// }
-
-#[rewrite]
-pub fn the_name_on_the_rust_side(i: i32) -> i32 {
-  return i;
+pub fn an_external_fun1() -> fn(i32) -> i32 {
+    return an_external_fun3;
 }
 
-#[rewrite]
-pub async fn an_external_async_fun() -> i32 {
-  return 1;
+pub fn the_name_on_the_rust_side(i: i32) -> i32 {
+    return i;
 }
 
 use super::*;
-#[rewrite(main)]
 #[test]
 fn test() {
-    assert_eq!(call!(callee_si32_si32(17)), 17);
-    assert_eq!(call!(caller1(4711)), 4711);
-    assert_eq!(call!(call_external2(13)), 13);
-    assert_eq!(call!(call_renamed_local(14)), 14);
-    assert_eq!(call!(defined_in_arc(15)), 15);
-    assert_eq!(block_on(call!(call_external_async())), 1);
+    assert_eq!(callee_si32_si32(17), 17);
+    assert_eq!(caller1(4711), 4711);
+    assert_eq!(call_external2(13), 13);
+    assert_eq!(call_renamed_local(14), 14);
+    assert_eq!(defined_in_arc(15), 15);
+    assert_eq!(block_on(call_external_async()), 1);
 }
diff --git a/arc-mlir/src/tests/arc-to-rust/enums.mlir.rust-tests b/arc-mlir/src/tests/arc-to-rust/enums.mlir.rust-tests
index 5b8036712..a07460991 100644
--- a/arc-mlir/src/tests/arc-to-rust/enums.mlir.rust-tests
+++ b/arc-mlir/src/tests/arc-to-rust/enums.mlir.rust-tests
@@ -1,25 +1,24 @@
 // Empty
 #[cfg(test)]
 mod tests {
-  use crate::toplevel::*;
-  #[rewrite(main)]
-  #[test]
-  fn it_works() {
-    assert_eq!(is!(Enum1ai321bf32End::a, call!(ok0())), true);
-    assert_eq!(is!(Enum1ai321bf32End::b, call!(ok1())), true);
-    assert_eq!(is!(Enum1ai32End::a, call!(ok2())), true);
-    assert_eq!(is!(Enum1ai321bEnum1ai32EndEnd::a, call!(ok3())), true);
-    assert_eq!(is!(Enum1ai321bEnum1ai32EndEnd::b, call!(ok4())), true);
-    let c0 : i32 = 17;
-    let tmp0 :Enum1ai321bf32End  = enwrap!(Enum1ai321bf32End::a, c0);
-    let c1 : f32 = 17.0;
-    let tmp1 : Enum1ai321bf32End = enwrap!(Enum1ai321bf32End::b, c1);
-    assert_eq!(call!(access0(tmp0)), c0);
-    assert_eq!(call!(access1(tmp1)), c1);
+    use crate::toplevel::*;
+    #[test]
+    fn it_works() {
+        assert_eq!(matches!(ok0(), Enum1ai321bf32End::a(_)), true);
+        assert_eq!(matches!(ok1(), Enum1ai321bf32End::b(_)), true);
+        assert_eq!(matches!(ok2(), Enum1ai32End::a(_)), true);
+        assert_eq!(matches!(ok3(), Enum1ai321bEnum1ai32EndEnd::a(_)), true);
+        assert_eq!(matches!(ok4(), Enum1ai321bEnum1ai32EndEnd::b(_)), true);
+        let c0: i32 = 17;
+        let tmp0: Enum1ai321bf32End = Enum1ai321bf32End::a(c0);
+        let c1: f32 = 17.0;
+        let tmp1: Enum1ai321bf32End = Enum1ai321bf32End::b(c1);
+        assert_eq!(access0(tmp0), c0);
+        assert_eq!(access1(tmp1), c1);
 
-    let c2 : Enum1ai321bf32End = enwrap!(Enum1ai321bf32End::b, 3.14);
-    let c3 : Enum1ai321bf32End = enwrap!(Enum1ai321bf32End::a, 3);
-    assert_eq!(call!(check0(c2)), false);
-    assert_eq!(call!(check0(c3)), true);
-  }
+        let c2: Enum1ai321bf32End = Enum1ai321bf32End::b(3.14);
+        let c3: Enum1ai321bf32End = Enum1ai321bf32End::a(3);
+        assert_eq!(check0(c2), false);
+        assert_eq!(check0(c3), true);
+    }
 }
diff --git a/arc-mlir/src/tests/arc-to-rust/float-tensor-arith.mlir.rust-tests b/arc-mlir/src/tests/arc-to-rust/float-tensor-arith.mlir.rust-tests
deleted file mode 100644
index a11ac400b..000000000
--- a/arc-mlir/src/tests/arc-to-rust/float-tensor-arith.mlir.rust-tests
+++ /dev/null
@@ -1,59 +0,0 @@
-#[cfg(test)]
-mod tests {
-    use crate::arctorustfloattensorarith::*;
-    use ndarray::{Array,Dim,Ix};
-    use std::rc::Rc;
-
-    #[rewrite(main)]
-    #[test]
-    fn testf32() {
-	let a32:Rc<Array<f32, Dim<[Ix; 2]>>> =
-	    Rc::new(Array::from_shape_vec((2, 2),
-					  vec![1.0, 2.0, 3.0, 4.0]).unwrap());
-	let b32:Rc<Array<f32, Dim<[Ix; 2]>>> =
-	    Rc::new(Array::from_shape_vec((2, 2),
-					  vec![5.0, 6.0, 7.0, 8.0]).unwrap());
-	assert_eq!(*addf_tensor2x2xf32(Rc::clone(&a32),
-					      Rc::clone(&b32)),
-		   &*a32 + &*b32);
-	assert_eq!(*subf_tensor2x2xf32(Rc::clone(&a32),
-					      Rc::clone(&b32)),
-		   &*a32 - &*b32);
-	assert_eq!(*mulf_tensor2x2xf32(Rc::clone(&a32),
-					      Rc::clone(&b32)),
-		   &*a32 * &*b32);
-	assert_eq!(*divf_tensor2x2xf32(Rc::clone(&a32),
-					      Rc::clone(&b32)),
-		   &*a32 / &*b32);
-	assert_eq!(*remf_tensor2x2xf32(Rc::clone(&a32),
-					      Rc::clone(&b32)),
-		   &*a32 % &*b32);
-    }
-
-#[rewrite(main)]
-    #[test]
-    fn testf64() {
-	let a64:Rc<Array<f64, Dim<[Ix; 2]>>> =
-	    Rc::new(Array::from_shape_vec((2, 2),
-					  vec![1.0, 2.0, 3.0, 4.0]).unwrap());
-	let b64:Rc<Array<f64, Dim<[Ix; 2]>>> =
-	    Rc::new(Array::from_shape_vec((2, 2),
-					  vec![5.0, 6.0, 7.0, 8.0]).unwrap());
-	assert_eq!(*addf_tensor2x2xf64(Rc::clone(&a64),
-					      Rc::clone(&b64)),
-		   &*a64 + &*b64);
-	assert_eq!(*subf_tensor2x2xf64(Rc::clone(&a64),
-					      Rc::clone(&b64)),
-		   &*a64 - &*b64);
-	assert_eq!(*mulf_tensor2x2xf64(Rc::clone(&a64),
-					      Rc::clone(&b64)),
-		   &*a64 * &*b64);
-	assert_eq!(*divf_tensor2x2xf64(Rc::clone(&a64),
-					      Rc::clone(&b64)),
-		   &*a64 / &*b64);
-	assert_eq!(*remf_tensor2x2xf64(Rc::clone(&a64),
-					      Rc::clone(&b64)),
-		   &*a64 % &*b64);
-  }
-
-}
diff --git a/arc-mlir/src/tests/arc-to-rust/foreign-calls.mlir.rust-tests b/arc-mlir/src/tests/arc-to-rust/foreign-calls.mlir.rust-tests
index be8dcaeed..d723f6f83 100644
--- a/arc-mlir/src/tests/arc-to-rust/foreign-calls.mlir.rust-tests
+++ b/arc-mlir/src/tests/arc-to-rust/foreign-calls.mlir.rust-tests
@@ -1,17 +1,13 @@
-#[rewrite]
 pub fn callee_void_void() {}
 
-#[rewrite]
 pub fn callee_si32_si32(x: i32) -> i32 {
-    return x
+    return x;
 }
 
-#[rewrite]
-pub fn callee_si32_x2_si32(a : i32, b : i32) -> i32 {
-    return a + b
+pub fn callee_si32_x2_si32(a: i32, b: i32) -> i32 {
+    return a + b;
 }
 
-#[rewrite]
-pub fn callee_struct(x : Struct3foo3i32End) -> Struct3foo3i32End {
-    return x
+pub fn callee_struct(x: Struct3foo3i32End) -> Struct3foo3i32End {
+    return x;
 }
diff --git a/arc-mlir/src/tests/arc-to-rust/func-arguments.mlir.rust-tests b/arc-mlir/src/tests/arc-to-rust/func-arguments.mlir.rust-tests
index fa7bd905d..fcbf90aaf 100644
--- a/arc-mlir/src/tests/arc-to-rust/func-arguments.mlir.rust-tests
+++ b/arc-mlir/src/tests/arc-to-rust/func-arguments.mlir.rust-tests
@@ -1,11 +1,10 @@
 #[cfg(test)]
 mod tests {
-use crate::arctorustfuncarguments::*;
-#[rewrite(main)]
-#[test]
-  fn it_works() {
-   assert_eq!(call!(zero_args()), 4711);
-   assert_eq!(call!(one_arg(4711)), 4711);
-   assert_eq!(call!(two_args(4712, 4711)), 4711);
-  }
+    use crate::arctorustfuncarguments::*;
+    #[test]
+    fn it_works() {
+        assert_eq!(zero_args(), 4711);
+        assert_eq!(one_arg(4711), 4711);
+        assert_eq!(two_args(4712, 4711), 4711);
+    }
 }
diff --git a/arc-mlir/src/tests/arc-to-rust/ifs.mlir.rust-tests b/arc-mlir/src/tests/arc-to-rust/ifs.mlir.rust-tests
index d14170b60..efa1c7fb4 100644
--- a/arc-mlir/src/tests/arc-to-rust/ifs.mlir.rust-tests
+++ b/arc-mlir/src/tests/arc-to-rust/ifs.mlir.rust-tests
@@ -1,18 +1,17 @@
 #[cfg(test)]
 mod tests {
-  use crate::arctorustifs::*;
-  #[rewrite(main)]
-  #[test]
-  fn test() {
-    assert_eq!(call!(test_0()), 65);
-    assert_eq!(call!(test_1(true, 0, 1)), 0);
-    assert_eq!(call!(test_1(false, 0, 1)), 1);
-    assert_eq!(call!(test_1(true, 1, 0)), 1);
-    assert_eq!(call!(test_1(false, 1, 0)), 0);
+    use crate::arctorustifs::*;
+    #[test]
+    fn test() {
+        assert_eq!(test_0(), 65);
+        assert_eq!(test_1(true, 0, 1), 0);
+        assert_eq!(test_1(false, 0, 1), 1);
+        assert_eq!(test_1(true, 1, 0), 1);
+        assert_eq!(test_1(false, 1, 0), 0);
 
-    assert_eq!(call!(test_3(true, 0, 1)), 0);
-    assert_eq!(call!(test_3(false, 0, 1)), 1);
-    assert_eq!(call!(test_3(true, 1, 0)), 1);
-    assert_eq!(call!(test_3(false, 1, 0)), 0);
-  }
+        assert_eq!(test_3(true, 0, 1), 0);
+        assert_eq!(test_3(false, 0, 1), 1);
+        assert_eq!(test_3(true, 1, 0), 1);
+        assert_eq!(test_3(false, 1, 0), 0);
+    }
 }
diff --git a/arc-mlir/src/tests/arc-to-rust/int-arith.mlir b/arc-mlir/src/tests/arc-to-rust/int-arith.mlir
index d4becd181..8511adadb 100644
--- a/arc-mlir/src/tests/arc-to-rust/int-arith.mlir
+++ b/arc-mlir/src/tests/arc-to-rust/int-arith.mlir
@@ -2,204 +2,203 @@
 // RUN: arc-mlir-rust-test %t-roundtrip-scf %s -rustinclude %s.rust-tests -canonicalize -remove-scf -canonicalize -to-scf -canonicalize
 
 module @arctorustintarith {
-func.func @addi_ui8(%a : ui8, %b : ui8) -> ui8 {
-  %c = arc.addi %a, %b : ui8
-  return %c : ui8
-}
-
-func.func @subi_ui8(%a : ui8, %b : ui8) -> ui8 {
-  %c = arc.subi %a, %b : ui8
-  return %c : ui8
-}
-
-func.func @muli_ui8(%a : ui8, %b : ui8) -> ui8 {
-  %c = arc.muli %a, %b : ui8
-  return %c : ui8
-}
-
-func.func @divi_ui8(%a : ui8, %b : ui8) -> ui8 {
-  %c = arc.divi %a, %b : ui8
-  return %c : ui8
-}
-
-func.func @remi_ui8(%a : ui8, %b : ui8) -> ui8 {
-  %c = arc.remi %a, %b : ui8
-  return %c : ui8
-}
-
-func.func @addi_ui16(%a : ui16, %b : ui16) -> ui16 {
-  %c = arc.addi %a, %b : ui16
-  return %c : ui16
-}
-
-func.func @subi_ui16(%a : ui16, %b : ui16) -> ui16 {
-  %c = arc.subi %a, %b : ui16
-  return %c : ui16
-}
-
-func.func @muli_ui16(%a : ui16, %b : ui16) -> ui16 {
-  %c = arc.muli %a, %b : ui16
-  return %c : ui16
-}
-
-func.func @divi_ui16(%a : ui16, %b : ui16) -> ui16 {
-  %c = arc.divi %a, %b : ui16
-  return %c : ui16
-}
-
-func.func @remi_ui16(%a : ui16, %b : ui16) -> ui16 {
-  %c = arc.remi %a, %b : ui16
-  return %c : ui16
-}
-
-func.func @addi_ui32(%a : ui32, %b : ui32) -> ui32 {
-  %c = arc.addi %a, %b : ui32
-  return %c : ui32
-}
-
-func.func @subi_ui32(%a : ui32, %b : ui32) -> ui32 {
-  %c = arc.subi %a, %b : ui32
-  return %c : ui32
-}
-
-func.func @muli_ui32(%a : ui32, %b : ui32) -> ui32 {
-  %c = arc.muli %a, %b : ui32
-  return %c : ui32
-}
-
-func.func @divi_ui32(%a : ui32, %b : ui32) -> ui32 {
-  %c = arc.divi %a, %b : ui32
-  return %c : ui32
-}
-
-func.func @remi_ui32(%a : ui32, %b : ui32) -> ui32 {
-  %c = arc.remi %a, %b : ui32
-  return %c : ui32
-}
-
-func.func @addi_ui64(%a : ui64, %b : ui64) -> ui64 {
-  %c = arc.addi %a, %b : ui64
-  return %c : ui64
-}
-
-func.func @subi_ui64(%a : ui64, %b : ui64) -> ui64 {
-  %c = arc.subi %a, %b : ui64
-  return %c : ui64
-}
-
-func.func @muli_ui64(%a : ui64, %b : ui64) -> ui64 {
-  %c = arc.muli %a, %b : ui64
-  return %c : ui64
-}
-
-func.func @divi_ui64(%a : ui64, %b : ui64) -> ui64 {
-  %c = arc.divi %a, %b : ui64
-  return %c : ui64
-}
-
-func.func @remi_ui64(%a : ui64, %b : ui64) -> ui64 {
-  %c = arc.remi %a, %b : ui64
-  return %c : ui64
-}
-
-func.func @addi_si8(%a : si8, %b : si8) -> si8 {
-  %c = arc.addi %a, %b : si8
-  return %c : si8
-}
-
-func.func @subi_si8(%a : si8, %b : si8) -> si8 {
-  %c = arc.subi %a, %b : si8
-  return %c : si8
-}
-
-func.func @muli_si8(%a : si8, %b : si8) -> si8 {
-  %c = arc.muli %a, %b : si8
-  return %c : si8
-}
-
-func.func @divi_si8(%a : si8, %b : si8) -> si8 {
-  %c = arc.divi %a, %b : si8
-  return %c : si8
-}
-
-func.func @remi_si8(%a : si8, %b : si8) -> si8 {
-  %c = arc.remi %a, %b : si8
-  return %c : si8
-}
-
-func.func @addi_si16(%a : si16, %b : si16) -> si16 {
-  %c = arc.addi %a, %b : si16
-  return %c : si16
-}
-
-func.func @subi_si16(%a : si16, %b : si16) -> si16 {
-  %c = arc.subi %a, %b : si16
-  return %c : si16
-}
-
-func.func @muli_si16(%a : si16, %b : si16) -> si16 {
-  %c = arc.muli %a, %b : si16
-  return %c : si16
-}
-
-func.func @divi_si16(%a : si16, %b : si16) -> si16 {
-  %c = arc.divi %a, %b : si16
-  return %c : si16
-}
-
-func.func @remi_si16(%a : si16, %b : si16) -> si16 {
-  %c = arc.remi %a, %b : si16
-  return %c : si16
-}
-
-func.func @addi_si32(%a : si32, %b : si32) -> si32 {
-  %c = arc.addi %a, %b : si32
-  return %c : si32
-}
-
-func.func @subi_si32(%a : si32, %b : si32) -> si32 {
-  %c = arc.subi %a, %b : si32
-  return %c : si32
-}
-
-func.func @muli_si32(%a : si32, %b : si32) -> si32 {
-  %c = arc.muli %a, %b : si32
-  return %c : si32
-}
-
-func.func @divi_si32(%a : si32, %b : si32) -> si32 {
-  %c = arc.divi %a, %b : si32
-  return %c : si32
-}
-
-func.func @remi_si32(%a : si32, %b : si32) -> si32 {
-  %c = arc.remi %a, %b : si32
-  return %c : si32
-}
-
-func.func @addi_si64(%a : si64, %b : si64) -> si64 {
-  %c = arc.addi %a, %b : si64
-  return %c : si64
-}
-
-func.func @subi_si64(%a : si64, %b : si64) -> si64 {
-  %c = arc.subi %a, %b : si64
-  return %c : si64
-}
-
-func.func @muli_si64(%a : si64, %b : si64) -> si64 {
-  %c = arc.muli %a, %b : si64
-  return %c : si64
-}
-
-func.func @divi_si64(%a : si64, %b : si64) -> si64 {
-  %c = arc.divi %a, %b : si64
-  return %c : si64
-}
-
-func.func @remi_si64(%a : si64, %b : si64) -> si64 {
-  %c = arc.remi %a, %b : si64
-  return %c : si64
-}
-
+  func.func @addi_ui8(%a : ui8, %b : ui8) -> ui8 {
+    %c = arc.addi %a, %b : ui8
+    return %c : ui8
+  }
+
+  func.func @subi_ui8(%a : ui8, %b : ui8) -> ui8 {
+    %c = arc.subi %a, %b : ui8
+    return %c : ui8
+  }
+
+  func.func @muli_ui8(%a : ui8, %b : ui8) -> ui8 {
+    %c = arc.muli %a, %b : ui8
+    return %c : ui8
+  }
+
+  func.func @divi_ui8(%a : ui8, %b : ui8) -> ui8 {
+    %c = arc.divi %a, %b : ui8
+    return %c : ui8
+  }
+
+  func.func @remi_ui8(%a : ui8, %b : ui8) -> ui8 {
+    %c = arc.remi %a, %b : ui8
+    return %c : ui8
+  }
+
+  func.func @addi_ui16(%a : ui16, %b : ui16) -> ui16 {
+    %c = arc.addi %a, %b : ui16
+    return %c : ui16
+  }
+
+  func.func @subi_ui16(%a : ui16, %b : ui16) -> ui16 {
+    %c = arc.subi %a, %b : ui16
+    return %c : ui16
+  }
+
+  func.func @muli_ui16(%a : ui16, %b : ui16) -> ui16 {
+    %c = arc.muli %a, %b : ui16
+    return %c : ui16
+  }
+
+  func.func @divi_ui16(%a : ui16, %b : ui16) -> ui16 {
+    %c = arc.divi %a, %b : ui16
+    return %c : ui16
+  }
+
+  func.func @remi_ui16(%a : ui16, %b : ui16) -> ui16 {
+    %c = arc.remi %a, %b : ui16
+    return %c : ui16
+  }
+
+  func.func @addi_ui32(%a : ui32, %b : ui32) -> ui32 {
+    %c = arc.addi %a, %b : ui32
+    return %c : ui32
+  }
+
+  func.func @subi_ui32(%a : ui32, %b : ui32) -> ui32 {
+    %c = arc.subi %a, %b : ui32
+    return %c : ui32
+  }
+
+  func.func @muli_ui32(%a : ui32, %b : ui32) -> ui32 {
+    %c = arc.muli %a, %b : ui32
+    return %c : ui32
+  }
+
+  func.func @divi_ui32(%a : ui32, %b : ui32) -> ui32 {
+    %c = arc.divi %a, %b : ui32
+    return %c : ui32
+  }
+
+  func.func @remi_ui32(%a : ui32, %b : ui32) -> ui32 {
+    %c = arc.remi %a, %b : ui32
+    return %c : ui32
+  }
+
+  func.func @addi_ui64(%a : ui64, %b : ui64) -> ui64 {
+    %c = arc.addi %a, %b : ui64
+    return %c : ui64
+  }
+
+  func.func @subi_ui64(%a : ui64, %b : ui64) -> ui64 {
+    %c = arc.subi %a, %b : ui64
+    return %c : ui64
+  }
+
+  func.func @muli_ui64(%a : ui64, %b : ui64) -> ui64 {
+    %c = arc.muli %a, %b : ui64
+    return %c : ui64
+  }
+
+  func.func @divi_ui64(%a : ui64, %b : ui64) -> ui64 {
+    %c = arc.divi %a, %b : ui64
+    return %c : ui64
+  }
+
+  func.func @remi_ui64(%a : ui64, %b : ui64) -> ui64 {
+    %c = arc.remi %a, %b : ui64
+    return %c : ui64
+  }
+
+  func.func @addi_si8(%a : si8, %b : si8) -> si8 {
+    %c = arc.addi %a, %b : si8
+    return %c : si8
+  }
+
+  func.func @subi_si8(%a : si8, %b : si8) -> si8 {
+    %c = arc.subi %a, %b : si8
+    return %c : si8
+  }
+
+  func.func @muli_si8(%a : si8, %b : si8) -> si8 {
+    %c = arc.muli %a, %b : si8
+    return %c : si8
+  }
+
+  func.func @divi_si8(%a : si8, %b : si8) -> si8 {
+    %c = arc.divi %a, %b : si8
+    return %c : si8
+  }
+
+  func.func @remi_si8(%a : si8, %b : si8) -> si8 {
+    %c = arc.remi %a, %b : si8
+    return %c : si8
+  }
+
+  func.func @addi_si16(%a : si16, %b : si16) -> si16 {
+    %c = arc.addi %a, %b : si16
+    return %c : si16
+  }
+
+  func.func @subi_si16(%a : si16, %b : si16) -> si16 {
+    %c = arc.subi %a, %b : si16
+    return %c : si16
+  }
+
+  func.func @muli_si16(%a : si16, %b : si16) -> si16 {
+    %c = arc.muli %a, %b : si16
+    return %c : si16
+  }
+
+  func.func @divi_si16(%a : si16, %b : si16) -> si16 {
+    %c = arc.divi %a, %b : si16
+    return %c : si16
+  }
+
+  func.func @remi_si16(%a : si16, %b : si16) -> si16 {
+    %c = arc.remi %a, %b : si16
+    return %c : si16
+  }
+
+  func.func @addi_si32(%a : si32, %b : si32) -> si32 {
+    %c = arc.addi %a, %b : si32
+    return %c : si32
+  }
+
+  func.func @subi_si32(%a : si32, %b : si32) -> si32 {
+    %c = arc.subi %a, %b : si32
+    return %c : si32
+  }
+
+  func.func @muli_si32(%a : si32, %b : si32) -> si32 {
+    %c = arc.muli %a, %b : si32
+    return %c : si32
+  }
+
+  func.func @divi_si32(%a : si32, %b : si32) -> si32 {
+    %c = arc.divi %a, %b : si32
+    return %c : si32
+  }
+
+  func.func @remi_si32(%a : si32, %b : si32) -> si32 {
+    %c = arc.remi %a, %b : si32
+    return %c : si32
+  }
+
+  func.func @addi_si64(%a : si64, %b : si64) -> si64 {
+    %c = arc.addi %a, %b : si64
+    return %c : si64
+  }
+
+  func.func @subi_si64(%a : si64, %b : si64) -> si64 {
+    %c = arc.subi %a, %b : si64
+    return %c : si64
+  }
+
+  func.func @muli_si64(%a : si64, %b : si64) -> si64 {
+    %c = arc.muli %a, %b : si64
+    return %c : si64
+  }
+
+  func.func @divi_si64(%a : si64, %b : si64) -> si64 {
+    %c = arc.divi %a, %b : si64
+    return %c : si64
+  }
+
+  func.func @remi_si64(%a : si64, %b : si64) -> si64 {
+    %c = arc.remi %a, %b : si64
+    return %c : si64
+  }
 }
diff --git a/arc-mlir/src/tests/arc-to-rust/int-arith.mlir.rust-tests b/arc-mlir/src/tests/arc-to-rust/int-arith.mlir.rust-tests
index 19ec2dffa..f32e0b160 100644
--- a/arc-mlir/src/tests/arc-to-rust/int-arith.mlir.rust-tests
+++ b/arc-mlir/src/tests/arc-to-rust/int-arith.mlir.rust-tests
@@ -1,3397 +1,3714 @@
 #[cfg(test)]
 mod tests {
-  use crate::arctorustintarith::*;
-  #[rewrite(main)]
-  #[test]
-  fn it_works() {
-assert_eq!(call!(addi_si16(-32768, 0)), -32768);
-assert_eq!(call!(addi_si16(0, -32768)), -32768);
-assert_eq!(call!(addi_si16(-32768, 1)), -32767);
-assert_eq!(call!(addi_si16(-32767, 0)), -32767);
-assert_eq!(call!(addi_si16(0, -32767)), -32767);
-assert_eq!(call!(addi_si16(1, -32768)), -32767);
-assert_eq!(call!(addi_si16(-32768, 2)), -32766);
-assert_eq!(call!(addi_si16(-32767, 1)), -32766);
-assert_eq!(call!(addi_si16(1, -32767)), -32766);
-assert_eq!(call!(addi_si16(2, -32768)), -32766);
-assert_eq!(call!(addi_si16(-32768, 3)), -32765);
-assert_eq!(call!(addi_si16(-32767, 2)), -32765);
-assert_eq!(call!(addi_si16(2, -32767)), -32765);
-assert_eq!(call!(addi_si16(3, -32768)), -32765);
-assert_eq!(call!(addi_si16(-32768, 4)), -32764);
-assert_eq!(call!(addi_si16(-32767, 3)), -32764);
-assert_eq!(call!(addi_si16(3, -32767)), -32764);
-assert_eq!(call!(addi_si16(4, -32768)), -32764);
-assert_eq!(call!(addi_si16(-32767, 4)), -32763);
-assert_eq!(call!(addi_si16(4, -32767)), -32763);
-assert_eq!(call!(addi_si16(-32547, 0)), -32547);
-assert_eq!(call!(addi_si16(0, -32547)), -32547);
-assert_eq!(call!(addi_si16(-32547, 1)), -32546);
-assert_eq!(call!(addi_si16(1, -32547)), -32546);
-assert_eq!(call!(addi_si16(-32547, 2)), -32545);
-assert_eq!(call!(addi_si16(2, -32547)), -32545);
-assert_eq!(call!(addi_si16(-32547, 3)), -32544);
-assert_eq!(call!(addi_si16(3, -32547)), -32544);
-assert_eq!(call!(addi_si16(-32547, 4)), -32543);
-assert_eq!(call!(addi_si16(4, -32547)), -32543);
-assert_eq!(call!(addi_si16(-32768, 10486)), -22282);
-assert_eq!(call!(addi_si16(10486, -32768)), -22282);
-assert_eq!(call!(addi_si16(-32767, 10486)), -22281);
-assert_eq!(call!(addi_si16(10486, -32767)), -22281);
-assert_eq!(call!(addi_si16(-32547, 10486)), -22061);
-assert_eq!(call!(addi_si16(10486, -32547)), -22061);
-assert_eq!(call!(addi_si16(-32768, 16514)), -16254);
-assert_eq!(call!(addi_si16(16514, -32768)), -16254);
-assert_eq!(call!(addi_si16(-32767, 16514)), -16253);
-assert_eq!(call!(addi_si16(16514, -32767)), -16253);
-assert_eq!(call!(addi_si16(-32547, 16514)), -16033);
-assert_eq!(call!(addi_si16(16514, -32547)), -16033);
-assert_eq!(call!(addi_si16(-32768, 32766)), -2);
-assert_eq!(call!(addi_si16(32766, -32768)), -2);
-assert_eq!(call!(addi_si16(-32768, 32767)), -1);
-assert_eq!(call!(addi_si16(-32767, 32766)), -1);
-assert_eq!(call!(addi_si16(32766, -32767)), -1);
-assert_eq!(call!(addi_si16(32767, -32768)), -1);
-assert_eq!(call!(addi_si16(-32767, 32767)), 0);
-assert_eq!(call!(addi_si16(0, 0)), 0);
-assert_eq!(call!(addi_si16(32767, -32767)), 0);
-assert_eq!(call!(addi_si16(0, 1)), 1);
-assert_eq!(call!(addi_si16(1, 0)), 1);
-assert_eq!(call!(addi_si16(0, 2)), 2);
-assert_eq!(call!(addi_si16(1, 1)), 2);
-assert_eq!(call!(addi_si16(2, 0)), 2);
-assert_eq!(call!(addi_si16(0, 3)), 3);
-assert_eq!(call!(addi_si16(1, 2)), 3);
-assert_eq!(call!(addi_si16(2, 1)), 3);
-assert_eq!(call!(addi_si16(3, 0)), 3);
-assert_eq!(call!(addi_si16(0, 4)), 4);
-assert_eq!(call!(addi_si16(1, 3)), 4);
-assert_eq!(call!(addi_si16(2, 2)), 4);
-assert_eq!(call!(addi_si16(3, 1)), 4);
-assert_eq!(call!(addi_si16(4, 0)), 4);
-assert_eq!(call!(addi_si16(1, 4)), 5);
-assert_eq!(call!(addi_si16(2, 3)), 5);
-assert_eq!(call!(addi_si16(3, 2)), 5);
-assert_eq!(call!(addi_si16(4, 1)), 5);
-assert_eq!(call!(addi_si16(2, 4)), 6);
-assert_eq!(call!(addi_si16(3, 3)), 6);
-assert_eq!(call!(addi_si16(4, 2)), 6);
-assert_eq!(call!(addi_si16(3, 4)), 7);
-assert_eq!(call!(addi_si16(4, 3)), 7);
-assert_eq!(call!(addi_si16(4, 4)), 8);
-assert_eq!(call!(addi_si16(-32547, 32766)), 219);
-assert_eq!(call!(addi_si16(32766, -32547)), 219);
-assert_eq!(call!(addi_si16(-32547, 32767)), 220);
-assert_eq!(call!(addi_si16(32767, -32547)), 220);
-assert_eq!(call!(addi_si16(0, 10486)), 10486);
-assert_eq!(call!(addi_si16(10486, 0)), 10486);
-assert_eq!(call!(addi_si16(1, 10486)), 10487);
-assert_eq!(call!(addi_si16(10486, 1)), 10487);
-assert_eq!(call!(addi_si16(2, 10486)), 10488);
-assert_eq!(call!(addi_si16(10486, 2)), 10488);
-assert_eq!(call!(addi_si16(3, 10486)), 10489);
-assert_eq!(call!(addi_si16(10486, 3)), 10489);
-assert_eq!(call!(addi_si16(4, 10486)), 10490);
-assert_eq!(call!(addi_si16(10486, 4)), 10490);
-assert_eq!(call!(addi_si16(0, 16514)), 16514);
-assert_eq!(call!(addi_si16(16514, 0)), 16514);
-assert_eq!(call!(addi_si16(1, 16514)), 16515);
-assert_eq!(call!(addi_si16(16514, 1)), 16515);
-assert_eq!(call!(addi_si16(2, 16514)), 16516);
-assert_eq!(call!(addi_si16(16514, 2)), 16516);
-assert_eq!(call!(addi_si16(3, 16514)), 16517);
-assert_eq!(call!(addi_si16(16514, 3)), 16517);
-assert_eq!(call!(addi_si16(4, 16514)), 16518);
-assert_eq!(call!(addi_si16(16514, 4)), 16518);
-assert_eq!(call!(addi_si16(10486, 10486)), 20972);
-assert_eq!(call!(addi_si16(10486, 16514)), 27000);
-assert_eq!(call!(addi_si16(16514, 10486)), 27000);
-assert_eq!(call!(addi_si16(0, 32766)), 32766);
-assert_eq!(call!(addi_si16(32766, 0)), 32766);
-assert_eq!(call!(addi_si16(0, 32767)), 32767);
-assert_eq!(call!(addi_si16(1, 32766)), 32767);
-assert_eq!(call!(addi_si16(32766, 1)), 32767);
-assert_eq!(call!(addi_si16(32767, 0)), 32767);
-assert_eq!(call!(addi_si32(-2147483648, 0)), -2147483648);
-assert_eq!(call!(addi_si32(0, -2147483648)), -2147483648);
-assert_eq!(call!(addi_si32(-2147483648, 1)), -2147483647);
-assert_eq!(call!(addi_si32(-2147483647, 0)), -2147483647);
-assert_eq!(call!(addi_si32(0, -2147483647)), -2147483647);
-assert_eq!(call!(addi_si32(1, -2147483648)), -2147483647);
-assert_eq!(call!(addi_si32(-2147483648, 2)), -2147483646);
-assert_eq!(call!(addi_si32(-2147483647, 1)), -2147483646);
-assert_eq!(call!(addi_si32(1, -2147483647)), -2147483646);
-assert_eq!(call!(addi_si32(2, -2147483648)), -2147483646);
-assert_eq!(call!(addi_si32(-2147483648, 3)), -2147483645);
-assert_eq!(call!(addi_si32(-2147483647, 2)), -2147483645);
-assert_eq!(call!(addi_si32(2, -2147483647)), -2147483645);
-assert_eq!(call!(addi_si32(3, -2147483648)), -2147483645);
-assert_eq!(call!(addi_si32(-2147483648, 4)), -2147483644);
-assert_eq!(call!(addi_si32(-2147483647, 3)), -2147483644);
-assert_eq!(call!(addi_si32(3, -2147483647)), -2147483644);
-assert_eq!(call!(addi_si32(4, -2147483648)), -2147483644);
-assert_eq!(call!(addi_si32(-2147483647, 4)), -2147483643);
-assert_eq!(call!(addi_si32(4, -2147483647)), -2147483643);
-assert_eq!(call!(addi_si32(-1035405763, -1035405763)), -2070811526);
-assert_eq!(call!(addi_si32(-1713183800, 0)), -1713183800);
-assert_eq!(call!(addi_si32(0, -1713183800)), -1713183800);
-assert_eq!(call!(addi_si32(-1713183800, 1)), -1713183799);
-assert_eq!(call!(addi_si32(1, -1713183800)), -1713183799);
-assert_eq!(call!(addi_si32(-1713183800, 2)), -1713183798);
-assert_eq!(call!(addi_si32(2, -1713183800)), -1713183798);
-assert_eq!(call!(addi_si32(-1713183800, 3)), -1713183797);
-assert_eq!(call!(addi_si32(3, -1713183800)), -1713183797);
-assert_eq!(call!(addi_si32(-1713183800, 4)), -1713183796);
-assert_eq!(call!(addi_si32(4, -1713183800)), -1713183796);
-assert_eq!(call!(addi_si32(-1252582164, 0)), -1252582164);
-assert_eq!(call!(addi_si32(0, -1252582164)), -1252582164);
-assert_eq!(call!(addi_si32(-1252582164, 1)), -1252582163);
-assert_eq!(call!(addi_si32(1, -1252582164)), -1252582163);
-assert_eq!(call!(addi_si32(-1252582164, 2)), -1252582162);
-assert_eq!(call!(addi_si32(2, -1252582164)), -1252582162);
-assert_eq!(call!(addi_si32(-1252582164, 3)), -1252582161);
-assert_eq!(call!(addi_si32(3, -1252582164)), -1252582161);
-assert_eq!(call!(addi_si32(-1252582164, 4)), -1252582160);
-assert_eq!(call!(addi_si32(4, -1252582164)), -1252582160);
-assert_eq!(call!(addi_si32(-1035405763, 0)), -1035405763);
-assert_eq!(call!(addi_si32(0, -1035405763)), -1035405763);
-assert_eq!(call!(addi_si32(-1035405763, 1)), -1035405762);
-assert_eq!(call!(addi_si32(1, -1035405763)), -1035405762);
-assert_eq!(call!(addi_si32(-1035405763, 2)), -1035405761);
-assert_eq!(call!(addi_si32(2, -1035405763)), -1035405761);
-assert_eq!(call!(addi_si32(-1035405763, 3)), -1035405760);
-assert_eq!(call!(addi_si32(3, -1035405763)), -1035405760);
-assert_eq!(call!(addi_si32(-1035405763, 4)), -1035405759);
-assert_eq!(call!(addi_si32(4, -1035405763)), -1035405759);
-assert_eq!(call!(addi_si32(-2147483648, 2147483646)), -2);
-assert_eq!(call!(addi_si32(2147483646, -2147483648)), -2);
-assert_eq!(call!(addi_si32(-2147483648, 2147483647)), -1);
-assert_eq!(call!(addi_si32(-2147483647, 2147483646)), -1);
-assert_eq!(call!(addi_si32(2147483646, -2147483647)), -1);
-assert_eq!(call!(addi_si32(2147483647, -2147483648)), -1);
-assert_eq!(call!(addi_si32(-2147483647, 2147483647)), 0);
-assert_eq!(call!(addi_si32(0, 0)), 0);
-assert_eq!(call!(addi_si32(2147483647, -2147483647)), 0);
-assert_eq!(call!(addi_si32(0, 1)), 1);
-assert_eq!(call!(addi_si32(1, 0)), 1);
-assert_eq!(call!(addi_si32(0, 2)), 2);
-assert_eq!(call!(addi_si32(1, 1)), 2);
-assert_eq!(call!(addi_si32(2, 0)), 2);
-assert_eq!(call!(addi_si32(0, 3)), 3);
-assert_eq!(call!(addi_si32(1, 2)), 3);
-assert_eq!(call!(addi_si32(2, 1)), 3);
-assert_eq!(call!(addi_si32(3, 0)), 3);
-assert_eq!(call!(addi_si32(0, 4)), 4);
-assert_eq!(call!(addi_si32(1, 3)), 4);
-assert_eq!(call!(addi_si32(2, 2)), 4);
-assert_eq!(call!(addi_si32(3, 1)), 4);
-assert_eq!(call!(addi_si32(4, 0)), 4);
-assert_eq!(call!(addi_si32(1, 4)), 5);
-assert_eq!(call!(addi_si32(2, 3)), 5);
-assert_eq!(call!(addi_si32(3, 2)), 5);
-assert_eq!(call!(addi_si32(4, 1)), 5);
-assert_eq!(call!(addi_si32(2, 4)), 6);
-assert_eq!(call!(addi_si32(3, 3)), 6);
-assert_eq!(call!(addi_si32(4, 2)), 6);
-assert_eq!(call!(addi_si32(3, 4)), 7);
-assert_eq!(call!(addi_si32(4, 3)), 7);
-assert_eq!(call!(addi_si32(4, 4)), 8);
-assert_eq!(call!(addi_si32(-1713183800, 2147483646)), 434299846);
-assert_eq!(call!(addi_si32(2147483646, -1713183800)), 434299846);
-assert_eq!(call!(addi_si32(-1713183800, 2147483647)), 434299847);
-assert_eq!(call!(addi_si32(2147483647, -1713183800)), 434299847);
-assert_eq!(call!(addi_si32(-1252582164, 2147483646)), 894901482);
-assert_eq!(call!(addi_si32(2147483646, -1252582164)), 894901482);
-assert_eq!(call!(addi_si32(-1252582164, 2147483647)), 894901483);
-assert_eq!(call!(addi_si32(2147483647, -1252582164)), 894901483);
-assert_eq!(call!(addi_si32(-1035405763, 2147483646)), 1112077883);
-assert_eq!(call!(addi_si32(2147483646, -1035405763)), 1112077883);
-assert_eq!(call!(addi_si32(-1035405763, 2147483647)), 1112077884);
-assert_eq!(call!(addi_si32(2147483647, -1035405763)), 1112077884);
-assert_eq!(call!(addi_si32(0, 2147483646)), 2147483646);
-assert_eq!(call!(addi_si32(2147483646, 0)), 2147483646);
-assert_eq!(call!(addi_si32(0, 2147483647)), 2147483647);
-assert_eq!(call!(addi_si32(1, 2147483646)), 2147483647);
-assert_eq!(call!(addi_si32(2147483646, 1)), 2147483647);
-assert_eq!(call!(addi_si32(2147483647, 0)), 2147483647);
-assert_eq!(call!(addi_si64(-9223372036854775808, 0)), -9223372036854775808);
-assert_eq!(call!(addi_si64(0, -9223372036854775808)), -9223372036854775808);
-assert_eq!(call!(addi_si64(-9223372036854775808, 1)), -9223372036854775807);
-assert_eq!(call!(addi_si64(-9223372036854775807, 0)), -9223372036854775807);
-assert_eq!(call!(addi_si64(0, -9223372036854775807)), -9223372036854775807);
-assert_eq!(call!(addi_si64(1, -9223372036854775808)), -9223372036854775807);
-assert_eq!(call!(addi_si64(-9223372036854775808, 2)), -9223372036854775806);
-assert_eq!(call!(addi_si64(-9223372036854775807, 1)), -9223372036854775806);
-assert_eq!(call!(addi_si64(1, -9223372036854775807)), -9223372036854775806);
-assert_eq!(call!(addi_si64(2, -9223372036854775808)), -9223372036854775806);
-assert_eq!(call!(addi_si64(-9223372036854775808, 3)), -9223372036854775805);
-assert_eq!(call!(addi_si64(-9223372036854775807, 2)), -9223372036854775805);
-assert_eq!(call!(addi_si64(2, -9223372036854775807)), -9223372036854775805);
-assert_eq!(call!(addi_si64(3, -9223372036854775808)), -9223372036854775805);
-assert_eq!(call!(addi_si64(-9223372036854775808, 4)), -9223372036854775804);
-assert_eq!(call!(addi_si64(-9223372036854775807, 3)), -9223372036854775804);
-assert_eq!(call!(addi_si64(3, -9223372036854775807)), -9223372036854775804);
-assert_eq!(call!(addi_si64(4, -9223372036854775808)), -9223372036854775804);
-assert_eq!(call!(addi_si64(-9223372036854775807, 4)), -9223372036854775803);
-assert_eq!(call!(addi_si64(4, -9223372036854775807)), -9223372036854775803);
-assert_eq!(call!(addi_si64(-9223372036854775808, 5577148965131116544)), -3646223071723659264);
-assert_eq!(call!(addi_si64(5577148965131116544, -9223372036854775808)), -3646223071723659264);
-assert_eq!(call!(addi_si64(-9223372036854775807, 5577148965131116544)), -3646223071723659263);
-assert_eq!(call!(addi_si64(5577148965131116544, -9223372036854775807)), -3646223071723659263);
-assert_eq!(call!(addi_si64(-1741927215160008704, -1741927215160008704)), -3483854430320017408);
-assert_eq!(call!(addi_si64(-1741927215160008704, -1328271339354574848)), -3070198554514583552);
-assert_eq!(call!(addi_si64(-1328271339354574848, -1741927215160008704)), -3070198554514583552);
-assert_eq!(call!(addi_si64(-1328271339354574848, -1328271339354574848)), -2656542678709149696);
-assert_eq!(call!(addi_si64(-1741927215160008704, 0)), -1741927215160008704);
-assert_eq!(call!(addi_si64(0, -1741927215160008704)), -1741927215160008704);
-assert_eq!(call!(addi_si64(-1741927215160008704, 1)), -1741927215160008703);
-assert_eq!(call!(addi_si64(1, -1741927215160008704)), -1741927215160008703);
-assert_eq!(call!(addi_si64(-1741927215160008704, 2)), -1741927215160008702);
-assert_eq!(call!(addi_si64(2, -1741927215160008704)), -1741927215160008702);
-assert_eq!(call!(addi_si64(-1741927215160008704, 3)), -1741927215160008701);
-assert_eq!(call!(addi_si64(3, -1741927215160008704)), -1741927215160008701);
-assert_eq!(call!(addi_si64(-1741927215160008704, 4)), -1741927215160008700);
-assert_eq!(call!(addi_si64(4, -1741927215160008704)), -1741927215160008700);
-assert_eq!(call!(addi_si64(-1328271339354574848, 0)), -1328271339354574848);
-assert_eq!(call!(addi_si64(0, -1328271339354574848)), -1328271339354574848);
-assert_eq!(call!(addi_si64(-1328271339354574848, 1)), -1328271339354574847);
-assert_eq!(call!(addi_si64(1, -1328271339354574848)), -1328271339354574847);
-assert_eq!(call!(addi_si64(-1328271339354574848, 2)), -1328271339354574846);
-assert_eq!(call!(addi_si64(2, -1328271339354574848)), -1328271339354574846);
-assert_eq!(call!(addi_si64(-1328271339354574848, 3)), -1328271339354574845);
-assert_eq!(call!(addi_si64(3, -1328271339354574848)), -1328271339354574845);
-assert_eq!(call!(addi_si64(-1328271339354574848, 4)), -1328271339354574844);
-assert_eq!(call!(addi_si64(4, -1328271339354574848)), -1328271339354574844);
-assert_eq!(call!(addi_si64(-9223372036854775808, 9223372036854775806)), -2);
-assert_eq!(call!(addi_si64(9223372036854775806, -9223372036854775808)), -2);
-assert_eq!(call!(addi_si64(-9223372036854775808, 9223372036854775807)), -1);
-assert_eq!(call!(addi_si64(-9223372036854775807, 9223372036854775806)), -1);
-assert_eq!(call!(addi_si64(9223372036854775806, -9223372036854775807)), -1);
-assert_eq!(call!(addi_si64(9223372036854775807, -9223372036854775808)), -1);
-assert_eq!(call!(addi_si64(-9223372036854775807, 9223372036854775807)), 0);
-assert_eq!(call!(addi_si64(0, 0)), 0);
-assert_eq!(call!(addi_si64(9223372036854775807, -9223372036854775807)), 0);
-assert_eq!(call!(addi_si64(0, 1)), 1);
-assert_eq!(call!(addi_si64(1, 0)), 1);
-assert_eq!(call!(addi_si64(0, 2)), 2);
-assert_eq!(call!(addi_si64(1, 1)), 2);
-assert_eq!(call!(addi_si64(2, 0)), 2);
-assert_eq!(call!(addi_si64(0, 3)), 3);
-assert_eq!(call!(addi_si64(1, 2)), 3);
-assert_eq!(call!(addi_si64(2, 1)), 3);
-assert_eq!(call!(addi_si64(3, 0)), 3);
-assert_eq!(call!(addi_si64(0, 4)), 4);
-assert_eq!(call!(addi_si64(1, 3)), 4);
-assert_eq!(call!(addi_si64(2, 2)), 4);
-assert_eq!(call!(addi_si64(3, 1)), 4);
-assert_eq!(call!(addi_si64(4, 0)), 4);
-assert_eq!(call!(addi_si64(1, 4)), 5);
-assert_eq!(call!(addi_si64(2, 3)), 5);
-assert_eq!(call!(addi_si64(3, 2)), 5);
-assert_eq!(call!(addi_si64(4, 1)), 5);
-assert_eq!(call!(addi_si64(2, 4)), 6);
-assert_eq!(call!(addi_si64(3, 3)), 6);
-assert_eq!(call!(addi_si64(4, 2)), 6);
-assert_eq!(call!(addi_si64(3, 4)), 7);
-assert_eq!(call!(addi_si64(4, 3)), 7);
-assert_eq!(call!(addi_si64(4, 4)), 8);
-assert_eq!(call!(addi_si64(-1741927215160008704, 5577148965131116544)), 3835221749971107840);
-assert_eq!(call!(addi_si64(5577148965131116544, -1741927215160008704)), 3835221749971107840);
-assert_eq!(call!(addi_si64(-1328271339354574848, 5577148965131116544)), 4248877625776541696);
-assert_eq!(call!(addi_si64(5577148965131116544, -1328271339354574848)), 4248877625776541696);
-assert_eq!(call!(addi_si64(0, 5577148965131116544)), 5577148965131116544);
-assert_eq!(call!(addi_si64(5577148965131116544, 0)), 5577148965131116544);
-assert_eq!(call!(addi_si64(1, 5577148965131116544)), 5577148965131116545);
-assert_eq!(call!(addi_si64(5577148965131116544, 1)), 5577148965131116545);
-assert_eq!(call!(addi_si64(2, 5577148965131116544)), 5577148965131116546);
-assert_eq!(call!(addi_si64(5577148965131116544, 2)), 5577148965131116546);
-assert_eq!(call!(addi_si64(3, 5577148965131116544)), 5577148965131116547);
-assert_eq!(call!(addi_si64(5577148965131116544, 3)), 5577148965131116547);
-assert_eq!(call!(addi_si64(4, 5577148965131116544)), 5577148965131116548);
-assert_eq!(call!(addi_si64(5577148965131116544, 4)), 5577148965131116548);
-assert_eq!(call!(addi_si64(-1741927215160008704, 9223372036854775806)), 7481444821694767102);
-assert_eq!(call!(addi_si64(9223372036854775806, -1741927215160008704)), 7481444821694767102);
-assert_eq!(call!(addi_si64(-1741927215160008704, 9223372036854775807)), 7481444821694767103);
-assert_eq!(call!(addi_si64(9223372036854775807, -1741927215160008704)), 7481444821694767103);
-assert_eq!(call!(addi_si64(-1328271339354574848, 9223372036854775806)), 7895100697500200958);
-assert_eq!(call!(addi_si64(9223372036854775806, -1328271339354574848)), 7895100697500200958);
-assert_eq!(call!(addi_si64(-1328271339354574848, 9223372036854775807)), 7895100697500200959);
-assert_eq!(call!(addi_si64(9223372036854775807, -1328271339354574848)), 7895100697500200959);
-assert_eq!(call!(addi_si64(0, 9223372036854775806)), 9223372036854775806);
-assert_eq!(call!(addi_si64(9223372036854775806, 0)), 9223372036854775806);
-assert_eq!(call!(addi_si64(0, 9223372036854775807)), 9223372036854775807);
-assert_eq!(call!(addi_si64(1, 9223372036854775806)), 9223372036854775807);
-assert_eq!(call!(addi_si64(9223372036854775806, 1)), 9223372036854775807);
-assert_eq!(call!(addi_si64(9223372036854775807, 0)), 9223372036854775807);
-assert_eq!(call!(addi_si8(-128, 0)), -128);
-assert_eq!(call!(addi_si8(0, -128)), -128);
-assert_eq!(call!(addi_si8(-128, 1)), -127);
-assert_eq!(call!(addi_si8(-127, 0)), -127);
-assert_eq!(call!(addi_si8(0, -127)), -127);
-assert_eq!(call!(addi_si8(1, -128)), -127);
-assert_eq!(call!(addi_si8(-128, 2)), -126);
-assert_eq!(call!(addi_si8(-127, 1)), -126);
-assert_eq!(call!(addi_si8(1, -127)), -126);
-assert_eq!(call!(addi_si8(2, -128)), -126);
-assert_eq!(call!(addi_si8(-128, 3)), -125);
-assert_eq!(call!(addi_si8(-127, 2)), -125);
-assert_eq!(call!(addi_si8(2, -127)), -125);
-assert_eq!(call!(addi_si8(3, -128)), -125);
-assert_eq!(call!(addi_si8(-128, 4)), -124);
-assert_eq!(call!(addi_si8(-127, 3)), -124);
-assert_eq!(call!(addi_si8(3, -127)), -124);
-assert_eq!(call!(addi_si8(4, -128)), -124);
-assert_eq!(call!(addi_si8(-127, 4)), -123);
-assert_eq!(call!(addi_si8(4, -127)), -123);
-assert_eq!(call!(addi_si8(-128, 16)), -112);
-assert_eq!(call!(addi_si8(16, -128)), -112);
-assert_eq!(call!(addi_si8(-127, 16)), -111);
-assert_eq!(call!(addi_si8(16, -127)), -111);
-assert_eq!(call!(addi_si8(-128, 126)), -2);
-assert_eq!(call!(addi_si8(126, -128)), -2);
-assert_eq!(call!(addi_si8(-128, 127)), -1);
-assert_eq!(call!(addi_si8(-127, 126)), -1);
-assert_eq!(call!(addi_si8(126, -127)), -1);
-assert_eq!(call!(addi_si8(127, -128)), -1);
-assert_eq!(call!(addi_si8(-127, 127)), 0);
-assert_eq!(call!(addi_si8(0, 0)), 0);
-assert_eq!(call!(addi_si8(127, -127)), 0);
-assert_eq!(call!(addi_si8(0, 1)), 1);
-assert_eq!(call!(addi_si8(1, 0)), 1);
-assert_eq!(call!(addi_si8(0, 2)), 2);
-assert_eq!(call!(addi_si8(1, 1)), 2);
-assert_eq!(call!(addi_si8(2, 0)), 2);
-assert_eq!(call!(addi_si8(0, 3)), 3);
-assert_eq!(call!(addi_si8(1, 2)), 3);
-assert_eq!(call!(addi_si8(2, 1)), 3);
-assert_eq!(call!(addi_si8(3, 0)), 3);
-assert_eq!(call!(addi_si8(0, 4)), 4);
-assert_eq!(call!(addi_si8(1, 3)), 4);
-assert_eq!(call!(addi_si8(2, 2)), 4);
-assert_eq!(call!(addi_si8(3, 1)), 4);
-assert_eq!(call!(addi_si8(4, 0)), 4);
-assert_eq!(call!(addi_si8(1, 4)), 5);
-assert_eq!(call!(addi_si8(2, 3)), 5);
-assert_eq!(call!(addi_si8(3, 2)), 5);
-assert_eq!(call!(addi_si8(4, 1)), 5);
-assert_eq!(call!(addi_si8(2, 4)), 6);
-assert_eq!(call!(addi_si8(3, 3)), 6);
-assert_eq!(call!(addi_si8(4, 2)), 6);
-assert_eq!(call!(addi_si8(3, 4)), 7);
-assert_eq!(call!(addi_si8(4, 3)), 7);
-assert_eq!(call!(addi_si8(4, 4)), 8);
-assert_eq!(call!(addi_si8(0, 16)), 16);
-assert_eq!(call!(addi_si8(16, 0)), 16);
-assert_eq!(call!(addi_si8(1, 16)), 17);
-assert_eq!(call!(addi_si8(16, 1)), 17);
-assert_eq!(call!(addi_si8(2, 16)), 18);
-assert_eq!(call!(addi_si8(16, 2)), 18);
-assert_eq!(call!(addi_si8(3, 16)), 19);
-assert_eq!(call!(addi_si8(16, 3)), 19);
-assert_eq!(call!(addi_si8(4, 16)), 20);
-assert_eq!(call!(addi_si8(16, 4)), 20);
-assert_eq!(call!(addi_si8(16, 16)), 32);
-assert_eq!(call!(addi_si8(0, 126)), 126);
-assert_eq!(call!(addi_si8(126, 0)), 126);
-assert_eq!(call!(addi_si8(0, 127)), 127);
-assert_eq!(call!(addi_si8(1, 126)), 127);
-assert_eq!(call!(addi_si8(126, 1)), 127);
-assert_eq!(call!(addi_si8(127, 0)), 127);
-assert_eq!(call!(addi_ui16(0, 0)), 0);
-assert_eq!(call!(addi_ui16(0, 1)), 1);
-assert_eq!(call!(addi_ui16(1, 0)), 1);
-assert_eq!(call!(addi_ui16(0, 2)), 2);
-assert_eq!(call!(addi_ui16(1, 1)), 2);
-assert_eq!(call!(addi_ui16(2, 0)), 2);
-assert_eq!(call!(addi_ui16(0, 3)), 3);
-assert_eq!(call!(addi_ui16(1, 2)), 3);
-assert_eq!(call!(addi_ui16(2, 1)), 3);
-assert_eq!(call!(addi_ui16(3, 0)), 3);
-assert_eq!(call!(addi_ui16(0, 4)), 4);
-assert_eq!(call!(addi_ui16(1, 3)), 4);
-assert_eq!(call!(addi_ui16(2, 2)), 4);
-assert_eq!(call!(addi_ui16(3, 1)), 4);
-assert_eq!(call!(addi_ui16(4, 0)), 4);
-assert_eq!(call!(addi_ui16(1, 4)), 5);
-assert_eq!(call!(addi_ui16(2, 3)), 5);
-assert_eq!(call!(addi_ui16(3, 2)), 5);
-assert_eq!(call!(addi_ui16(4, 1)), 5);
-assert_eq!(call!(addi_ui16(2, 4)), 6);
-assert_eq!(call!(addi_ui16(3, 3)), 6);
-assert_eq!(call!(addi_ui16(4, 2)), 6);
-assert_eq!(call!(addi_ui16(3, 4)), 7);
-assert_eq!(call!(addi_ui16(4, 3)), 7);
-assert_eq!(call!(addi_ui16(4, 4)), 8);
-assert_eq!(call!(addi_ui16(0, 1717)), 1717);
-assert_eq!(call!(addi_ui16(1717, 0)), 1717);
-assert_eq!(call!(addi_ui16(1, 1717)), 1718);
-assert_eq!(call!(addi_ui16(1717, 1)), 1718);
-assert_eq!(call!(addi_ui16(2, 1717)), 1719);
-assert_eq!(call!(addi_ui16(1717, 2)), 1719);
-assert_eq!(call!(addi_ui16(3, 1717)), 1720);
-assert_eq!(call!(addi_ui16(1717, 3)), 1720);
-assert_eq!(call!(addi_ui16(4, 1717)), 1721);
-assert_eq!(call!(addi_ui16(1717, 4)), 1721);
-assert_eq!(call!(addi_ui16(1717, 1717)), 3434);
-assert_eq!(call!(addi_ui16(0, 17988)), 17988);
-assert_eq!(call!(addi_ui16(17988, 0)), 17988);
-assert_eq!(call!(addi_ui16(1, 17988)), 17989);
-assert_eq!(call!(addi_ui16(17988, 1)), 17989);
-assert_eq!(call!(addi_ui16(2, 17988)), 17990);
-assert_eq!(call!(addi_ui16(17988, 2)), 17990);
-assert_eq!(call!(addi_ui16(3, 17988)), 17991);
-assert_eq!(call!(addi_ui16(17988, 3)), 17991);
-assert_eq!(call!(addi_ui16(4, 17988)), 17992);
-assert_eq!(call!(addi_ui16(17988, 4)), 17992);
-assert_eq!(call!(addi_ui16(1717, 17988)), 19705);
-assert_eq!(call!(addi_ui16(17988, 1717)), 19705);
-assert_eq!(call!(addi_ui16(17988, 17988)), 35976);
-assert_eq!(call!(addi_ui16(0, 65096)), 65096);
-assert_eq!(call!(addi_ui16(65096, 0)), 65096);
-assert_eq!(call!(addi_ui16(1, 65096)), 65097);
-assert_eq!(call!(addi_ui16(65096, 1)), 65097);
-assert_eq!(call!(addi_ui16(2, 65096)), 65098);
-assert_eq!(call!(addi_ui16(65096, 2)), 65098);
-assert_eq!(call!(addi_ui16(3, 65096)), 65099);
-assert_eq!(call!(addi_ui16(65096, 3)), 65099);
-assert_eq!(call!(addi_ui16(4, 65096)), 65100);
-assert_eq!(call!(addi_ui16(65096, 4)), 65100);
-assert_eq!(call!(addi_ui16(0, 65534)), 65534);
-assert_eq!(call!(addi_ui16(65534, 0)), 65534);
-assert_eq!(call!(addi_ui16(0, 65535)), 65535);
-assert_eq!(call!(addi_ui16(1, 65534)), 65535);
-assert_eq!(call!(addi_ui16(65534, 1)), 65535);
-assert_eq!(call!(addi_ui16(65535, 0)), 65535);
-assert_eq!(call!(addi_ui32(0, 0)), 0);
-assert_eq!(call!(addi_ui32(0, 1)), 1);
-assert_eq!(call!(addi_ui32(1, 0)), 1);
-assert_eq!(call!(addi_ui32(0, 2)), 2);
-assert_eq!(call!(addi_ui32(1, 1)), 2);
-assert_eq!(call!(addi_ui32(2, 0)), 2);
-assert_eq!(call!(addi_ui32(0, 3)), 3);
-assert_eq!(call!(addi_ui32(1, 2)), 3);
-assert_eq!(call!(addi_ui32(2, 1)), 3);
-assert_eq!(call!(addi_ui32(3, 0)), 3);
-assert_eq!(call!(addi_ui32(0, 4)), 4);
-assert_eq!(call!(addi_ui32(1, 3)), 4);
-assert_eq!(call!(addi_ui32(2, 2)), 4);
-assert_eq!(call!(addi_ui32(3, 1)), 4);
-assert_eq!(call!(addi_ui32(4, 0)), 4);
-assert_eq!(call!(addi_ui32(1, 4)), 5);
-assert_eq!(call!(addi_ui32(2, 3)), 5);
-assert_eq!(call!(addi_ui32(3, 2)), 5);
-assert_eq!(call!(addi_ui32(4, 1)), 5);
-assert_eq!(call!(addi_ui32(2, 4)), 6);
-assert_eq!(call!(addi_ui32(3, 3)), 6);
-assert_eq!(call!(addi_ui32(4, 2)), 6);
-assert_eq!(call!(addi_ui32(3, 4)), 7);
-assert_eq!(call!(addi_ui32(4, 3)), 7);
-assert_eq!(call!(addi_ui32(4, 4)), 8);
-assert_eq!(call!(addi_ui32(0, 2119154652)), 2119154652);
-assert_eq!(call!(addi_ui32(2119154652, 0)), 2119154652);
-assert_eq!(call!(addi_ui32(1, 2119154652)), 2119154653);
-assert_eq!(call!(addi_ui32(2119154652, 1)), 2119154653);
-assert_eq!(call!(addi_ui32(2, 2119154652)), 2119154654);
-assert_eq!(call!(addi_ui32(2119154652, 2)), 2119154654);
-assert_eq!(call!(addi_ui32(3, 2119154652)), 2119154655);
-assert_eq!(call!(addi_ui32(2119154652, 3)), 2119154655);
-assert_eq!(call!(addi_ui32(4, 2119154652)), 2119154656);
-assert_eq!(call!(addi_ui32(2119154652, 4)), 2119154656);
-assert_eq!(call!(addi_ui32(0, 3002788344)), 3002788344);
-assert_eq!(call!(addi_ui32(3002788344, 0)), 3002788344);
-assert_eq!(call!(addi_ui32(1, 3002788344)), 3002788345);
-assert_eq!(call!(addi_ui32(3002788344, 1)), 3002788345);
-assert_eq!(call!(addi_ui32(2, 3002788344)), 3002788346);
-assert_eq!(call!(addi_ui32(3002788344, 2)), 3002788346);
-assert_eq!(call!(addi_ui32(3, 3002788344)), 3002788347);
-assert_eq!(call!(addi_ui32(3002788344, 3)), 3002788347);
-assert_eq!(call!(addi_ui32(4, 3002788344)), 3002788348);
-assert_eq!(call!(addi_ui32(3002788344, 4)), 3002788348);
-assert_eq!(call!(addi_ui32(0, 3482297128)), 3482297128);
-assert_eq!(call!(addi_ui32(3482297128, 0)), 3482297128);
-assert_eq!(call!(addi_ui32(1, 3482297128)), 3482297129);
-assert_eq!(call!(addi_ui32(3482297128, 1)), 3482297129);
-assert_eq!(call!(addi_ui32(2, 3482297128)), 3482297130);
-assert_eq!(call!(addi_ui32(3482297128, 2)), 3482297130);
-assert_eq!(call!(addi_ui32(3, 3482297128)), 3482297131);
-assert_eq!(call!(addi_ui32(3482297128, 3)), 3482297131);
-assert_eq!(call!(addi_ui32(4, 3482297128)), 3482297132);
-assert_eq!(call!(addi_ui32(3482297128, 4)), 3482297132);
-assert_eq!(call!(addi_ui32(2119154652, 2119154652)), 4238309304);
-assert_eq!(call!(addi_ui32(0, 4294967294)), 4294967294);
-assert_eq!(call!(addi_ui32(4294967294, 0)), 4294967294);
-assert_eq!(call!(addi_ui32(0, 4294967295)), 4294967295);
-assert_eq!(call!(addi_ui32(1, 4294967294)), 4294967295);
-assert_eq!(call!(addi_ui32(4294967294, 1)), 4294967295);
-assert_eq!(call!(addi_ui32(4294967295, 0)), 4294967295);
-assert_eq!(call!(addi_ui64(0, 0)), 0);
-assert_eq!(call!(addi_ui64(0, 1)), 1);
-assert_eq!(call!(addi_ui64(1, 0)), 1);
-assert_eq!(call!(addi_ui64(0, 2)), 2);
-assert_eq!(call!(addi_ui64(1, 1)), 2);
-assert_eq!(call!(addi_ui64(2, 0)), 2);
-assert_eq!(call!(addi_ui64(0, 3)), 3);
-assert_eq!(call!(addi_ui64(1, 2)), 3);
-assert_eq!(call!(addi_ui64(2, 1)), 3);
-assert_eq!(call!(addi_ui64(3, 0)), 3);
-assert_eq!(call!(addi_ui64(0, 4)), 4);
-assert_eq!(call!(addi_ui64(1, 3)), 4);
-assert_eq!(call!(addi_ui64(2, 2)), 4);
-assert_eq!(call!(addi_ui64(3, 1)), 4);
-assert_eq!(call!(addi_ui64(4, 0)), 4);
-assert_eq!(call!(addi_ui64(1, 4)), 5);
-assert_eq!(call!(addi_ui64(2, 3)), 5);
-assert_eq!(call!(addi_ui64(3, 2)), 5);
-assert_eq!(call!(addi_ui64(4, 1)), 5);
-assert_eq!(call!(addi_ui64(2, 4)), 6);
-assert_eq!(call!(addi_ui64(3, 3)), 6);
-assert_eq!(call!(addi_ui64(4, 2)), 6);
-assert_eq!(call!(addi_ui64(3, 4)), 7);
-assert_eq!(call!(addi_ui64(4, 3)), 7);
-assert_eq!(call!(addi_ui64(4, 4)), 8);
-assert_eq!(call!(addi_ui64(0, 191084152064409600)), 191084152064409600);
-assert_eq!(call!(addi_ui64(191084152064409600, 0)), 191084152064409600);
-assert_eq!(call!(addi_ui64(1, 191084152064409600)), 191084152064409601);
-assert_eq!(call!(addi_ui64(191084152064409600, 1)), 191084152064409601);
-assert_eq!(call!(addi_ui64(2, 191084152064409600)), 191084152064409602);
-assert_eq!(call!(addi_ui64(191084152064409600, 2)), 191084152064409602);
-assert_eq!(call!(addi_ui64(3, 191084152064409600)), 191084152064409603);
-assert_eq!(call!(addi_ui64(191084152064409600, 3)), 191084152064409603);
-assert_eq!(call!(addi_ui64(4, 191084152064409600)), 191084152064409604);
-assert_eq!(call!(addi_ui64(191084152064409600, 4)), 191084152064409604);
-assert_eq!(call!(addi_ui64(191084152064409600, 191084152064409600)), 382168304128819200);
-assert_eq!(call!(addi_ui64(0, 11015955194427482112)), 11015955194427482112);
-assert_eq!(call!(addi_ui64(11015955194427482112, 0)), 11015955194427482112);
-assert_eq!(call!(addi_ui64(1, 11015955194427482112)), 11015955194427482113);
-assert_eq!(call!(addi_ui64(11015955194427482112, 1)), 11015955194427482113);
-assert_eq!(call!(addi_ui64(2, 11015955194427482112)), 11015955194427482114);
-assert_eq!(call!(addi_ui64(11015955194427482112, 2)), 11015955194427482114);
-assert_eq!(call!(addi_ui64(3, 11015955194427482112)), 11015955194427482115);
-assert_eq!(call!(addi_ui64(11015955194427482112, 3)), 11015955194427482115);
-assert_eq!(call!(addi_ui64(4, 11015955194427482112)), 11015955194427482116);
-assert_eq!(call!(addi_ui64(11015955194427482112, 4)), 11015955194427482116);
-assert_eq!(call!(addi_ui64(191084152064409600, 11015955194427482112)), 11207039346491891712);
-assert_eq!(call!(addi_ui64(11015955194427482112, 191084152064409600)), 11207039346491891712);
-assert_eq!(call!(addi_ui64(0, 16990600415051759616)), 16990600415051759616);
-assert_eq!(call!(addi_ui64(16990600415051759616, 0)), 16990600415051759616);
-assert_eq!(call!(addi_ui64(1, 16990600415051759616)), 16990600415051759617);
-assert_eq!(call!(addi_ui64(16990600415051759616, 1)), 16990600415051759617);
-assert_eq!(call!(addi_ui64(2, 16990600415051759616)), 16990600415051759618);
-assert_eq!(call!(addi_ui64(16990600415051759616, 2)), 16990600415051759618);
-assert_eq!(call!(addi_ui64(3, 16990600415051759616)), 16990600415051759619);
-assert_eq!(call!(addi_ui64(16990600415051759616, 3)), 16990600415051759619);
-assert_eq!(call!(addi_ui64(4, 16990600415051759616)), 16990600415051759620);
-assert_eq!(call!(addi_ui64(16990600415051759616, 4)), 16990600415051759620);
-assert_eq!(call!(addi_ui64(191084152064409600, 16990600415051759616)), 17181684567116169216);
-assert_eq!(call!(addi_ui64(16990600415051759616, 191084152064409600)), 17181684567116169216);
-assert_eq!(call!(addi_ui64(0, 18446744073709551614)), 18446744073709551614);
-assert_eq!(call!(addi_ui64(18446744073709551614, 0)), 18446744073709551614);
-assert_eq!(call!(addi_ui64(0, 18446744073709551615)), 18446744073709551615);
-assert_eq!(call!(addi_ui64(1, 18446744073709551614)), 18446744073709551615);
-assert_eq!(call!(addi_ui64(18446744073709551614, 1)), 18446744073709551615);
-assert_eq!(call!(addi_ui64(18446744073709551615, 0)), 18446744073709551615);
-assert_eq!(call!(addi_ui8(0, 0)), 0);
-assert_eq!(call!(addi_ui8(0, 1)), 1);
-assert_eq!(call!(addi_ui8(1, 0)), 1);
-assert_eq!(call!(addi_ui8(0, 2)), 2);
-assert_eq!(call!(addi_ui8(1, 1)), 2);
-assert_eq!(call!(addi_ui8(2, 0)), 2);
-assert_eq!(call!(addi_ui8(0, 3)), 3);
-assert_eq!(call!(addi_ui8(1, 2)), 3);
-assert_eq!(call!(addi_ui8(2, 1)), 3);
-assert_eq!(call!(addi_ui8(3, 0)), 3);
-assert_eq!(call!(addi_ui8(0, 4)), 4);
-assert_eq!(call!(addi_ui8(1, 3)), 4);
-assert_eq!(call!(addi_ui8(2, 2)), 4);
-assert_eq!(call!(addi_ui8(3, 1)), 4);
-assert_eq!(call!(addi_ui8(4, 0)), 4);
-assert_eq!(call!(addi_ui8(1, 4)), 5);
-assert_eq!(call!(addi_ui8(2, 3)), 5);
-assert_eq!(call!(addi_ui8(3, 2)), 5);
-assert_eq!(call!(addi_ui8(4, 1)), 5);
-assert_eq!(call!(addi_ui8(2, 4)), 6);
-assert_eq!(call!(addi_ui8(3, 3)), 6);
-assert_eq!(call!(addi_ui8(4, 2)), 6);
-assert_eq!(call!(addi_ui8(3, 4)), 7);
-assert_eq!(call!(addi_ui8(4, 3)), 7);
-assert_eq!(call!(addi_ui8(4, 4)), 8);
-assert_eq!(call!(addi_ui8(0, 72)), 72);
-assert_eq!(call!(addi_ui8(72, 0)), 72);
-assert_eq!(call!(addi_ui8(1, 72)), 73);
-assert_eq!(call!(addi_ui8(72, 1)), 73);
-assert_eq!(call!(addi_ui8(2, 72)), 74);
-assert_eq!(call!(addi_ui8(72, 2)), 74);
-assert_eq!(call!(addi_ui8(3, 72)), 75);
-assert_eq!(call!(addi_ui8(72, 3)), 75);
-assert_eq!(call!(addi_ui8(4, 72)), 76);
-assert_eq!(call!(addi_ui8(72, 4)), 76);
-assert_eq!(call!(addi_ui8(0, 100)), 100);
-assert_eq!(call!(addi_ui8(100, 0)), 100);
-assert_eq!(call!(addi_ui8(1, 100)), 101);
-assert_eq!(call!(addi_ui8(100, 1)), 101);
-assert_eq!(call!(addi_ui8(2, 100)), 102);
-assert_eq!(call!(addi_ui8(100, 2)), 102);
-assert_eq!(call!(addi_ui8(3, 100)), 103);
-assert_eq!(call!(addi_ui8(100, 3)), 103);
-assert_eq!(call!(addi_ui8(4, 100)), 104);
-assert_eq!(call!(addi_ui8(100, 4)), 104);
-assert_eq!(call!(addi_ui8(72, 72)), 144);
-assert_eq!(call!(addi_ui8(0, 162)), 162);
-assert_eq!(call!(addi_ui8(162, 0)), 162);
-assert_eq!(call!(addi_ui8(1, 162)), 163);
-assert_eq!(call!(addi_ui8(162, 1)), 163);
-assert_eq!(call!(addi_ui8(2, 162)), 164);
-assert_eq!(call!(addi_ui8(162, 2)), 164);
-assert_eq!(call!(addi_ui8(3, 162)), 165);
-assert_eq!(call!(addi_ui8(162, 3)), 165);
-assert_eq!(call!(addi_ui8(4, 162)), 166);
-assert_eq!(call!(addi_ui8(162, 4)), 166);
-assert_eq!(call!(addi_ui8(72, 100)), 172);
-assert_eq!(call!(addi_ui8(100, 72)), 172);
-assert_eq!(call!(addi_ui8(100, 100)), 200);
-assert_eq!(call!(addi_ui8(72, 162)), 234);
-assert_eq!(call!(addi_ui8(162, 72)), 234);
-assert_eq!(call!(addi_ui8(0, 254)), 254);
-assert_eq!(call!(addi_ui8(254, 0)), 254);
-assert_eq!(call!(addi_ui8(0, 255)), 255);
-assert_eq!(call!(addi_ui8(1, 254)), 255);
-assert_eq!(call!(addi_ui8(254, 1)), 255);
-assert_eq!(call!(addi_ui8(255, 0)), 255);
-assert_eq!(call!(divi_si16(-32768, 1)), -32768);
-assert_eq!(call!(divi_si16(-32767, 1)), -32767);
-assert_eq!(call!(divi_si16(-32547, 1)), -32547);
-assert_eq!(call!(divi_si16(-32768, 2)), -16384);
-assert_eq!(call!(divi_si16(-32767, 2)), -16383);
-assert_eq!(call!(divi_si16(-32547, 2)), -16273);
-assert_eq!(call!(divi_si16(-32768, 3)), -10922);
-assert_eq!(call!(divi_si16(-32767, 3)), -10922);
-assert_eq!(call!(divi_si16(-32547, 3)), -10849);
-assert_eq!(call!(divi_si16(-32768, 4)), -8192);
-assert_eq!(call!(divi_si16(-32767, 4)), -8191);
-assert_eq!(call!(divi_si16(-32547, 4)), -8136);
-assert_eq!(call!(divi_si16(-32768, 10486)), -3);
-assert_eq!(call!(divi_si16(-32767, 10486)), -3);
-assert_eq!(call!(divi_si16(-32547, 10486)), -3);
-assert_eq!(call!(divi_si16(-32768, 16514)), -1);
-assert_eq!(call!(divi_si16(-32768, 32766)), -1);
-assert_eq!(call!(divi_si16(-32768, 32767)), -1);
-assert_eq!(call!(divi_si16(-32767, 16514)), -1);
-assert_eq!(call!(divi_si16(-32767, 32766)), -1);
-assert_eq!(call!(divi_si16(-32767, 32767)), -1);
-assert_eq!(call!(divi_si16(-32547, 16514)), -1);
-assert_eq!(call!(divi_si16(32766, -32547)), -1);
-assert_eq!(call!(divi_si16(32767, -32767)), -1);
-assert_eq!(call!(divi_si16(32767, -32547)), -1);
-assert_eq!(call!(divi_si16(-32767, -32768)), 0);
-assert_eq!(call!(divi_si16(-32547, -32768)), 0);
-assert_eq!(call!(divi_si16(-32547, -32767)), 0);
-assert_eq!(call!(divi_si16(-32547, 32766)), 0);
-assert_eq!(call!(divi_si16(-32547, 32767)), 0);
-assert_eq!(call!(divi_si16(0, -32768)), 0);
-assert_eq!(call!(divi_si16(0, -32767)), 0);
-assert_eq!(call!(divi_si16(0, -32547)), 0);
-assert_eq!(call!(divi_si16(0, 1)), 0);
-assert_eq!(call!(divi_si16(0, 2)), 0);
-assert_eq!(call!(divi_si16(0, 3)), 0);
-assert_eq!(call!(divi_si16(0, 4)), 0);
-assert_eq!(call!(divi_si16(0, 10486)), 0);
-assert_eq!(call!(divi_si16(0, 16514)), 0);
-assert_eq!(call!(divi_si16(0, 32766)), 0);
-assert_eq!(call!(divi_si16(0, 32767)), 0);
-assert_eq!(call!(divi_si16(1, -32768)), 0);
-assert_eq!(call!(divi_si16(1, -32767)), 0);
-assert_eq!(call!(divi_si16(1, -32547)), 0);
-assert_eq!(call!(divi_si16(1, 2)), 0);
-assert_eq!(call!(divi_si16(1, 3)), 0);
-assert_eq!(call!(divi_si16(1, 4)), 0);
-assert_eq!(call!(divi_si16(1, 10486)), 0);
-assert_eq!(call!(divi_si16(1, 16514)), 0);
-assert_eq!(call!(divi_si16(1, 32766)), 0);
-assert_eq!(call!(divi_si16(1, 32767)), 0);
-assert_eq!(call!(divi_si16(2, -32768)), 0);
-assert_eq!(call!(divi_si16(2, -32767)), 0);
-assert_eq!(call!(divi_si16(2, -32547)), 0);
-assert_eq!(call!(divi_si16(2, 3)), 0);
-assert_eq!(call!(divi_si16(2, 4)), 0);
-assert_eq!(call!(divi_si16(2, 10486)), 0);
-assert_eq!(call!(divi_si16(2, 16514)), 0);
-assert_eq!(call!(divi_si16(2, 32766)), 0);
-assert_eq!(call!(divi_si16(2, 32767)), 0);
-assert_eq!(call!(divi_si16(3, -32768)), 0);
-assert_eq!(call!(divi_si16(3, -32767)), 0);
-assert_eq!(call!(divi_si16(3, -32547)), 0);
-assert_eq!(call!(divi_si16(3, 4)), 0);
-assert_eq!(call!(divi_si16(3, 10486)), 0);
-assert_eq!(call!(divi_si16(3, 16514)), 0);
-assert_eq!(call!(divi_si16(3, 32766)), 0);
-assert_eq!(call!(divi_si16(3, 32767)), 0);
-assert_eq!(call!(divi_si16(4, -32768)), 0);
-assert_eq!(call!(divi_si16(4, -32767)), 0);
-assert_eq!(call!(divi_si16(4, -32547)), 0);
-assert_eq!(call!(divi_si16(4, 10486)), 0);
-assert_eq!(call!(divi_si16(4, 16514)), 0);
-assert_eq!(call!(divi_si16(4, 32766)), 0);
-assert_eq!(call!(divi_si16(4, 32767)), 0);
-assert_eq!(call!(divi_si16(10486, -32768)), 0);
-assert_eq!(call!(divi_si16(10486, -32767)), 0);
-assert_eq!(call!(divi_si16(10486, -32547)), 0);
-assert_eq!(call!(divi_si16(10486, 16514)), 0);
-assert_eq!(call!(divi_si16(10486, 32766)), 0);
-assert_eq!(call!(divi_si16(10486, 32767)), 0);
-assert_eq!(call!(divi_si16(16514, -32768)), 0);
-assert_eq!(call!(divi_si16(16514, -32767)), 0);
-assert_eq!(call!(divi_si16(16514, -32547)), 0);
-assert_eq!(call!(divi_si16(16514, 32766)), 0);
-assert_eq!(call!(divi_si16(16514, 32767)), 0);
-assert_eq!(call!(divi_si16(32766, -32768)), 0);
-assert_eq!(call!(divi_si16(32766, -32767)), 0);
-assert_eq!(call!(divi_si16(32766, 32767)), 0);
-assert_eq!(call!(divi_si16(32767, -32768)), 0);
-assert_eq!(call!(divi_si16(-32768, -32768)), 1);
-assert_eq!(call!(divi_si16(-32768, -32767)), 1);
-assert_eq!(call!(divi_si16(-32768, -32547)), 1);
-assert_eq!(call!(divi_si16(-32767, -32767)), 1);
-assert_eq!(call!(divi_si16(-32767, -32547)), 1);
-assert_eq!(call!(divi_si16(-32547, -32547)), 1);
-assert_eq!(call!(divi_si16(1, 1)), 1);
-assert_eq!(call!(divi_si16(2, 2)), 1);
-assert_eq!(call!(divi_si16(3, 2)), 1);
-assert_eq!(call!(divi_si16(3, 3)), 1);
-assert_eq!(call!(divi_si16(4, 3)), 1);
-assert_eq!(call!(divi_si16(4, 4)), 1);
-assert_eq!(call!(divi_si16(10486, 10486)), 1);
-assert_eq!(call!(divi_si16(16514, 10486)), 1);
-assert_eq!(call!(divi_si16(16514, 16514)), 1);
-assert_eq!(call!(divi_si16(32766, 16514)), 1);
-assert_eq!(call!(divi_si16(32766, 32766)), 1);
-assert_eq!(call!(divi_si16(32767, 16514)), 1);
-assert_eq!(call!(divi_si16(32767, 32766)), 1);
-assert_eq!(call!(divi_si16(32767, 32767)), 1);
-assert_eq!(call!(divi_si16(2, 1)), 2);
-assert_eq!(call!(divi_si16(4, 2)), 2);
-assert_eq!(call!(divi_si16(3, 1)), 3);
-assert_eq!(call!(divi_si16(32766, 10486)), 3);
-assert_eq!(call!(divi_si16(32767, 10486)), 3);
-assert_eq!(call!(divi_si16(4, 1)), 4);
-assert_eq!(call!(divi_si16(10486, 4)), 2621);
-assert_eq!(call!(divi_si16(10486, 3)), 3495);
-assert_eq!(call!(divi_si16(16514, 4)), 4128);
-assert_eq!(call!(divi_si16(10486, 2)), 5243);
-assert_eq!(call!(divi_si16(16514, 3)), 5504);
-assert_eq!(call!(divi_si16(32766, 4)), 8191);
-assert_eq!(call!(divi_si16(32767, 4)), 8191);
-assert_eq!(call!(divi_si16(16514, 2)), 8257);
-assert_eq!(call!(divi_si16(10486, 1)), 10486);
-assert_eq!(call!(divi_si16(32766, 3)), 10922);
-assert_eq!(call!(divi_si16(32767, 3)), 10922);
-assert_eq!(call!(divi_si16(32766, 2)), 16383);
-assert_eq!(call!(divi_si16(32767, 2)), 16383);
-assert_eq!(call!(divi_si16(16514, 1)), 16514);
-assert_eq!(call!(divi_si16(32766, 1)), 32766);
-assert_eq!(call!(divi_si16(32767, 1)), 32767);
-assert_eq!(call!(divi_si32(-2147483648, 1)), -2147483648);
-assert_eq!(call!(divi_si32(-2147483647, 1)), -2147483647);
-assert_eq!(call!(divi_si32(-1713183800, 1)), -1713183800);
-assert_eq!(call!(divi_si32(-1252582164, 1)), -1252582164);
-assert_eq!(call!(divi_si32(-2147483648, 2)), -1073741824);
-assert_eq!(call!(divi_si32(-2147483647, 2)), -1073741823);
-assert_eq!(call!(divi_si32(-1035405763, 1)), -1035405763);
-assert_eq!(call!(divi_si32(-1713183800, 2)), -856591900);
-assert_eq!(call!(divi_si32(-2147483648, 3)), -715827882);
-assert_eq!(call!(divi_si32(-2147483647, 3)), -715827882);
-assert_eq!(call!(divi_si32(-1252582164, 2)), -626291082);
-assert_eq!(call!(divi_si32(-1713183800, 3)), -571061266);
-assert_eq!(call!(divi_si32(-2147483648, 4)), -536870912);
-assert_eq!(call!(divi_si32(-2147483647, 4)), -536870911);
-assert_eq!(call!(divi_si32(-1035405763, 2)), -517702881);
-assert_eq!(call!(divi_si32(-1713183800, 4)), -428295950);
-assert_eq!(call!(divi_si32(-1252582164, 3)), -417527388);
-assert_eq!(call!(divi_si32(-1035405763, 3)), -345135254);
-assert_eq!(call!(divi_si32(-1252582164, 4)), -313145541);
-assert_eq!(call!(divi_si32(-1035405763, 4)), -258851440);
-assert_eq!(call!(divi_si32(2147483646, -1035405763)), -2);
-assert_eq!(call!(divi_si32(2147483647, -1035405763)), -2);
-assert_eq!(call!(divi_si32(-2147483648, 2147483646)), -1);
-assert_eq!(call!(divi_si32(-2147483648, 2147483647)), -1);
-assert_eq!(call!(divi_si32(-2147483647, 2147483646)), -1);
-assert_eq!(call!(divi_si32(-2147483647, 2147483647)), -1);
-assert_eq!(call!(divi_si32(2147483646, -1713183800)), -1);
-assert_eq!(call!(divi_si32(2147483646, -1252582164)), -1);
-assert_eq!(call!(divi_si32(2147483647, -2147483647)), -1);
-assert_eq!(call!(divi_si32(2147483647, -1713183800)), -1);
-assert_eq!(call!(divi_si32(2147483647, -1252582164)), -1);
-assert_eq!(call!(divi_si32(-2147483647, -2147483648)), 0);
-assert_eq!(call!(divi_si32(-1713183800, -2147483648)), 0);
-assert_eq!(call!(divi_si32(-1713183800, -2147483647)), 0);
-assert_eq!(call!(divi_si32(-1713183800, 2147483646)), 0);
-assert_eq!(call!(divi_si32(-1713183800, 2147483647)), 0);
-assert_eq!(call!(divi_si32(-1252582164, -2147483648)), 0);
-assert_eq!(call!(divi_si32(-1252582164, -2147483647)), 0);
-assert_eq!(call!(divi_si32(-1252582164, -1713183800)), 0);
-assert_eq!(call!(divi_si32(-1252582164, 2147483646)), 0);
-assert_eq!(call!(divi_si32(-1252582164, 2147483647)), 0);
-assert_eq!(call!(divi_si32(-1035405763, -2147483648)), 0);
-assert_eq!(call!(divi_si32(-1035405763, -2147483647)), 0);
-assert_eq!(call!(divi_si32(-1035405763, -1713183800)), 0);
-assert_eq!(call!(divi_si32(-1035405763, -1252582164)), 0);
-assert_eq!(call!(divi_si32(-1035405763, 2147483646)), 0);
-assert_eq!(call!(divi_si32(-1035405763, 2147483647)), 0);
-assert_eq!(call!(divi_si32(0, -2147483648)), 0);
-assert_eq!(call!(divi_si32(0, -2147483647)), 0);
-assert_eq!(call!(divi_si32(0, -1713183800)), 0);
-assert_eq!(call!(divi_si32(0, -1252582164)), 0);
-assert_eq!(call!(divi_si32(0, -1035405763)), 0);
-assert_eq!(call!(divi_si32(0, 1)), 0);
-assert_eq!(call!(divi_si32(0, 2)), 0);
-assert_eq!(call!(divi_si32(0, 3)), 0);
-assert_eq!(call!(divi_si32(0, 4)), 0);
-assert_eq!(call!(divi_si32(0, 2147483646)), 0);
-assert_eq!(call!(divi_si32(0, 2147483647)), 0);
-assert_eq!(call!(divi_si32(1, -2147483648)), 0);
-assert_eq!(call!(divi_si32(1, -2147483647)), 0);
-assert_eq!(call!(divi_si32(1, -1713183800)), 0);
-assert_eq!(call!(divi_si32(1, -1252582164)), 0);
-assert_eq!(call!(divi_si32(1, -1035405763)), 0);
-assert_eq!(call!(divi_si32(1, 2)), 0);
-assert_eq!(call!(divi_si32(1, 3)), 0);
-assert_eq!(call!(divi_si32(1, 4)), 0);
-assert_eq!(call!(divi_si32(1, 2147483646)), 0);
-assert_eq!(call!(divi_si32(1, 2147483647)), 0);
-assert_eq!(call!(divi_si32(2, -2147483648)), 0);
-assert_eq!(call!(divi_si32(2, -2147483647)), 0);
-assert_eq!(call!(divi_si32(2, -1713183800)), 0);
-assert_eq!(call!(divi_si32(2, -1252582164)), 0);
-assert_eq!(call!(divi_si32(2, -1035405763)), 0);
-assert_eq!(call!(divi_si32(2, 3)), 0);
-assert_eq!(call!(divi_si32(2, 4)), 0);
-assert_eq!(call!(divi_si32(2, 2147483646)), 0);
-assert_eq!(call!(divi_si32(2, 2147483647)), 0);
-assert_eq!(call!(divi_si32(3, -2147483648)), 0);
-assert_eq!(call!(divi_si32(3, -2147483647)), 0);
-assert_eq!(call!(divi_si32(3, -1713183800)), 0);
-assert_eq!(call!(divi_si32(3, -1252582164)), 0);
-assert_eq!(call!(divi_si32(3, -1035405763)), 0);
-assert_eq!(call!(divi_si32(3, 4)), 0);
-assert_eq!(call!(divi_si32(3, 2147483646)), 0);
-assert_eq!(call!(divi_si32(3, 2147483647)), 0);
-assert_eq!(call!(divi_si32(4, -2147483648)), 0);
-assert_eq!(call!(divi_si32(4, -2147483647)), 0);
-assert_eq!(call!(divi_si32(4, -1713183800)), 0);
-assert_eq!(call!(divi_si32(4, -1252582164)), 0);
-assert_eq!(call!(divi_si32(4, -1035405763)), 0);
-assert_eq!(call!(divi_si32(4, 2147483646)), 0);
-assert_eq!(call!(divi_si32(4, 2147483647)), 0);
-assert_eq!(call!(divi_si32(2147483646, -2147483648)), 0);
-assert_eq!(call!(divi_si32(2147483646, -2147483647)), 0);
-assert_eq!(call!(divi_si32(2147483646, 2147483647)), 0);
-assert_eq!(call!(divi_si32(2147483647, -2147483648)), 0);
-assert_eq!(call!(divi_si32(-2147483648, -2147483648)), 1);
-assert_eq!(call!(divi_si32(-2147483648, -2147483647)), 1);
-assert_eq!(call!(divi_si32(-2147483648, -1713183800)), 1);
-assert_eq!(call!(divi_si32(-2147483648, -1252582164)), 1);
-assert_eq!(call!(divi_si32(-2147483647, -2147483647)), 1);
-assert_eq!(call!(divi_si32(-2147483647, -1713183800)), 1);
-assert_eq!(call!(divi_si32(-2147483647, -1252582164)), 1);
-assert_eq!(call!(divi_si32(-1713183800, -1713183800)), 1);
-assert_eq!(call!(divi_si32(-1713183800, -1252582164)), 1);
-assert_eq!(call!(divi_si32(-1713183800, -1035405763)), 1);
-assert_eq!(call!(divi_si32(-1252582164, -1252582164)), 1);
-assert_eq!(call!(divi_si32(-1252582164, -1035405763)), 1);
-assert_eq!(call!(divi_si32(-1035405763, -1035405763)), 1);
-assert_eq!(call!(divi_si32(1, 1)), 1);
-assert_eq!(call!(divi_si32(2, 2)), 1);
-assert_eq!(call!(divi_si32(3, 2)), 1);
-assert_eq!(call!(divi_si32(3, 3)), 1);
-assert_eq!(call!(divi_si32(4, 3)), 1);
-assert_eq!(call!(divi_si32(4, 4)), 1);
-assert_eq!(call!(divi_si32(2147483646, 2147483646)), 1);
-assert_eq!(call!(divi_si32(2147483647, 2147483646)), 1);
-assert_eq!(call!(divi_si32(2147483647, 2147483647)), 1);
-assert_eq!(call!(divi_si32(-2147483648, -1035405763)), 2);
-assert_eq!(call!(divi_si32(-2147483647, -1035405763)), 2);
-assert_eq!(call!(divi_si32(2, 1)), 2);
-assert_eq!(call!(divi_si32(4, 2)), 2);
-assert_eq!(call!(divi_si32(3, 1)), 3);
-assert_eq!(call!(divi_si32(4, 1)), 4);
-assert_eq!(call!(divi_si32(2147483646, 4)), 536870911);
-assert_eq!(call!(divi_si32(2147483647, 4)), 536870911);
-assert_eq!(call!(divi_si32(2147483646, 3)), 715827882);
-assert_eq!(call!(divi_si32(2147483647, 3)), 715827882);
-assert_eq!(call!(divi_si32(2147483646, 2)), 1073741823);
-assert_eq!(call!(divi_si32(2147483647, 2)), 1073741823);
-assert_eq!(call!(divi_si32(2147483646, 1)), 2147483646);
-assert_eq!(call!(divi_si32(2147483647, 1)), 2147483647);
-assert_eq!(call!(divi_si64(-9223372036854775808, 1)), -9223372036854775808);
-assert_eq!(call!(divi_si64(-9223372036854775807, 1)), -9223372036854775807);
-assert_eq!(call!(divi_si64(-9223372036854775808, 2)), -4611686018427387904);
-assert_eq!(call!(divi_si64(-9223372036854775807, 2)), -4611686018427387903);
-assert_eq!(call!(divi_si64(-9223372036854775808, 3)), -3074457345618258602);
-assert_eq!(call!(divi_si64(-9223372036854775807, 3)), -3074457345618258602);
-assert_eq!(call!(divi_si64(-9223372036854775808, 4)), -2305843009213693952);
-assert_eq!(call!(divi_si64(-9223372036854775807, 4)), -2305843009213693951);
-assert_eq!(call!(divi_si64(-1741927215160008704, 1)), -1741927215160008704);
-assert_eq!(call!(divi_si64(-1328271339354574848, 1)), -1328271339354574848);
-assert_eq!(call!(divi_si64(-1741927215160008704, 2)), -870963607580004352);
-assert_eq!(call!(divi_si64(-1328271339354574848, 2)), -664135669677287424);
-assert_eq!(call!(divi_si64(-1741927215160008704, 3)), -580642405053336234);
-assert_eq!(call!(divi_si64(-1328271339354574848, 3)), -442757113118191616);
-assert_eq!(call!(divi_si64(-1741927215160008704, 4)), -435481803790002176);
-assert_eq!(call!(divi_si64(-1328271339354574848, 4)), -332067834838643712);
-assert_eq!(call!(divi_si64(9223372036854775806, -1328271339354574848)), -6);
-assert_eq!(call!(divi_si64(9223372036854775807, -1328271339354574848)), -6);
-assert_eq!(call!(divi_si64(9223372036854775806, -1741927215160008704)), -5);
-assert_eq!(call!(divi_si64(9223372036854775807, -1741927215160008704)), -5);
-assert_eq!(call!(divi_si64(5577148965131116544, -1328271339354574848)), -4);
-assert_eq!(call!(divi_si64(5577148965131116544, -1741927215160008704)), -3);
-assert_eq!(call!(divi_si64(-9223372036854775808, 5577148965131116544)), -1);
-assert_eq!(call!(divi_si64(-9223372036854775808, 9223372036854775806)), -1);
-assert_eq!(call!(divi_si64(-9223372036854775808, 9223372036854775807)), -1);
-assert_eq!(call!(divi_si64(-9223372036854775807, 5577148965131116544)), -1);
-assert_eq!(call!(divi_si64(-9223372036854775807, 9223372036854775806)), -1);
-assert_eq!(call!(divi_si64(-9223372036854775807, 9223372036854775807)), -1);
-assert_eq!(call!(divi_si64(9223372036854775807, -9223372036854775807)), -1);
-assert_eq!(call!(divi_si64(-9223372036854775807, -9223372036854775808)), 0);
-assert_eq!(call!(divi_si64(-1741927215160008704, -9223372036854775808)), 0);
-assert_eq!(call!(divi_si64(-1741927215160008704, -9223372036854775807)), 0);
-assert_eq!(call!(divi_si64(-1741927215160008704, 5577148965131116544)), 0);
-assert_eq!(call!(divi_si64(-1741927215160008704, 9223372036854775806)), 0);
-assert_eq!(call!(divi_si64(-1741927215160008704, 9223372036854775807)), 0);
-assert_eq!(call!(divi_si64(-1328271339354574848, -9223372036854775808)), 0);
-assert_eq!(call!(divi_si64(-1328271339354574848, -9223372036854775807)), 0);
-assert_eq!(call!(divi_si64(-1328271339354574848, -1741927215160008704)), 0);
-assert_eq!(call!(divi_si64(-1328271339354574848, 5577148965131116544)), 0);
-assert_eq!(call!(divi_si64(-1328271339354574848, 9223372036854775806)), 0);
-assert_eq!(call!(divi_si64(-1328271339354574848, 9223372036854775807)), 0);
-assert_eq!(call!(divi_si64(0, -9223372036854775808)), 0);
-assert_eq!(call!(divi_si64(0, -9223372036854775807)), 0);
-assert_eq!(call!(divi_si64(0, -1741927215160008704)), 0);
-assert_eq!(call!(divi_si64(0, -1328271339354574848)), 0);
-assert_eq!(call!(divi_si64(0, 1)), 0);
-assert_eq!(call!(divi_si64(0, 2)), 0);
-assert_eq!(call!(divi_si64(0, 3)), 0);
-assert_eq!(call!(divi_si64(0, 4)), 0);
-assert_eq!(call!(divi_si64(0, 5577148965131116544)), 0);
-assert_eq!(call!(divi_si64(0, 9223372036854775806)), 0);
-assert_eq!(call!(divi_si64(0, 9223372036854775807)), 0);
-assert_eq!(call!(divi_si64(1, -9223372036854775808)), 0);
-assert_eq!(call!(divi_si64(1, -9223372036854775807)), 0);
-assert_eq!(call!(divi_si64(1, -1741927215160008704)), 0);
-assert_eq!(call!(divi_si64(1, -1328271339354574848)), 0);
-assert_eq!(call!(divi_si64(1, 2)), 0);
-assert_eq!(call!(divi_si64(1, 3)), 0);
-assert_eq!(call!(divi_si64(1, 4)), 0);
-assert_eq!(call!(divi_si64(1, 5577148965131116544)), 0);
-assert_eq!(call!(divi_si64(1, 9223372036854775806)), 0);
-assert_eq!(call!(divi_si64(1, 9223372036854775807)), 0);
-assert_eq!(call!(divi_si64(2, -9223372036854775808)), 0);
-assert_eq!(call!(divi_si64(2, -9223372036854775807)), 0);
-assert_eq!(call!(divi_si64(2, -1741927215160008704)), 0);
-assert_eq!(call!(divi_si64(2, -1328271339354574848)), 0);
-assert_eq!(call!(divi_si64(2, 3)), 0);
-assert_eq!(call!(divi_si64(2, 4)), 0);
-assert_eq!(call!(divi_si64(2, 5577148965131116544)), 0);
-assert_eq!(call!(divi_si64(2, 9223372036854775806)), 0);
-assert_eq!(call!(divi_si64(2, 9223372036854775807)), 0);
-assert_eq!(call!(divi_si64(3, -9223372036854775808)), 0);
-assert_eq!(call!(divi_si64(3, -9223372036854775807)), 0);
-assert_eq!(call!(divi_si64(3, -1741927215160008704)), 0);
-assert_eq!(call!(divi_si64(3, -1328271339354574848)), 0);
-assert_eq!(call!(divi_si64(3, 4)), 0);
-assert_eq!(call!(divi_si64(3, 5577148965131116544)), 0);
-assert_eq!(call!(divi_si64(3, 9223372036854775806)), 0);
-assert_eq!(call!(divi_si64(3, 9223372036854775807)), 0);
-assert_eq!(call!(divi_si64(4, -9223372036854775808)), 0);
-assert_eq!(call!(divi_si64(4, -9223372036854775807)), 0);
-assert_eq!(call!(divi_si64(4, -1741927215160008704)), 0);
-assert_eq!(call!(divi_si64(4, -1328271339354574848)), 0);
-assert_eq!(call!(divi_si64(4, 5577148965131116544)), 0);
-assert_eq!(call!(divi_si64(4, 9223372036854775806)), 0);
-assert_eq!(call!(divi_si64(4, 9223372036854775807)), 0);
-assert_eq!(call!(divi_si64(5577148965131116544, -9223372036854775808)), 0);
-assert_eq!(call!(divi_si64(5577148965131116544, -9223372036854775807)), 0);
-assert_eq!(call!(divi_si64(5577148965131116544, 9223372036854775806)), 0);
-assert_eq!(call!(divi_si64(5577148965131116544, 9223372036854775807)), 0);
-assert_eq!(call!(divi_si64(9223372036854775806, -9223372036854775808)), 0);
-assert_eq!(call!(divi_si64(9223372036854775806, -9223372036854775807)), 0);
-assert_eq!(call!(divi_si64(9223372036854775806, 9223372036854775807)), 0);
-assert_eq!(call!(divi_si64(9223372036854775807, -9223372036854775808)), 0);
-assert_eq!(call!(divi_si64(-9223372036854775808, -9223372036854775808)), 1);
-assert_eq!(call!(divi_si64(-9223372036854775808, -9223372036854775807)), 1);
-assert_eq!(call!(divi_si64(-9223372036854775807, -9223372036854775807)), 1);
-assert_eq!(call!(divi_si64(-1741927215160008704, -1741927215160008704)), 1);
-assert_eq!(call!(divi_si64(-1741927215160008704, -1328271339354574848)), 1);
-assert_eq!(call!(divi_si64(-1328271339354574848, -1328271339354574848)), 1);
-assert_eq!(call!(divi_si64(1, 1)), 1);
-assert_eq!(call!(divi_si64(2, 2)), 1);
-assert_eq!(call!(divi_si64(3, 2)), 1);
-assert_eq!(call!(divi_si64(3, 3)), 1);
-assert_eq!(call!(divi_si64(4, 3)), 1);
-assert_eq!(call!(divi_si64(4, 4)), 1);
-assert_eq!(call!(divi_si64(5577148965131116544, 5577148965131116544)), 1);
-assert_eq!(call!(divi_si64(9223372036854775806, 5577148965131116544)), 1);
-assert_eq!(call!(divi_si64(9223372036854775806, 9223372036854775806)), 1);
-assert_eq!(call!(divi_si64(9223372036854775807, 5577148965131116544)), 1);
-assert_eq!(call!(divi_si64(9223372036854775807, 9223372036854775806)), 1);
-assert_eq!(call!(divi_si64(9223372036854775807, 9223372036854775807)), 1);
-assert_eq!(call!(divi_si64(2, 1)), 2);
-assert_eq!(call!(divi_si64(4, 2)), 2);
-assert_eq!(call!(divi_si64(3, 1)), 3);
-assert_eq!(call!(divi_si64(4, 1)), 4);
-assert_eq!(call!(divi_si64(-9223372036854775808, -1741927215160008704)), 5);
-assert_eq!(call!(divi_si64(-9223372036854775807, -1741927215160008704)), 5);
-assert_eq!(call!(divi_si64(-9223372036854775808, -1328271339354574848)), 6);
-assert_eq!(call!(divi_si64(-9223372036854775807, -1328271339354574848)), 6);
-assert_eq!(call!(divi_si64(5577148965131116544, 4)), 1394287241282779136);
-assert_eq!(call!(divi_si64(5577148965131116544, 3)), 1859049655043705514);
-assert_eq!(call!(divi_si64(9223372036854775806, 4)), 2305843009213693951);
-assert_eq!(call!(divi_si64(9223372036854775807, 4)), 2305843009213693951);
-assert_eq!(call!(divi_si64(5577148965131116544, 2)), 2788574482565558272);
-assert_eq!(call!(divi_si64(9223372036854775806, 3)), 3074457345618258602);
-assert_eq!(call!(divi_si64(9223372036854775807, 3)), 3074457345618258602);
-assert_eq!(call!(divi_si64(9223372036854775806, 2)), 4611686018427387903);
-assert_eq!(call!(divi_si64(9223372036854775807, 2)), 4611686018427387903);
-assert_eq!(call!(divi_si64(5577148965131116544, 1)), 5577148965131116544);
-assert_eq!(call!(divi_si64(9223372036854775806, 1)), 9223372036854775806);
-assert_eq!(call!(divi_si64(9223372036854775807, 1)), 9223372036854775807);
-assert_eq!(call!(divi_si8(-128, 1)), -128);
-assert_eq!(call!(divi_si8(-127, 1)), -127);
-assert_eq!(call!(divi_si8(-128, 2)), -64);
-assert_eq!(call!(divi_si8(-127, 2)), -63);
-assert_eq!(call!(divi_si8(-128, 3)), -42);
-assert_eq!(call!(divi_si8(-127, 3)), -42);
-assert_eq!(call!(divi_si8(-128, 4)), -32);
-assert_eq!(call!(divi_si8(-127, 4)), -31);
-assert_eq!(call!(divi_si8(-128, 16)), -8);
-assert_eq!(call!(divi_si8(-127, 16)), -7);
-assert_eq!(call!(divi_si8(-128, 126)), -1);
-assert_eq!(call!(divi_si8(-128, 127)), -1);
-assert_eq!(call!(divi_si8(-127, 126)), -1);
-assert_eq!(call!(divi_si8(-127, 127)), -1);
-assert_eq!(call!(divi_si8(127, -127)), -1);
-assert_eq!(call!(divi_si8(-127, -128)), 0);
-assert_eq!(call!(divi_si8(0, -128)), 0);
-assert_eq!(call!(divi_si8(0, -127)), 0);
-assert_eq!(call!(divi_si8(0, 1)), 0);
-assert_eq!(call!(divi_si8(0, 2)), 0);
-assert_eq!(call!(divi_si8(0, 3)), 0);
-assert_eq!(call!(divi_si8(0, 4)), 0);
-assert_eq!(call!(divi_si8(0, 16)), 0);
-assert_eq!(call!(divi_si8(0, 126)), 0);
-assert_eq!(call!(divi_si8(0, 127)), 0);
-assert_eq!(call!(divi_si8(1, -128)), 0);
-assert_eq!(call!(divi_si8(1, -127)), 0);
-assert_eq!(call!(divi_si8(1, 2)), 0);
-assert_eq!(call!(divi_si8(1, 3)), 0);
-assert_eq!(call!(divi_si8(1, 4)), 0);
-assert_eq!(call!(divi_si8(1, 16)), 0);
-assert_eq!(call!(divi_si8(1, 126)), 0);
-assert_eq!(call!(divi_si8(1, 127)), 0);
-assert_eq!(call!(divi_si8(2, -128)), 0);
-assert_eq!(call!(divi_si8(2, -127)), 0);
-assert_eq!(call!(divi_si8(2, 3)), 0);
-assert_eq!(call!(divi_si8(2, 4)), 0);
-assert_eq!(call!(divi_si8(2, 16)), 0);
-assert_eq!(call!(divi_si8(2, 126)), 0);
-assert_eq!(call!(divi_si8(2, 127)), 0);
-assert_eq!(call!(divi_si8(3, -128)), 0);
-assert_eq!(call!(divi_si8(3, -127)), 0);
-assert_eq!(call!(divi_si8(3, 4)), 0);
-assert_eq!(call!(divi_si8(3, 16)), 0);
-assert_eq!(call!(divi_si8(3, 126)), 0);
-assert_eq!(call!(divi_si8(3, 127)), 0);
-assert_eq!(call!(divi_si8(4, -128)), 0);
-assert_eq!(call!(divi_si8(4, -127)), 0);
-assert_eq!(call!(divi_si8(4, 16)), 0);
-assert_eq!(call!(divi_si8(4, 126)), 0);
-assert_eq!(call!(divi_si8(4, 127)), 0);
-assert_eq!(call!(divi_si8(16, -128)), 0);
-assert_eq!(call!(divi_si8(16, -127)), 0);
-assert_eq!(call!(divi_si8(16, 126)), 0);
-assert_eq!(call!(divi_si8(16, 127)), 0);
-assert_eq!(call!(divi_si8(126, -128)), 0);
-assert_eq!(call!(divi_si8(126, -127)), 0);
-assert_eq!(call!(divi_si8(126, 127)), 0);
-assert_eq!(call!(divi_si8(127, -128)), 0);
-assert_eq!(call!(divi_si8(-128, -128)), 1);
-assert_eq!(call!(divi_si8(-128, -127)), 1);
-assert_eq!(call!(divi_si8(-127, -127)), 1);
-assert_eq!(call!(divi_si8(1, 1)), 1);
-assert_eq!(call!(divi_si8(2, 2)), 1);
-assert_eq!(call!(divi_si8(3, 2)), 1);
-assert_eq!(call!(divi_si8(3, 3)), 1);
-assert_eq!(call!(divi_si8(4, 3)), 1);
-assert_eq!(call!(divi_si8(4, 4)), 1);
-assert_eq!(call!(divi_si8(16, 16)), 1);
-assert_eq!(call!(divi_si8(126, 126)), 1);
-assert_eq!(call!(divi_si8(127, 126)), 1);
-assert_eq!(call!(divi_si8(127, 127)), 1);
-assert_eq!(call!(divi_si8(2, 1)), 2);
-assert_eq!(call!(divi_si8(4, 2)), 2);
-assert_eq!(call!(divi_si8(3, 1)), 3);
-assert_eq!(call!(divi_si8(4, 1)), 4);
-assert_eq!(call!(divi_si8(16, 4)), 4);
-assert_eq!(call!(divi_si8(16, 3)), 5);
-assert_eq!(call!(divi_si8(126, 16)), 7);
-assert_eq!(call!(divi_si8(127, 16)), 7);
-assert_eq!(call!(divi_si8(16, 2)), 8);
-assert_eq!(call!(divi_si8(16, 1)), 16);
-assert_eq!(call!(divi_si8(126, 4)), 31);
-assert_eq!(call!(divi_si8(127, 4)), 31);
-assert_eq!(call!(divi_si8(126, 3)), 42);
-assert_eq!(call!(divi_si8(127, 3)), 42);
-assert_eq!(call!(divi_si8(126, 2)), 63);
-assert_eq!(call!(divi_si8(127, 2)), 63);
-assert_eq!(call!(divi_si8(126, 1)), 126);
-assert_eq!(call!(divi_si8(127, 1)), 127);
-assert_eq!(call!(divi_ui16(0, 1)), 0);
-assert_eq!(call!(divi_ui16(0, 2)), 0);
-assert_eq!(call!(divi_ui16(0, 3)), 0);
-assert_eq!(call!(divi_ui16(0, 4)), 0);
-assert_eq!(call!(divi_ui16(0, 1717)), 0);
-assert_eq!(call!(divi_ui16(0, 17988)), 0);
-assert_eq!(call!(divi_ui16(0, 65096)), 0);
-assert_eq!(call!(divi_ui16(0, 65534)), 0);
-assert_eq!(call!(divi_ui16(0, 65535)), 0);
-assert_eq!(call!(divi_ui16(1, 2)), 0);
-assert_eq!(call!(divi_ui16(1, 3)), 0);
-assert_eq!(call!(divi_ui16(1, 4)), 0);
-assert_eq!(call!(divi_ui16(1, 1717)), 0);
-assert_eq!(call!(divi_ui16(1, 17988)), 0);
-assert_eq!(call!(divi_ui16(1, 65096)), 0);
-assert_eq!(call!(divi_ui16(1, 65534)), 0);
-assert_eq!(call!(divi_ui16(1, 65535)), 0);
-assert_eq!(call!(divi_ui16(2, 3)), 0);
-assert_eq!(call!(divi_ui16(2, 4)), 0);
-assert_eq!(call!(divi_ui16(2, 1717)), 0);
-assert_eq!(call!(divi_ui16(2, 17988)), 0);
-assert_eq!(call!(divi_ui16(2, 65096)), 0);
-assert_eq!(call!(divi_ui16(2, 65534)), 0);
-assert_eq!(call!(divi_ui16(2, 65535)), 0);
-assert_eq!(call!(divi_ui16(3, 4)), 0);
-assert_eq!(call!(divi_ui16(3, 1717)), 0);
-assert_eq!(call!(divi_ui16(3, 17988)), 0);
-assert_eq!(call!(divi_ui16(3, 65096)), 0);
-assert_eq!(call!(divi_ui16(3, 65534)), 0);
-assert_eq!(call!(divi_ui16(3, 65535)), 0);
-assert_eq!(call!(divi_ui16(4, 1717)), 0);
-assert_eq!(call!(divi_ui16(4, 17988)), 0);
-assert_eq!(call!(divi_ui16(4, 65096)), 0);
-assert_eq!(call!(divi_ui16(4, 65534)), 0);
-assert_eq!(call!(divi_ui16(4, 65535)), 0);
-assert_eq!(call!(divi_ui16(1717, 17988)), 0);
-assert_eq!(call!(divi_ui16(1717, 65096)), 0);
-assert_eq!(call!(divi_ui16(1717, 65534)), 0);
-assert_eq!(call!(divi_ui16(1717, 65535)), 0);
-assert_eq!(call!(divi_ui16(17988, 65096)), 0);
-assert_eq!(call!(divi_ui16(17988, 65534)), 0);
-assert_eq!(call!(divi_ui16(17988, 65535)), 0);
-assert_eq!(call!(divi_ui16(65096, 65534)), 0);
-assert_eq!(call!(divi_ui16(65096, 65535)), 0);
-assert_eq!(call!(divi_ui16(65534, 65535)), 0);
-assert_eq!(call!(divi_ui16(1, 1)), 1);
-assert_eq!(call!(divi_ui16(2, 2)), 1);
-assert_eq!(call!(divi_ui16(3, 2)), 1);
-assert_eq!(call!(divi_ui16(3, 3)), 1);
-assert_eq!(call!(divi_ui16(4, 3)), 1);
-assert_eq!(call!(divi_ui16(4, 4)), 1);
-assert_eq!(call!(divi_ui16(1717, 1717)), 1);
-assert_eq!(call!(divi_ui16(17988, 17988)), 1);
-assert_eq!(call!(divi_ui16(65096, 65096)), 1);
-assert_eq!(call!(divi_ui16(65534, 65096)), 1);
-assert_eq!(call!(divi_ui16(65534, 65534)), 1);
-assert_eq!(call!(divi_ui16(65535, 65096)), 1);
-assert_eq!(call!(divi_ui16(65535, 65534)), 1);
-assert_eq!(call!(divi_ui16(65535, 65535)), 1);
-assert_eq!(call!(divi_ui16(2, 1)), 2);
-assert_eq!(call!(divi_ui16(4, 2)), 2);
-assert_eq!(call!(divi_ui16(3, 1)), 3);
-assert_eq!(call!(divi_ui16(65096, 17988)), 3);
-assert_eq!(call!(divi_ui16(65534, 17988)), 3);
-assert_eq!(call!(divi_ui16(65535, 17988)), 3);
-assert_eq!(call!(divi_ui16(4, 1)), 4);
-assert_eq!(call!(divi_ui16(17988, 1717)), 10);
-assert_eq!(call!(divi_ui16(65096, 1717)), 37);
-assert_eq!(call!(divi_ui16(65534, 1717)), 38);
-assert_eq!(call!(divi_ui16(65535, 1717)), 38);
-assert_eq!(call!(divi_ui16(1717, 4)), 429);
-assert_eq!(call!(divi_ui16(1717, 3)), 572);
-assert_eq!(call!(divi_ui16(1717, 2)), 858);
-assert_eq!(call!(divi_ui16(1717, 1)), 1717);
-assert_eq!(call!(divi_ui16(17988, 4)), 4497);
-assert_eq!(call!(divi_ui16(17988, 3)), 5996);
-assert_eq!(call!(divi_ui16(17988, 2)), 8994);
-assert_eq!(call!(divi_ui16(65096, 4)), 16274);
-assert_eq!(call!(divi_ui16(65534, 4)), 16383);
-assert_eq!(call!(divi_ui16(65535, 4)), 16383);
-assert_eq!(call!(divi_ui16(17988, 1)), 17988);
-assert_eq!(call!(divi_ui16(65096, 3)), 21698);
-assert_eq!(call!(divi_ui16(65534, 3)), 21844);
-assert_eq!(call!(divi_ui16(65535, 3)), 21845);
-assert_eq!(call!(divi_ui16(65096, 2)), 32548);
-assert_eq!(call!(divi_ui16(65534, 2)), 32767);
-assert_eq!(call!(divi_ui16(65535, 2)), 32767);
-assert_eq!(call!(divi_ui16(65096, 1)), 65096);
-assert_eq!(call!(divi_ui16(65534, 1)), 65534);
-assert_eq!(call!(divi_ui16(65535, 1)), 65535);
-assert_eq!(call!(divi_ui32(0, 1)), 0);
-assert_eq!(call!(divi_ui32(0, 2)), 0);
-assert_eq!(call!(divi_ui32(0, 3)), 0);
-assert_eq!(call!(divi_ui32(0, 4)), 0);
-assert_eq!(call!(divi_ui32(0, 2119154652)), 0);
-assert_eq!(call!(divi_ui32(0, 3002788344)), 0);
-assert_eq!(call!(divi_ui32(0, 3482297128)), 0);
-assert_eq!(call!(divi_ui32(0, 4294967294)), 0);
-assert_eq!(call!(divi_ui32(0, 4294967295)), 0);
-assert_eq!(call!(divi_ui32(1, 2)), 0);
-assert_eq!(call!(divi_ui32(1, 3)), 0);
-assert_eq!(call!(divi_ui32(1, 4)), 0);
-assert_eq!(call!(divi_ui32(1, 2119154652)), 0);
-assert_eq!(call!(divi_ui32(1, 3002788344)), 0);
-assert_eq!(call!(divi_ui32(1, 3482297128)), 0);
-assert_eq!(call!(divi_ui32(1, 4294967294)), 0);
-assert_eq!(call!(divi_ui32(1, 4294967295)), 0);
-assert_eq!(call!(divi_ui32(2, 3)), 0);
-assert_eq!(call!(divi_ui32(2, 4)), 0);
-assert_eq!(call!(divi_ui32(2, 2119154652)), 0);
-assert_eq!(call!(divi_ui32(2, 3002788344)), 0);
-assert_eq!(call!(divi_ui32(2, 3482297128)), 0);
-assert_eq!(call!(divi_ui32(2, 4294967294)), 0);
-assert_eq!(call!(divi_ui32(2, 4294967295)), 0);
-assert_eq!(call!(divi_ui32(3, 4)), 0);
-assert_eq!(call!(divi_ui32(3, 2119154652)), 0);
-assert_eq!(call!(divi_ui32(3, 3002788344)), 0);
-assert_eq!(call!(divi_ui32(3, 3482297128)), 0);
-assert_eq!(call!(divi_ui32(3, 4294967294)), 0);
-assert_eq!(call!(divi_ui32(3, 4294967295)), 0);
-assert_eq!(call!(divi_ui32(4, 2119154652)), 0);
-assert_eq!(call!(divi_ui32(4, 3002788344)), 0);
-assert_eq!(call!(divi_ui32(4, 3482297128)), 0);
-assert_eq!(call!(divi_ui32(4, 4294967294)), 0);
-assert_eq!(call!(divi_ui32(4, 4294967295)), 0);
-assert_eq!(call!(divi_ui32(2119154652, 3002788344)), 0);
-assert_eq!(call!(divi_ui32(2119154652, 3482297128)), 0);
-assert_eq!(call!(divi_ui32(2119154652, 4294967294)), 0);
-assert_eq!(call!(divi_ui32(2119154652, 4294967295)), 0);
-assert_eq!(call!(divi_ui32(3002788344, 3482297128)), 0);
-assert_eq!(call!(divi_ui32(3002788344, 4294967294)), 0);
-assert_eq!(call!(divi_ui32(3002788344, 4294967295)), 0);
-assert_eq!(call!(divi_ui32(3482297128, 4294967294)), 0);
-assert_eq!(call!(divi_ui32(3482297128, 4294967295)), 0);
-assert_eq!(call!(divi_ui32(4294967294, 4294967295)), 0);
-assert_eq!(call!(divi_ui32(1, 1)), 1);
-assert_eq!(call!(divi_ui32(2, 2)), 1);
-assert_eq!(call!(divi_ui32(3, 2)), 1);
-assert_eq!(call!(divi_ui32(3, 3)), 1);
-assert_eq!(call!(divi_ui32(4, 3)), 1);
-assert_eq!(call!(divi_ui32(4, 4)), 1);
-assert_eq!(call!(divi_ui32(2119154652, 2119154652)), 1);
-assert_eq!(call!(divi_ui32(3002788344, 2119154652)), 1);
-assert_eq!(call!(divi_ui32(3002788344, 3002788344)), 1);
-assert_eq!(call!(divi_ui32(3482297128, 2119154652)), 1);
-assert_eq!(call!(divi_ui32(3482297128, 3002788344)), 1);
-assert_eq!(call!(divi_ui32(3482297128, 3482297128)), 1);
-assert_eq!(call!(divi_ui32(4294967294, 3002788344)), 1);
-assert_eq!(call!(divi_ui32(4294967294, 3482297128)), 1);
-assert_eq!(call!(divi_ui32(4294967294, 4294967294)), 1);
-assert_eq!(call!(divi_ui32(4294967295, 3002788344)), 1);
-assert_eq!(call!(divi_ui32(4294967295, 3482297128)), 1);
-assert_eq!(call!(divi_ui32(4294967295, 4294967294)), 1);
-assert_eq!(call!(divi_ui32(4294967295, 4294967295)), 1);
-assert_eq!(call!(divi_ui32(2, 1)), 2);
-assert_eq!(call!(divi_ui32(4, 2)), 2);
-assert_eq!(call!(divi_ui32(4294967294, 2119154652)), 2);
-assert_eq!(call!(divi_ui32(4294967295, 2119154652)), 2);
-assert_eq!(call!(divi_ui32(3, 1)), 3);
-assert_eq!(call!(divi_ui32(4, 1)), 4);
-assert_eq!(call!(divi_ui32(2119154652, 4)), 529788663);
-assert_eq!(call!(divi_ui32(2119154652, 3)), 706384884);
-assert_eq!(call!(divi_ui32(3002788344, 4)), 750697086);
-assert_eq!(call!(divi_ui32(3482297128, 4)), 870574282);
-assert_eq!(call!(divi_ui32(3002788344, 3)), 1000929448);
-assert_eq!(call!(divi_ui32(2119154652, 2)), 1059577326);
-assert_eq!(call!(divi_ui32(4294967294, 4)), 1073741823);
-assert_eq!(call!(divi_ui32(4294967295, 4)), 1073741823);
-assert_eq!(call!(divi_ui32(3482297128, 3)), 1160765709);
-assert_eq!(call!(divi_ui32(4294967294, 3)), 1431655764);
-assert_eq!(call!(divi_ui32(4294967295, 3)), 1431655765);
-assert_eq!(call!(divi_ui32(3002788344, 2)), 1501394172);
-assert_eq!(call!(divi_ui32(3482297128, 2)), 1741148564);
-assert_eq!(call!(divi_ui32(2119154652, 1)), 2119154652);
-assert_eq!(call!(divi_ui32(4294967294, 2)), 2147483647);
-assert_eq!(call!(divi_ui32(4294967295, 2)), 2147483647);
-assert_eq!(call!(divi_ui32(3002788344, 1)), 3002788344);
-assert_eq!(call!(divi_ui32(3482297128, 1)), 3482297128);
-assert_eq!(call!(divi_ui32(4294967294, 1)), 4294967294);
-assert_eq!(call!(divi_ui32(4294967295, 1)), 4294967295);
-assert_eq!(call!(divi_ui64(0, 1)), 0);
-assert_eq!(call!(divi_ui64(0, 2)), 0);
-assert_eq!(call!(divi_ui64(0, 3)), 0);
-assert_eq!(call!(divi_ui64(0, 4)), 0);
-assert_eq!(call!(divi_ui64(0, 191084152064409600)), 0);
-assert_eq!(call!(divi_ui64(0, 11015955194427482112)), 0);
-assert_eq!(call!(divi_ui64(0, 16990600415051759616)), 0);
-assert_eq!(call!(divi_ui64(0, 18446744073709551614)), 0);
-assert_eq!(call!(divi_ui64(0, 18446744073709551615)), 0);
-assert_eq!(call!(divi_ui64(1, 2)), 0);
-assert_eq!(call!(divi_ui64(1, 3)), 0);
-assert_eq!(call!(divi_ui64(1, 4)), 0);
-assert_eq!(call!(divi_ui64(1, 191084152064409600)), 0);
-assert_eq!(call!(divi_ui64(1, 11015955194427482112)), 0);
-assert_eq!(call!(divi_ui64(1, 16990600415051759616)), 0);
-assert_eq!(call!(divi_ui64(1, 18446744073709551614)), 0);
-assert_eq!(call!(divi_ui64(1, 18446744073709551615)), 0);
-assert_eq!(call!(divi_ui64(2, 3)), 0);
-assert_eq!(call!(divi_ui64(2, 4)), 0);
-assert_eq!(call!(divi_ui64(2, 191084152064409600)), 0);
-assert_eq!(call!(divi_ui64(2, 11015955194427482112)), 0);
-assert_eq!(call!(divi_ui64(2, 16990600415051759616)), 0);
-assert_eq!(call!(divi_ui64(2, 18446744073709551614)), 0);
-assert_eq!(call!(divi_ui64(2, 18446744073709551615)), 0);
-assert_eq!(call!(divi_ui64(3, 4)), 0);
-assert_eq!(call!(divi_ui64(3, 191084152064409600)), 0);
-assert_eq!(call!(divi_ui64(3, 11015955194427482112)), 0);
-assert_eq!(call!(divi_ui64(3, 16990600415051759616)), 0);
-assert_eq!(call!(divi_ui64(3, 18446744073709551614)), 0);
-assert_eq!(call!(divi_ui64(3, 18446744073709551615)), 0);
-assert_eq!(call!(divi_ui64(4, 191084152064409600)), 0);
-assert_eq!(call!(divi_ui64(4, 11015955194427482112)), 0);
-assert_eq!(call!(divi_ui64(4, 16990600415051759616)), 0);
-assert_eq!(call!(divi_ui64(4, 18446744073709551614)), 0);
-assert_eq!(call!(divi_ui64(4, 18446744073709551615)), 0);
-assert_eq!(call!(divi_ui64(191084152064409600, 11015955194427482112)), 0);
-assert_eq!(call!(divi_ui64(191084152064409600, 16990600415051759616)), 0);
-assert_eq!(call!(divi_ui64(191084152064409600, 18446744073709551614)), 0);
-assert_eq!(call!(divi_ui64(191084152064409600, 18446744073709551615)), 0);
-assert_eq!(call!(divi_ui64(11015955194427482112, 16990600415051759616)), 0);
-assert_eq!(call!(divi_ui64(11015955194427482112, 18446744073709551614)), 0);
-assert_eq!(call!(divi_ui64(11015955194427482112, 18446744073709551615)), 0);
-assert_eq!(call!(divi_ui64(16990600415051759616, 18446744073709551614)), 0);
-assert_eq!(call!(divi_ui64(16990600415051759616, 18446744073709551615)), 0);
-assert_eq!(call!(divi_ui64(18446744073709551614, 18446744073709551615)), 0);
-assert_eq!(call!(divi_ui64(1, 1)), 1);
-assert_eq!(call!(divi_ui64(2, 2)), 1);
-assert_eq!(call!(divi_ui64(3, 2)), 1);
-assert_eq!(call!(divi_ui64(3, 3)), 1);
-assert_eq!(call!(divi_ui64(4, 3)), 1);
-assert_eq!(call!(divi_ui64(4, 4)), 1);
-assert_eq!(call!(divi_ui64(191084152064409600, 191084152064409600)), 1);
-assert_eq!(call!(divi_ui64(11015955194427482112, 11015955194427482112)), 1);
-assert_eq!(call!(divi_ui64(16990600415051759616, 11015955194427482112)), 1);
-assert_eq!(call!(divi_ui64(16990600415051759616, 16990600415051759616)), 1);
-assert_eq!(call!(divi_ui64(18446744073709551614, 11015955194427482112)), 1);
-assert_eq!(call!(divi_ui64(18446744073709551614, 16990600415051759616)), 1);
-assert_eq!(call!(divi_ui64(18446744073709551614, 18446744073709551614)), 1);
-assert_eq!(call!(divi_ui64(18446744073709551615, 11015955194427482112)), 1);
-assert_eq!(call!(divi_ui64(18446744073709551615, 16990600415051759616)), 1);
-assert_eq!(call!(divi_ui64(18446744073709551615, 18446744073709551614)), 1);
-assert_eq!(call!(divi_ui64(18446744073709551615, 18446744073709551615)), 1);
-assert_eq!(call!(divi_ui64(2, 1)), 2);
-assert_eq!(call!(divi_ui64(4, 2)), 2);
-assert_eq!(call!(divi_ui64(3, 1)), 3);
-assert_eq!(call!(divi_ui64(4, 1)), 4);
-assert_eq!(call!(divi_ui64(11015955194427482112, 191084152064409600)), 57);
-assert_eq!(call!(divi_ui64(16990600415051759616, 191084152064409600)), 88);
-assert_eq!(call!(divi_ui64(18446744073709551614, 191084152064409600)), 96);
-assert_eq!(call!(divi_ui64(18446744073709551615, 191084152064409600)), 96);
-assert_eq!(call!(divi_ui64(191084152064409600, 4)), 47771038016102400);
-assert_eq!(call!(divi_ui64(191084152064409600, 3)), 63694717354803200);
-assert_eq!(call!(divi_ui64(191084152064409600, 2)), 95542076032204800);
-assert_eq!(call!(divi_ui64(191084152064409600, 1)), 191084152064409600);
-assert_eq!(call!(divi_ui64(11015955194427482112, 4)), 2753988798606870528);
-assert_eq!(call!(divi_ui64(11015955194427482112, 3)), 3671985064809160704);
-assert_eq!(call!(divi_ui64(16990600415051759616, 4)), 4247650103762939904);
-assert_eq!(call!(divi_ui64(18446744073709551614, 4)), 4611686018427387903);
-assert_eq!(call!(divi_ui64(18446744073709551615, 4)), 4611686018427387903);
-assert_eq!(call!(divi_ui64(11015955194427482112, 2)), 5507977597213741056);
-assert_eq!(call!(divi_ui64(16990600415051759616, 3)), 5663533471683919872);
-assert_eq!(call!(divi_ui64(18446744073709551614, 3)), 6148914691236517204);
-assert_eq!(call!(divi_ui64(18446744073709551615, 3)), 6148914691236517205);
-assert_eq!(call!(divi_ui64(16990600415051759616, 2)), 8495300207525879808);
-assert_eq!(call!(divi_ui64(18446744073709551614, 2)), 9223372036854775807);
-assert_eq!(call!(divi_ui64(18446744073709551615, 2)), 9223372036854775807);
-assert_eq!(call!(divi_ui64(11015955194427482112, 1)), 11015955194427482112);
-assert_eq!(call!(divi_ui64(16990600415051759616, 1)), 16990600415051759616);
-assert_eq!(call!(divi_ui64(18446744073709551614, 1)), 18446744073709551614);
-assert_eq!(call!(divi_ui64(18446744073709551615, 1)), 18446744073709551615);
-assert_eq!(call!(divi_ui8(0, 1)), 0);
-assert_eq!(call!(divi_ui8(0, 2)), 0);
-assert_eq!(call!(divi_ui8(0, 3)), 0);
-assert_eq!(call!(divi_ui8(0, 4)), 0);
-assert_eq!(call!(divi_ui8(0, 72)), 0);
-assert_eq!(call!(divi_ui8(0, 100)), 0);
-assert_eq!(call!(divi_ui8(0, 162)), 0);
-assert_eq!(call!(divi_ui8(0, 254)), 0);
-assert_eq!(call!(divi_ui8(0, 255)), 0);
-assert_eq!(call!(divi_ui8(1, 2)), 0);
-assert_eq!(call!(divi_ui8(1, 3)), 0);
-assert_eq!(call!(divi_ui8(1, 4)), 0);
-assert_eq!(call!(divi_ui8(1, 72)), 0);
-assert_eq!(call!(divi_ui8(1, 100)), 0);
-assert_eq!(call!(divi_ui8(1, 162)), 0);
-assert_eq!(call!(divi_ui8(1, 254)), 0);
-assert_eq!(call!(divi_ui8(1, 255)), 0);
-assert_eq!(call!(divi_ui8(2, 3)), 0);
-assert_eq!(call!(divi_ui8(2, 4)), 0);
-assert_eq!(call!(divi_ui8(2, 72)), 0);
-assert_eq!(call!(divi_ui8(2, 100)), 0);
-assert_eq!(call!(divi_ui8(2, 162)), 0);
-assert_eq!(call!(divi_ui8(2, 254)), 0);
-assert_eq!(call!(divi_ui8(2, 255)), 0);
-assert_eq!(call!(divi_ui8(3, 4)), 0);
-assert_eq!(call!(divi_ui8(3, 72)), 0);
-assert_eq!(call!(divi_ui8(3, 100)), 0);
-assert_eq!(call!(divi_ui8(3, 162)), 0);
-assert_eq!(call!(divi_ui8(3, 254)), 0);
-assert_eq!(call!(divi_ui8(3, 255)), 0);
-assert_eq!(call!(divi_ui8(4, 72)), 0);
-assert_eq!(call!(divi_ui8(4, 100)), 0);
-assert_eq!(call!(divi_ui8(4, 162)), 0);
-assert_eq!(call!(divi_ui8(4, 254)), 0);
-assert_eq!(call!(divi_ui8(4, 255)), 0);
-assert_eq!(call!(divi_ui8(72, 100)), 0);
-assert_eq!(call!(divi_ui8(72, 162)), 0);
-assert_eq!(call!(divi_ui8(72, 254)), 0);
-assert_eq!(call!(divi_ui8(72, 255)), 0);
-assert_eq!(call!(divi_ui8(100, 162)), 0);
-assert_eq!(call!(divi_ui8(100, 254)), 0);
-assert_eq!(call!(divi_ui8(100, 255)), 0);
-assert_eq!(call!(divi_ui8(162, 254)), 0);
-assert_eq!(call!(divi_ui8(162, 255)), 0);
-assert_eq!(call!(divi_ui8(254, 255)), 0);
-assert_eq!(call!(divi_ui8(1, 1)), 1);
-assert_eq!(call!(divi_ui8(2, 2)), 1);
-assert_eq!(call!(divi_ui8(3, 2)), 1);
-assert_eq!(call!(divi_ui8(3, 3)), 1);
-assert_eq!(call!(divi_ui8(4, 3)), 1);
-assert_eq!(call!(divi_ui8(4, 4)), 1);
-assert_eq!(call!(divi_ui8(72, 72)), 1);
-assert_eq!(call!(divi_ui8(100, 72)), 1);
-assert_eq!(call!(divi_ui8(100, 100)), 1);
-assert_eq!(call!(divi_ui8(162, 100)), 1);
-assert_eq!(call!(divi_ui8(162, 162)), 1);
-assert_eq!(call!(divi_ui8(254, 162)), 1);
-assert_eq!(call!(divi_ui8(254, 254)), 1);
-assert_eq!(call!(divi_ui8(255, 162)), 1);
-assert_eq!(call!(divi_ui8(255, 254)), 1);
-assert_eq!(call!(divi_ui8(255, 255)), 1);
-assert_eq!(call!(divi_ui8(2, 1)), 2);
-assert_eq!(call!(divi_ui8(4, 2)), 2);
-assert_eq!(call!(divi_ui8(162, 72)), 2);
-assert_eq!(call!(divi_ui8(254, 100)), 2);
-assert_eq!(call!(divi_ui8(255, 100)), 2);
-assert_eq!(call!(divi_ui8(3, 1)), 3);
-assert_eq!(call!(divi_ui8(254, 72)), 3);
-assert_eq!(call!(divi_ui8(255, 72)), 3);
-assert_eq!(call!(divi_ui8(4, 1)), 4);
-assert_eq!(call!(divi_ui8(72, 4)), 18);
-assert_eq!(call!(divi_ui8(72, 3)), 24);
-assert_eq!(call!(divi_ui8(100, 4)), 25);
-assert_eq!(call!(divi_ui8(100, 3)), 33);
-assert_eq!(call!(divi_ui8(72, 2)), 36);
-assert_eq!(call!(divi_ui8(162, 4)), 40);
-assert_eq!(call!(divi_ui8(100, 2)), 50);
-assert_eq!(call!(divi_ui8(162, 3)), 54);
-assert_eq!(call!(divi_ui8(254, 4)), 63);
-assert_eq!(call!(divi_ui8(255, 4)), 63);
-assert_eq!(call!(divi_ui8(72, 1)), 72);
-assert_eq!(call!(divi_ui8(162, 2)), 81);
-assert_eq!(call!(divi_ui8(254, 3)), 84);
-assert_eq!(call!(divi_ui8(255, 3)), 85);
-assert_eq!(call!(divi_ui8(100, 1)), 100);
-assert_eq!(call!(divi_ui8(254, 2)), 127);
-assert_eq!(call!(divi_ui8(255, 2)), 127);
-assert_eq!(call!(divi_ui8(162, 1)), 162);
-assert_eq!(call!(divi_ui8(254, 1)), 254);
-assert_eq!(call!(divi_ui8(255, 1)), 255);
-assert_eq!(call!(muli_si16(-32768, 1)), -32768);
-assert_eq!(call!(muli_si16(1, -32768)), -32768);
-assert_eq!(call!(muli_si16(-32767, 1)), -32767);
-assert_eq!(call!(muli_si16(1, -32767)), -32767);
-assert_eq!(call!(muli_si16(-32547, 1)), -32547);
-assert_eq!(call!(muli_si16(1, -32547)), -32547);
-assert_eq!(call!(muli_si16(-32768, 0)), 0);
-assert_eq!(call!(muli_si16(-32767, 0)), 0);
-assert_eq!(call!(muli_si16(-32547, 0)), 0);
-assert_eq!(call!(muli_si16(0, -32768)), 0);
-assert_eq!(call!(muli_si16(0, -32767)), 0);
-assert_eq!(call!(muli_si16(0, -32547)), 0);
-assert_eq!(call!(muli_si16(0, 0)), 0);
-assert_eq!(call!(muli_si16(0, 1)), 0);
-assert_eq!(call!(muli_si16(0, 2)), 0);
-assert_eq!(call!(muli_si16(0, 3)), 0);
-assert_eq!(call!(muli_si16(0, 4)), 0);
-assert_eq!(call!(muli_si16(0, 10486)), 0);
-assert_eq!(call!(muli_si16(0, 16514)), 0);
-assert_eq!(call!(muli_si16(0, 32766)), 0);
-assert_eq!(call!(muli_si16(0, 32767)), 0);
-assert_eq!(call!(muli_si16(1, 0)), 0);
-assert_eq!(call!(muli_si16(2, 0)), 0);
-assert_eq!(call!(muli_si16(3, 0)), 0);
-assert_eq!(call!(muli_si16(4, 0)), 0);
-assert_eq!(call!(muli_si16(10486, 0)), 0);
-assert_eq!(call!(muli_si16(16514, 0)), 0);
-assert_eq!(call!(muli_si16(32766, 0)), 0);
-assert_eq!(call!(muli_si16(32767, 0)), 0);
-assert_eq!(call!(muli_si16(1, 1)), 1);
-assert_eq!(call!(muli_si16(1, 2)), 2);
-assert_eq!(call!(muli_si16(2, 1)), 2);
-assert_eq!(call!(muli_si16(1, 3)), 3);
-assert_eq!(call!(muli_si16(3, 1)), 3);
-assert_eq!(call!(muli_si16(1, 4)), 4);
-assert_eq!(call!(muli_si16(2, 2)), 4);
-assert_eq!(call!(muli_si16(4, 1)), 4);
-assert_eq!(call!(muli_si16(2, 3)), 6);
-assert_eq!(call!(muli_si16(3, 2)), 6);
-assert_eq!(call!(muli_si16(2, 4)), 8);
-assert_eq!(call!(muli_si16(4, 2)), 8);
-assert_eq!(call!(muli_si16(3, 3)), 9);
-assert_eq!(call!(muli_si16(3, 4)), 12);
-assert_eq!(call!(muli_si16(4, 3)), 12);
-assert_eq!(call!(muli_si16(4, 4)), 16);
-assert_eq!(call!(muli_si16(1, 10486)), 10486);
-assert_eq!(call!(muli_si16(10486, 1)), 10486);
-assert_eq!(call!(muli_si16(1, 16514)), 16514);
-assert_eq!(call!(muli_si16(16514, 1)), 16514);
-assert_eq!(call!(muli_si16(2, 10486)), 20972);
-assert_eq!(call!(muli_si16(10486, 2)), 20972);
-assert_eq!(call!(muli_si16(3, 10486)), 31458);
-assert_eq!(call!(muli_si16(10486, 3)), 31458);
-assert_eq!(call!(muli_si16(1, 32766)), 32766);
-assert_eq!(call!(muli_si16(32766, 1)), 32766);
-assert_eq!(call!(muli_si16(1, 32767)), 32767);
-assert_eq!(call!(muli_si16(32767, 1)), 32767);
-assert_eq!(call!(muli_si32(-2147483648, 1)), -2147483648);
-assert_eq!(call!(muli_si32(1, -2147483648)), -2147483648);
-assert_eq!(call!(muli_si32(-2147483647, 1)), -2147483647);
-assert_eq!(call!(muli_si32(1, -2147483647)), -2147483647);
-assert_eq!(call!(muli_si32(-1035405763, 2)), -2070811526);
-assert_eq!(call!(muli_si32(2, -1035405763)), -2070811526);
-assert_eq!(call!(muli_si32(-1713183800, 1)), -1713183800);
-assert_eq!(call!(muli_si32(1, -1713183800)), -1713183800);
-assert_eq!(call!(muli_si32(-1252582164, 1)), -1252582164);
-assert_eq!(call!(muli_si32(1, -1252582164)), -1252582164);
-assert_eq!(call!(muli_si32(-1035405763, 1)), -1035405763);
-assert_eq!(call!(muli_si32(1, -1035405763)), -1035405763);
-assert_eq!(call!(muli_si32(-2147483648, 0)), 0);
-assert_eq!(call!(muli_si32(-2147483647, 0)), 0);
-assert_eq!(call!(muli_si32(-1713183800, 0)), 0);
-assert_eq!(call!(muli_si32(-1252582164, 0)), 0);
-assert_eq!(call!(muli_si32(-1035405763, 0)), 0);
-assert_eq!(call!(muli_si32(0, -2147483648)), 0);
-assert_eq!(call!(muli_si32(0, -2147483647)), 0);
-assert_eq!(call!(muli_si32(0, -1713183800)), 0);
-assert_eq!(call!(muli_si32(0, -1252582164)), 0);
-assert_eq!(call!(muli_si32(0, -1035405763)), 0);
-assert_eq!(call!(muli_si32(0, 0)), 0);
-assert_eq!(call!(muli_si32(0, 1)), 0);
-assert_eq!(call!(muli_si32(0, 2)), 0);
-assert_eq!(call!(muli_si32(0, 3)), 0);
-assert_eq!(call!(muli_si32(0, 4)), 0);
-assert_eq!(call!(muli_si32(0, 2147483646)), 0);
-assert_eq!(call!(muli_si32(0, 2147483647)), 0);
-assert_eq!(call!(muli_si32(1, 0)), 0);
-assert_eq!(call!(muli_si32(2, 0)), 0);
-assert_eq!(call!(muli_si32(3, 0)), 0);
-assert_eq!(call!(muli_si32(4, 0)), 0);
-assert_eq!(call!(muli_si32(2147483646, 0)), 0);
-assert_eq!(call!(muli_si32(2147483647, 0)), 0);
-assert_eq!(call!(muli_si32(1, 1)), 1);
-assert_eq!(call!(muli_si32(1, 2)), 2);
-assert_eq!(call!(muli_si32(2, 1)), 2);
-assert_eq!(call!(muli_si32(1, 3)), 3);
-assert_eq!(call!(muli_si32(3, 1)), 3);
-assert_eq!(call!(muli_si32(1, 4)), 4);
-assert_eq!(call!(muli_si32(2, 2)), 4);
-assert_eq!(call!(muli_si32(4, 1)), 4);
-assert_eq!(call!(muli_si32(2, 3)), 6);
-assert_eq!(call!(muli_si32(3, 2)), 6);
-assert_eq!(call!(muli_si32(2, 4)), 8);
-assert_eq!(call!(muli_si32(4, 2)), 8);
-assert_eq!(call!(muli_si32(3, 3)), 9);
-assert_eq!(call!(muli_si32(3, 4)), 12);
-assert_eq!(call!(muli_si32(4, 3)), 12);
-assert_eq!(call!(muli_si32(4, 4)), 16);
-assert_eq!(call!(muli_si32(1, 2147483646)), 2147483646);
-assert_eq!(call!(muli_si32(2147483646, 1)), 2147483646);
-assert_eq!(call!(muli_si32(1, 2147483647)), 2147483647);
-assert_eq!(call!(muli_si32(2147483647, 1)), 2147483647);
-assert_eq!(call!(muli_si64(-9223372036854775808, 1)), -9223372036854775808);
-assert_eq!(call!(muli_si64(1, -9223372036854775808)), -9223372036854775808);
-assert_eq!(call!(muli_si64(-9223372036854775807, 1)), -9223372036854775807);
-assert_eq!(call!(muli_si64(1, -9223372036854775807)), -9223372036854775807);
-assert_eq!(call!(muli_si64(-1741927215160008704, 4)), -6967708860640034816);
-assert_eq!(call!(muli_si64(4, -1741927215160008704)), -6967708860640034816);
-assert_eq!(call!(muli_si64(-1328271339354574848, 4)), -5313085357418299392);
-assert_eq!(call!(muli_si64(4, -1328271339354574848)), -5313085357418299392);
-assert_eq!(call!(muli_si64(-1741927215160008704, 3)), -5225781645480026112);
-assert_eq!(call!(muli_si64(3, -1741927215160008704)), -5225781645480026112);
-assert_eq!(call!(muli_si64(-1328271339354574848, 3)), -3984814018063724544);
-assert_eq!(call!(muli_si64(3, -1328271339354574848)), -3984814018063724544);
-assert_eq!(call!(muli_si64(-1741927215160008704, 2)), -3483854430320017408);
-assert_eq!(call!(muli_si64(2, -1741927215160008704)), -3483854430320017408);
-assert_eq!(call!(muli_si64(-1328271339354574848, 2)), -2656542678709149696);
-assert_eq!(call!(muli_si64(2, -1328271339354574848)), -2656542678709149696);
-assert_eq!(call!(muli_si64(-1741927215160008704, 1)), -1741927215160008704);
-assert_eq!(call!(muli_si64(1, -1741927215160008704)), -1741927215160008704);
-assert_eq!(call!(muli_si64(-1328271339354574848, 1)), -1328271339354574848);
-assert_eq!(call!(muli_si64(1, -1328271339354574848)), -1328271339354574848);
-assert_eq!(call!(muli_si64(-9223372036854775808, 0)), 0);
-assert_eq!(call!(muli_si64(-9223372036854775807, 0)), 0);
-assert_eq!(call!(muli_si64(-1741927215160008704, 0)), 0);
-assert_eq!(call!(muli_si64(-1328271339354574848, 0)), 0);
-assert_eq!(call!(muli_si64(0, -9223372036854775808)), 0);
-assert_eq!(call!(muli_si64(0, -9223372036854775807)), 0);
-assert_eq!(call!(muli_si64(0, -1741927215160008704)), 0);
-assert_eq!(call!(muli_si64(0, -1328271339354574848)), 0);
-assert_eq!(call!(muli_si64(0, 0)), 0);
-assert_eq!(call!(muli_si64(0, 1)), 0);
-assert_eq!(call!(muli_si64(0, 2)), 0);
-assert_eq!(call!(muli_si64(0, 3)), 0);
-assert_eq!(call!(muli_si64(0, 4)), 0);
-assert_eq!(call!(muli_si64(0, 5577148965131116544)), 0);
-assert_eq!(call!(muli_si64(0, 9223372036854775806)), 0);
-assert_eq!(call!(muli_si64(0, 9223372036854775807)), 0);
-assert_eq!(call!(muli_si64(1, 0)), 0);
-assert_eq!(call!(muli_si64(2, 0)), 0);
-assert_eq!(call!(muli_si64(3, 0)), 0);
-assert_eq!(call!(muli_si64(4, 0)), 0);
-assert_eq!(call!(muli_si64(5577148965131116544, 0)), 0);
-assert_eq!(call!(muli_si64(9223372036854775806, 0)), 0);
-assert_eq!(call!(muli_si64(9223372036854775807, 0)), 0);
-assert_eq!(call!(muli_si64(1, 1)), 1);
-assert_eq!(call!(muli_si64(1, 2)), 2);
-assert_eq!(call!(muli_si64(2, 1)), 2);
-assert_eq!(call!(muli_si64(1, 3)), 3);
-assert_eq!(call!(muli_si64(3, 1)), 3);
-assert_eq!(call!(muli_si64(1, 4)), 4);
-assert_eq!(call!(muli_si64(2, 2)), 4);
-assert_eq!(call!(muli_si64(4, 1)), 4);
-assert_eq!(call!(muli_si64(2, 3)), 6);
-assert_eq!(call!(muli_si64(3, 2)), 6);
-assert_eq!(call!(muli_si64(2, 4)), 8);
-assert_eq!(call!(muli_si64(4, 2)), 8);
-assert_eq!(call!(muli_si64(3, 3)), 9);
-assert_eq!(call!(muli_si64(3, 4)), 12);
-assert_eq!(call!(muli_si64(4, 3)), 12);
-assert_eq!(call!(muli_si64(4, 4)), 16);
-assert_eq!(call!(muli_si64(1, 5577148965131116544)), 5577148965131116544);
-assert_eq!(call!(muli_si64(5577148965131116544, 1)), 5577148965131116544);
-assert_eq!(call!(muli_si64(1, 9223372036854775806)), 9223372036854775806);
-assert_eq!(call!(muli_si64(9223372036854775806, 1)), 9223372036854775806);
-assert_eq!(call!(muli_si64(1, 9223372036854775807)), 9223372036854775807);
-assert_eq!(call!(muli_si64(9223372036854775807, 1)), 9223372036854775807);
-assert_eq!(call!(muli_si8(-128, 1)), -128);
-assert_eq!(call!(muli_si8(1, -128)), -128);
-assert_eq!(call!(muli_si8(-127, 1)), -127);
-assert_eq!(call!(muli_si8(1, -127)), -127);
-assert_eq!(call!(muli_si8(-128, 0)), 0);
-assert_eq!(call!(muli_si8(-127, 0)), 0);
-assert_eq!(call!(muli_si8(0, -128)), 0);
-assert_eq!(call!(muli_si8(0, -127)), 0);
-assert_eq!(call!(muli_si8(0, 0)), 0);
-assert_eq!(call!(muli_si8(0, 1)), 0);
-assert_eq!(call!(muli_si8(0, 2)), 0);
-assert_eq!(call!(muli_si8(0, 3)), 0);
-assert_eq!(call!(muli_si8(0, 4)), 0);
-assert_eq!(call!(muli_si8(0, 16)), 0);
-assert_eq!(call!(muli_si8(0, 126)), 0);
-assert_eq!(call!(muli_si8(0, 127)), 0);
-assert_eq!(call!(muli_si8(1, 0)), 0);
-assert_eq!(call!(muli_si8(2, 0)), 0);
-assert_eq!(call!(muli_si8(3, 0)), 0);
-assert_eq!(call!(muli_si8(4, 0)), 0);
-assert_eq!(call!(muli_si8(16, 0)), 0);
-assert_eq!(call!(muli_si8(126, 0)), 0);
-assert_eq!(call!(muli_si8(127, 0)), 0);
-assert_eq!(call!(muli_si8(1, 1)), 1);
-assert_eq!(call!(muli_si8(1, 2)), 2);
-assert_eq!(call!(muli_si8(2, 1)), 2);
-assert_eq!(call!(muli_si8(1, 3)), 3);
-assert_eq!(call!(muli_si8(3, 1)), 3);
-assert_eq!(call!(muli_si8(1, 4)), 4);
-assert_eq!(call!(muli_si8(2, 2)), 4);
-assert_eq!(call!(muli_si8(4, 1)), 4);
-assert_eq!(call!(muli_si8(2, 3)), 6);
-assert_eq!(call!(muli_si8(3, 2)), 6);
-assert_eq!(call!(muli_si8(2, 4)), 8);
-assert_eq!(call!(muli_si8(4, 2)), 8);
-assert_eq!(call!(muli_si8(3, 3)), 9);
-assert_eq!(call!(muli_si8(3, 4)), 12);
-assert_eq!(call!(muli_si8(4, 3)), 12);
-assert_eq!(call!(muli_si8(1, 16)), 16);
-assert_eq!(call!(muli_si8(4, 4)), 16);
-assert_eq!(call!(muli_si8(16, 1)), 16);
-assert_eq!(call!(muli_si8(2, 16)), 32);
-assert_eq!(call!(muli_si8(16, 2)), 32);
-assert_eq!(call!(muli_si8(3, 16)), 48);
-assert_eq!(call!(muli_si8(16, 3)), 48);
-assert_eq!(call!(muli_si8(4, 16)), 64);
-assert_eq!(call!(muli_si8(16, 4)), 64);
-assert_eq!(call!(muli_si8(1, 126)), 126);
-assert_eq!(call!(muli_si8(126, 1)), 126);
-assert_eq!(call!(muli_si8(1, 127)), 127);
-assert_eq!(call!(muli_si8(127, 1)), 127);
-assert_eq!(call!(muli_ui16(0, 0)), 0);
-assert_eq!(call!(muli_ui16(0, 1)), 0);
-assert_eq!(call!(muli_ui16(0, 2)), 0);
-assert_eq!(call!(muli_ui16(0, 3)), 0);
-assert_eq!(call!(muli_ui16(0, 4)), 0);
-assert_eq!(call!(muli_ui16(0, 1717)), 0);
-assert_eq!(call!(muli_ui16(0, 17988)), 0);
-assert_eq!(call!(muli_ui16(0, 65096)), 0);
-assert_eq!(call!(muli_ui16(0, 65534)), 0);
-assert_eq!(call!(muli_ui16(0, 65535)), 0);
-assert_eq!(call!(muli_ui16(1, 0)), 0);
-assert_eq!(call!(muli_ui16(2, 0)), 0);
-assert_eq!(call!(muli_ui16(3, 0)), 0);
-assert_eq!(call!(muli_ui16(4, 0)), 0);
-assert_eq!(call!(muli_ui16(1717, 0)), 0);
-assert_eq!(call!(muli_ui16(17988, 0)), 0);
-assert_eq!(call!(muli_ui16(65096, 0)), 0);
-assert_eq!(call!(muli_ui16(65534, 0)), 0);
-assert_eq!(call!(muli_ui16(65535, 0)), 0);
-assert_eq!(call!(muli_ui16(1, 1)), 1);
-assert_eq!(call!(muli_ui16(1, 2)), 2);
-assert_eq!(call!(muli_ui16(2, 1)), 2);
-assert_eq!(call!(muli_ui16(1, 3)), 3);
-assert_eq!(call!(muli_ui16(3, 1)), 3);
-assert_eq!(call!(muli_ui16(1, 4)), 4);
-assert_eq!(call!(muli_ui16(2, 2)), 4);
-assert_eq!(call!(muli_ui16(4, 1)), 4);
-assert_eq!(call!(muli_ui16(2, 3)), 6);
-assert_eq!(call!(muli_ui16(3, 2)), 6);
-assert_eq!(call!(muli_ui16(2, 4)), 8);
-assert_eq!(call!(muli_ui16(4, 2)), 8);
-assert_eq!(call!(muli_ui16(3, 3)), 9);
-assert_eq!(call!(muli_ui16(3, 4)), 12);
-assert_eq!(call!(muli_ui16(4, 3)), 12);
-assert_eq!(call!(muli_ui16(4, 4)), 16);
-assert_eq!(call!(muli_ui16(1, 1717)), 1717);
-assert_eq!(call!(muli_ui16(1717, 1)), 1717);
-assert_eq!(call!(muli_ui16(2, 1717)), 3434);
-assert_eq!(call!(muli_ui16(1717, 2)), 3434);
-assert_eq!(call!(muli_ui16(3, 1717)), 5151);
-assert_eq!(call!(muli_ui16(1717, 3)), 5151);
-assert_eq!(call!(muli_ui16(4, 1717)), 6868);
-assert_eq!(call!(muli_ui16(1717, 4)), 6868);
-assert_eq!(call!(muli_ui16(1, 17988)), 17988);
-assert_eq!(call!(muli_ui16(17988, 1)), 17988);
-assert_eq!(call!(muli_ui16(2, 17988)), 35976);
-assert_eq!(call!(muli_ui16(17988, 2)), 35976);
-assert_eq!(call!(muli_ui16(3, 17988)), 53964);
-assert_eq!(call!(muli_ui16(17988, 3)), 53964);
-assert_eq!(call!(muli_ui16(1, 65096)), 65096);
-assert_eq!(call!(muli_ui16(65096, 1)), 65096);
-assert_eq!(call!(muli_ui16(1, 65534)), 65534);
-assert_eq!(call!(muli_ui16(65534, 1)), 65534);
-assert_eq!(call!(muli_ui16(1, 65535)), 65535);
-assert_eq!(call!(muli_ui16(65535, 1)), 65535);
-assert_eq!(call!(muli_ui32(0, 0)), 0);
-assert_eq!(call!(muli_ui32(0, 1)), 0);
-assert_eq!(call!(muli_ui32(0, 2)), 0);
-assert_eq!(call!(muli_ui32(0, 3)), 0);
-assert_eq!(call!(muli_ui32(0, 4)), 0);
-assert_eq!(call!(muli_ui32(0, 2119154652)), 0);
-assert_eq!(call!(muli_ui32(0, 3002788344)), 0);
-assert_eq!(call!(muli_ui32(0, 3482297128)), 0);
-assert_eq!(call!(muli_ui32(0, 4294967294)), 0);
-assert_eq!(call!(muli_ui32(0, 4294967295)), 0);
-assert_eq!(call!(muli_ui32(1, 0)), 0);
-assert_eq!(call!(muli_ui32(2, 0)), 0);
-assert_eq!(call!(muli_ui32(3, 0)), 0);
-assert_eq!(call!(muli_ui32(4, 0)), 0);
-assert_eq!(call!(muli_ui32(2119154652, 0)), 0);
-assert_eq!(call!(muli_ui32(3002788344, 0)), 0);
-assert_eq!(call!(muli_ui32(3482297128, 0)), 0);
-assert_eq!(call!(muli_ui32(4294967294, 0)), 0);
-assert_eq!(call!(muli_ui32(4294967295, 0)), 0);
-assert_eq!(call!(muli_ui32(1, 1)), 1);
-assert_eq!(call!(muli_ui32(1, 2)), 2);
-assert_eq!(call!(muli_ui32(2, 1)), 2);
-assert_eq!(call!(muli_ui32(1, 3)), 3);
-assert_eq!(call!(muli_ui32(3, 1)), 3);
-assert_eq!(call!(muli_ui32(1, 4)), 4);
-assert_eq!(call!(muli_ui32(2, 2)), 4);
-assert_eq!(call!(muli_ui32(4, 1)), 4);
-assert_eq!(call!(muli_ui32(2, 3)), 6);
-assert_eq!(call!(muli_ui32(3, 2)), 6);
-assert_eq!(call!(muli_ui32(2, 4)), 8);
-assert_eq!(call!(muli_ui32(4, 2)), 8);
-assert_eq!(call!(muli_ui32(3, 3)), 9);
-assert_eq!(call!(muli_ui32(3, 4)), 12);
-assert_eq!(call!(muli_ui32(4, 3)), 12);
-assert_eq!(call!(muli_ui32(4, 4)), 16);
-assert_eq!(call!(muli_ui32(1, 2119154652)), 2119154652);
-assert_eq!(call!(muli_ui32(2119154652, 1)), 2119154652);
-assert_eq!(call!(muli_ui32(1, 3002788344)), 3002788344);
-assert_eq!(call!(muli_ui32(3002788344, 1)), 3002788344);
-assert_eq!(call!(muli_ui32(1, 3482297128)), 3482297128);
-assert_eq!(call!(muli_ui32(3482297128, 1)), 3482297128);
-assert_eq!(call!(muli_ui32(2, 2119154652)), 4238309304);
-assert_eq!(call!(muli_ui32(2119154652, 2)), 4238309304);
-assert_eq!(call!(muli_ui32(1, 4294967294)), 4294967294);
-assert_eq!(call!(muli_ui32(4294967294, 1)), 4294967294);
-assert_eq!(call!(muli_ui32(1, 4294967295)), 4294967295);
-assert_eq!(call!(muli_ui32(4294967295, 1)), 4294967295);
-assert_eq!(call!(muli_ui64(0, 0)), 0);
-assert_eq!(call!(muli_ui64(0, 1)), 0);
-assert_eq!(call!(muli_ui64(0, 2)), 0);
-assert_eq!(call!(muli_ui64(0, 3)), 0);
-assert_eq!(call!(muli_ui64(0, 4)), 0);
-assert_eq!(call!(muli_ui64(0, 191084152064409600)), 0);
-assert_eq!(call!(muli_ui64(0, 11015955194427482112)), 0);
-assert_eq!(call!(muli_ui64(0, 16990600415051759616)), 0);
-assert_eq!(call!(muli_ui64(0, 18446744073709551614)), 0);
-assert_eq!(call!(muli_ui64(0, 18446744073709551615)), 0);
-assert_eq!(call!(muli_ui64(1, 0)), 0);
-assert_eq!(call!(muli_ui64(2, 0)), 0);
-assert_eq!(call!(muli_ui64(3, 0)), 0);
-assert_eq!(call!(muli_ui64(4, 0)), 0);
-assert_eq!(call!(muli_ui64(191084152064409600, 0)), 0);
-assert_eq!(call!(muli_ui64(11015955194427482112, 0)), 0);
-assert_eq!(call!(muli_ui64(16990600415051759616, 0)), 0);
-assert_eq!(call!(muli_ui64(18446744073709551614, 0)), 0);
-assert_eq!(call!(muli_ui64(18446744073709551615, 0)), 0);
-assert_eq!(call!(muli_ui64(1, 1)), 1);
-assert_eq!(call!(muli_ui64(1, 2)), 2);
-assert_eq!(call!(muli_ui64(2, 1)), 2);
-assert_eq!(call!(muli_ui64(1, 3)), 3);
-assert_eq!(call!(muli_ui64(3, 1)), 3);
-assert_eq!(call!(muli_ui64(1, 4)), 4);
-assert_eq!(call!(muli_ui64(2, 2)), 4);
-assert_eq!(call!(muli_ui64(4, 1)), 4);
-assert_eq!(call!(muli_ui64(2, 3)), 6);
-assert_eq!(call!(muli_ui64(3, 2)), 6);
-assert_eq!(call!(muli_ui64(2, 4)), 8);
-assert_eq!(call!(muli_ui64(4, 2)), 8);
-assert_eq!(call!(muli_ui64(3, 3)), 9);
-assert_eq!(call!(muli_ui64(3, 4)), 12);
-assert_eq!(call!(muli_ui64(4, 3)), 12);
-assert_eq!(call!(muli_ui64(4, 4)), 16);
-assert_eq!(call!(muli_ui64(1, 191084152064409600)), 191084152064409600);
-assert_eq!(call!(muli_ui64(191084152064409600, 1)), 191084152064409600);
-assert_eq!(call!(muli_ui64(2, 191084152064409600)), 382168304128819200);
-assert_eq!(call!(muli_ui64(191084152064409600, 2)), 382168304128819200);
-assert_eq!(call!(muli_ui64(3, 191084152064409600)), 573252456193228800);
-assert_eq!(call!(muli_ui64(191084152064409600, 3)), 573252456193228800);
-assert_eq!(call!(muli_ui64(4, 191084152064409600)), 764336608257638400);
-assert_eq!(call!(muli_ui64(191084152064409600, 4)), 764336608257638400);
-assert_eq!(call!(muli_ui64(1, 11015955194427482112)), 11015955194427482112);
-assert_eq!(call!(muli_ui64(11015955194427482112, 1)), 11015955194427482112);
-assert_eq!(call!(muli_ui64(1, 16990600415051759616)), 16990600415051759616);
-assert_eq!(call!(muli_ui64(16990600415051759616, 1)), 16990600415051759616);
-assert_eq!(call!(muli_ui64(1, 18446744073709551614)), 18446744073709551614);
-assert_eq!(call!(muli_ui64(18446744073709551614, 1)), 18446744073709551614);
-assert_eq!(call!(muli_ui64(1, 18446744073709551615)), 18446744073709551615);
-assert_eq!(call!(muli_ui64(18446744073709551615, 1)), 18446744073709551615);
-assert_eq!(call!(muli_ui8(0, 0)), 0);
-assert_eq!(call!(muli_ui8(0, 1)), 0);
-assert_eq!(call!(muli_ui8(0, 2)), 0);
-assert_eq!(call!(muli_ui8(0, 3)), 0);
-assert_eq!(call!(muli_ui8(0, 4)), 0);
-assert_eq!(call!(muli_ui8(0, 72)), 0);
-assert_eq!(call!(muli_ui8(0, 100)), 0);
-assert_eq!(call!(muli_ui8(0, 162)), 0);
-assert_eq!(call!(muli_ui8(0, 254)), 0);
-assert_eq!(call!(muli_ui8(0, 255)), 0);
-assert_eq!(call!(muli_ui8(1, 0)), 0);
-assert_eq!(call!(muli_ui8(2, 0)), 0);
-assert_eq!(call!(muli_ui8(3, 0)), 0);
-assert_eq!(call!(muli_ui8(4, 0)), 0);
-assert_eq!(call!(muli_ui8(72, 0)), 0);
-assert_eq!(call!(muli_ui8(100, 0)), 0);
-assert_eq!(call!(muli_ui8(162, 0)), 0);
-assert_eq!(call!(muli_ui8(254, 0)), 0);
-assert_eq!(call!(muli_ui8(255, 0)), 0);
-assert_eq!(call!(muli_ui8(1, 1)), 1);
-assert_eq!(call!(muli_ui8(1, 2)), 2);
-assert_eq!(call!(muli_ui8(2, 1)), 2);
-assert_eq!(call!(muli_ui8(1, 3)), 3);
-assert_eq!(call!(muli_ui8(3, 1)), 3);
-assert_eq!(call!(muli_ui8(1, 4)), 4);
-assert_eq!(call!(muli_ui8(2, 2)), 4);
-assert_eq!(call!(muli_ui8(4, 1)), 4);
-assert_eq!(call!(muli_ui8(2, 3)), 6);
-assert_eq!(call!(muli_ui8(3, 2)), 6);
-assert_eq!(call!(muli_ui8(2, 4)), 8);
-assert_eq!(call!(muli_ui8(4, 2)), 8);
-assert_eq!(call!(muli_ui8(3, 3)), 9);
-assert_eq!(call!(muli_ui8(3, 4)), 12);
-assert_eq!(call!(muli_ui8(4, 3)), 12);
-assert_eq!(call!(muli_ui8(4, 4)), 16);
-assert_eq!(call!(muli_ui8(1, 72)), 72);
-assert_eq!(call!(muli_ui8(72, 1)), 72);
-assert_eq!(call!(muli_ui8(1, 100)), 100);
-assert_eq!(call!(muli_ui8(100, 1)), 100);
-assert_eq!(call!(muli_ui8(2, 72)), 144);
-assert_eq!(call!(muli_ui8(72, 2)), 144);
-assert_eq!(call!(muli_ui8(1, 162)), 162);
-assert_eq!(call!(muli_ui8(162, 1)), 162);
-assert_eq!(call!(muli_ui8(2, 100)), 200);
-assert_eq!(call!(muli_ui8(100, 2)), 200);
-assert_eq!(call!(muli_ui8(3, 72)), 216);
-assert_eq!(call!(muli_ui8(72, 3)), 216);
-assert_eq!(call!(muli_ui8(1, 254)), 254);
-assert_eq!(call!(muli_ui8(254, 1)), 254);
-assert_eq!(call!(muli_ui8(1, 255)), 255);
-assert_eq!(call!(muli_ui8(255, 1)), 255);
-assert_eq!(call!(remi_si16(-32767, -32768)), -32767);
-assert_eq!(call!(remi_si16(-32547, -32768)), -32547);
-assert_eq!(call!(remi_si16(-32547, -32767)), -32547);
-assert_eq!(call!(remi_si16(-32547, 32766)), -32547);
-assert_eq!(call!(remi_si16(-32547, 32767)), -32547);
-assert_eq!(call!(remi_si16(-32768, 16514)), -16254);
-assert_eq!(call!(remi_si16(-32767, 16514)), -16253);
-assert_eq!(call!(remi_si16(-32547, 16514)), -16033);
-assert_eq!(call!(remi_si16(-32768, 10486)), -1310);
-assert_eq!(call!(remi_si16(-32767, 10486)), -1309);
-assert_eq!(call!(remi_si16(-32547, 10486)), -1089);
-assert_eq!(call!(remi_si16(-32768, -32547)), -221);
-assert_eq!(call!(remi_si16(-32767, -32547)), -220);
-assert_eq!(call!(remi_si16(-32767, 4)), -3);
-assert_eq!(call!(remi_si16(-32547, 4)), -3);
-assert_eq!(call!(remi_si16(-32768, 3)), -2);
-assert_eq!(call!(remi_si16(-32768, 32766)), -2);
-assert_eq!(call!(remi_si16(-32768, -32767)), -1);
-assert_eq!(call!(remi_si16(-32768, 32767)), -1);
-assert_eq!(call!(remi_si16(-32767, 2)), -1);
-assert_eq!(call!(remi_si16(-32767, 3)), -1);
-assert_eq!(call!(remi_si16(-32767, 32766)), -1);
-assert_eq!(call!(remi_si16(-32547, 2)), -1);
-assert_eq!(call!(remi_si16(-32768, -32768)), 0);
-assert_eq!(call!(remi_si16(-32768, 1)), 0);
-assert_eq!(call!(remi_si16(-32768, 2)), 0);
-assert_eq!(call!(remi_si16(-32768, 4)), 0);
-assert_eq!(call!(remi_si16(-32767, -32767)), 0);
-assert_eq!(call!(remi_si16(-32767, 1)), 0);
-assert_eq!(call!(remi_si16(-32767, 32767)), 0);
-assert_eq!(call!(remi_si16(-32547, -32547)), 0);
-assert_eq!(call!(remi_si16(-32547, 1)), 0);
-assert_eq!(call!(remi_si16(-32547, 3)), 0);
-assert_eq!(call!(remi_si16(0, -32768)), 0);
-assert_eq!(call!(remi_si16(0, -32767)), 0);
-assert_eq!(call!(remi_si16(0, -32547)), 0);
-assert_eq!(call!(remi_si16(0, 1)), 0);
-assert_eq!(call!(remi_si16(0, 2)), 0);
-assert_eq!(call!(remi_si16(0, 3)), 0);
-assert_eq!(call!(remi_si16(0, 4)), 0);
-assert_eq!(call!(remi_si16(0, 10486)), 0);
-assert_eq!(call!(remi_si16(0, 16514)), 0);
-assert_eq!(call!(remi_si16(0, 32766)), 0);
-assert_eq!(call!(remi_si16(0, 32767)), 0);
-assert_eq!(call!(remi_si16(1, 1)), 0);
-assert_eq!(call!(remi_si16(2, 1)), 0);
-assert_eq!(call!(remi_si16(2, 2)), 0);
-assert_eq!(call!(remi_si16(3, 1)), 0);
-assert_eq!(call!(remi_si16(3, 3)), 0);
-assert_eq!(call!(remi_si16(4, 1)), 0);
-assert_eq!(call!(remi_si16(4, 2)), 0);
-assert_eq!(call!(remi_si16(4, 4)), 0);
-assert_eq!(call!(remi_si16(10486, 1)), 0);
-assert_eq!(call!(remi_si16(10486, 2)), 0);
-assert_eq!(call!(remi_si16(10486, 10486)), 0);
-assert_eq!(call!(remi_si16(16514, 1)), 0);
-assert_eq!(call!(remi_si16(16514, 2)), 0);
-assert_eq!(call!(remi_si16(16514, 16514)), 0);
-assert_eq!(call!(remi_si16(32766, 1)), 0);
-assert_eq!(call!(remi_si16(32766, 2)), 0);
-assert_eq!(call!(remi_si16(32766, 3)), 0);
-assert_eq!(call!(remi_si16(32766, 32766)), 0);
-assert_eq!(call!(remi_si16(32767, -32767)), 0);
-assert_eq!(call!(remi_si16(32767, 1)), 0);
-assert_eq!(call!(remi_si16(32767, 32767)), 0);
-assert_eq!(call!(remi_si16(1, -32768)), 1);
-assert_eq!(call!(remi_si16(1, -32767)), 1);
-assert_eq!(call!(remi_si16(1, -32547)), 1);
-assert_eq!(call!(remi_si16(1, 2)), 1);
-assert_eq!(call!(remi_si16(1, 3)), 1);
-assert_eq!(call!(remi_si16(1, 4)), 1);
-assert_eq!(call!(remi_si16(1, 10486)), 1);
-assert_eq!(call!(remi_si16(1, 16514)), 1);
-assert_eq!(call!(remi_si16(1, 32766)), 1);
-assert_eq!(call!(remi_si16(1, 32767)), 1);
-assert_eq!(call!(remi_si16(3, 2)), 1);
-assert_eq!(call!(remi_si16(4, 3)), 1);
-assert_eq!(call!(remi_si16(10486, 3)), 1);
-assert_eq!(call!(remi_si16(32767, 2)), 1);
-assert_eq!(call!(remi_si16(32767, 3)), 1);
-assert_eq!(call!(remi_si16(32767, 32766)), 1);
-assert_eq!(call!(remi_si16(2, -32768)), 2);
-assert_eq!(call!(remi_si16(2, -32767)), 2);
-assert_eq!(call!(remi_si16(2, -32547)), 2);
-assert_eq!(call!(remi_si16(2, 3)), 2);
-assert_eq!(call!(remi_si16(2, 4)), 2);
-assert_eq!(call!(remi_si16(2, 10486)), 2);
-assert_eq!(call!(remi_si16(2, 16514)), 2);
-assert_eq!(call!(remi_si16(2, 32766)), 2);
-assert_eq!(call!(remi_si16(2, 32767)), 2);
-assert_eq!(call!(remi_si16(10486, 4)), 2);
-assert_eq!(call!(remi_si16(16514, 3)), 2);
-assert_eq!(call!(remi_si16(16514, 4)), 2);
-assert_eq!(call!(remi_si16(32766, 4)), 2);
-assert_eq!(call!(remi_si16(3, -32768)), 3);
-assert_eq!(call!(remi_si16(3, -32767)), 3);
-assert_eq!(call!(remi_si16(3, -32547)), 3);
-assert_eq!(call!(remi_si16(3, 4)), 3);
-assert_eq!(call!(remi_si16(3, 10486)), 3);
-assert_eq!(call!(remi_si16(3, 16514)), 3);
-assert_eq!(call!(remi_si16(3, 32766)), 3);
-assert_eq!(call!(remi_si16(3, 32767)), 3);
-assert_eq!(call!(remi_si16(32767, 4)), 3);
-assert_eq!(call!(remi_si16(4, -32768)), 4);
-assert_eq!(call!(remi_si16(4, -32767)), 4);
-assert_eq!(call!(remi_si16(4, -32547)), 4);
-assert_eq!(call!(remi_si16(4, 10486)), 4);
-assert_eq!(call!(remi_si16(4, 16514)), 4);
-assert_eq!(call!(remi_si16(4, 32766)), 4);
-assert_eq!(call!(remi_si16(4, 32767)), 4);
-assert_eq!(call!(remi_si16(32766, -32547)), 219);
-assert_eq!(call!(remi_si16(32767, -32547)), 220);
-assert_eq!(call!(remi_si16(32766, 10486)), 1308);
-assert_eq!(call!(remi_si16(32767, 10486)), 1309);
-assert_eq!(call!(remi_si16(16514, 10486)), 6028);
-assert_eq!(call!(remi_si16(10486, -32768)), 10486);
-assert_eq!(call!(remi_si16(10486, -32767)), 10486);
-assert_eq!(call!(remi_si16(10486, -32547)), 10486);
-assert_eq!(call!(remi_si16(10486, 16514)), 10486);
-assert_eq!(call!(remi_si16(10486, 32766)), 10486);
-assert_eq!(call!(remi_si16(10486, 32767)), 10486);
-assert_eq!(call!(remi_si16(32766, 16514)), 16252);
-assert_eq!(call!(remi_si16(32767, 16514)), 16253);
-assert_eq!(call!(remi_si16(16514, -32768)), 16514);
-assert_eq!(call!(remi_si16(16514, -32767)), 16514);
-assert_eq!(call!(remi_si16(16514, -32547)), 16514);
-assert_eq!(call!(remi_si16(16514, 32766)), 16514);
-assert_eq!(call!(remi_si16(16514, 32767)), 16514);
-assert_eq!(call!(remi_si16(32766, -32768)), 32766);
-assert_eq!(call!(remi_si16(32766, -32767)), 32766);
-assert_eq!(call!(remi_si16(32766, 32767)), 32766);
-assert_eq!(call!(remi_si16(32767, -32768)), 32767);
-assert_eq!(call!(remi_si32(-2147483647, -2147483648)), -2147483647);
-assert_eq!(call!(remi_si32(-1713183800, -2147483648)), -1713183800);
-assert_eq!(call!(remi_si32(-1713183800, -2147483647)), -1713183800);
-assert_eq!(call!(remi_si32(-1713183800, 2147483646)), -1713183800);
-assert_eq!(call!(remi_si32(-1713183800, 2147483647)), -1713183800);
-assert_eq!(call!(remi_si32(-1252582164, -2147483648)), -1252582164);
-assert_eq!(call!(remi_si32(-1252582164, -2147483647)), -1252582164);
-assert_eq!(call!(remi_si32(-1252582164, -1713183800)), -1252582164);
-assert_eq!(call!(remi_si32(-1252582164, 2147483646)), -1252582164);
-assert_eq!(call!(remi_si32(-1252582164, 2147483647)), -1252582164);
-assert_eq!(call!(remi_si32(-1035405763, -2147483648)), -1035405763);
-assert_eq!(call!(remi_si32(-1035405763, -2147483647)), -1035405763);
-assert_eq!(call!(remi_si32(-1035405763, -1713183800)), -1035405763);
-assert_eq!(call!(remi_si32(-1035405763, -1252582164)), -1035405763);
-assert_eq!(call!(remi_si32(-1035405763, 2147483646)), -1035405763);
-assert_eq!(call!(remi_si32(-1035405763, 2147483647)), -1035405763);
-assert_eq!(call!(remi_si32(-2147483648, -1252582164)), -894901484);
-assert_eq!(call!(remi_si32(-2147483647, -1252582164)), -894901483);
-assert_eq!(call!(remi_si32(-1713183800, -1035405763)), -677778037);
-assert_eq!(call!(remi_si32(-1713183800, -1252582164)), -460601636);
-assert_eq!(call!(remi_si32(-2147483648, -1713183800)), -434299848);
-assert_eq!(call!(remi_si32(-2147483647, -1713183800)), -434299847);
-assert_eq!(call!(remi_si32(-1252582164, -1035405763)), -217176401);
-assert_eq!(call!(remi_si32(-2147483648, -1035405763)), -76672122);
-assert_eq!(call!(remi_si32(-2147483647, -1035405763)), -76672121);
-assert_eq!(call!(remi_si32(-2147483647, 4)), -3);
-assert_eq!(call!(remi_si32(-1035405763, 4)), -3);
-assert_eq!(call!(remi_si32(-2147483648, 3)), -2);
-assert_eq!(call!(remi_si32(-2147483648, 2147483646)), -2);
-assert_eq!(call!(remi_si32(-1713183800, 3)), -2);
-assert_eq!(call!(remi_si32(-2147483648, -2147483647)), -1);
-assert_eq!(call!(remi_si32(-2147483648, 2147483647)), -1);
-assert_eq!(call!(remi_si32(-2147483647, 2)), -1);
-assert_eq!(call!(remi_si32(-2147483647, 3)), -1);
-assert_eq!(call!(remi_si32(-2147483647, 2147483646)), -1);
-assert_eq!(call!(remi_si32(-1035405763, 2)), -1);
-assert_eq!(call!(remi_si32(-1035405763, 3)), -1);
-assert_eq!(call!(remi_si32(-2147483648, -2147483648)), 0);
-assert_eq!(call!(remi_si32(-2147483648, 1)), 0);
-assert_eq!(call!(remi_si32(-2147483648, 2)), 0);
-assert_eq!(call!(remi_si32(-2147483648, 4)), 0);
-assert_eq!(call!(remi_si32(-2147483647, -2147483647)), 0);
-assert_eq!(call!(remi_si32(-2147483647, 1)), 0);
-assert_eq!(call!(remi_si32(-2147483647, 2147483647)), 0);
-assert_eq!(call!(remi_si32(-1713183800, -1713183800)), 0);
-assert_eq!(call!(remi_si32(-1713183800, 1)), 0);
-assert_eq!(call!(remi_si32(-1713183800, 2)), 0);
-assert_eq!(call!(remi_si32(-1713183800, 4)), 0);
-assert_eq!(call!(remi_si32(-1252582164, -1252582164)), 0);
-assert_eq!(call!(remi_si32(-1252582164, 1)), 0);
-assert_eq!(call!(remi_si32(-1252582164, 2)), 0);
-assert_eq!(call!(remi_si32(-1252582164, 3)), 0);
-assert_eq!(call!(remi_si32(-1252582164, 4)), 0);
-assert_eq!(call!(remi_si32(-1035405763, -1035405763)), 0);
-assert_eq!(call!(remi_si32(-1035405763, 1)), 0);
-assert_eq!(call!(remi_si32(0, -2147483648)), 0);
-assert_eq!(call!(remi_si32(0, -2147483647)), 0);
-assert_eq!(call!(remi_si32(0, -1713183800)), 0);
-assert_eq!(call!(remi_si32(0, -1252582164)), 0);
-assert_eq!(call!(remi_si32(0, -1035405763)), 0);
-assert_eq!(call!(remi_si32(0, 1)), 0);
-assert_eq!(call!(remi_si32(0, 2)), 0);
-assert_eq!(call!(remi_si32(0, 3)), 0);
-assert_eq!(call!(remi_si32(0, 4)), 0);
-assert_eq!(call!(remi_si32(0, 2147483646)), 0);
-assert_eq!(call!(remi_si32(0, 2147483647)), 0);
-assert_eq!(call!(remi_si32(1, 1)), 0);
-assert_eq!(call!(remi_si32(2, 1)), 0);
-assert_eq!(call!(remi_si32(2, 2)), 0);
-assert_eq!(call!(remi_si32(3, 1)), 0);
-assert_eq!(call!(remi_si32(3, 3)), 0);
-assert_eq!(call!(remi_si32(4, 1)), 0);
-assert_eq!(call!(remi_si32(4, 2)), 0);
-assert_eq!(call!(remi_si32(4, 4)), 0);
-assert_eq!(call!(remi_si32(2147483646, 1)), 0);
-assert_eq!(call!(remi_si32(2147483646, 2)), 0);
-assert_eq!(call!(remi_si32(2147483646, 3)), 0);
-assert_eq!(call!(remi_si32(2147483646, 2147483646)), 0);
-assert_eq!(call!(remi_si32(2147483647, -2147483647)), 0);
-assert_eq!(call!(remi_si32(2147483647, 1)), 0);
-assert_eq!(call!(remi_si32(2147483647, 2147483647)), 0);
-assert_eq!(call!(remi_si32(1, -2147483648)), 1);
-assert_eq!(call!(remi_si32(1, -2147483647)), 1);
-assert_eq!(call!(remi_si32(1, -1713183800)), 1);
-assert_eq!(call!(remi_si32(1, -1252582164)), 1);
-assert_eq!(call!(remi_si32(1, -1035405763)), 1);
-assert_eq!(call!(remi_si32(1, 2)), 1);
-assert_eq!(call!(remi_si32(1, 3)), 1);
-assert_eq!(call!(remi_si32(1, 4)), 1);
-assert_eq!(call!(remi_si32(1, 2147483646)), 1);
-assert_eq!(call!(remi_si32(1, 2147483647)), 1);
-assert_eq!(call!(remi_si32(3, 2)), 1);
-assert_eq!(call!(remi_si32(4, 3)), 1);
-assert_eq!(call!(remi_si32(2147483647, 2)), 1);
-assert_eq!(call!(remi_si32(2147483647, 3)), 1);
-assert_eq!(call!(remi_si32(2147483647, 2147483646)), 1);
-assert_eq!(call!(remi_si32(2, -2147483648)), 2);
-assert_eq!(call!(remi_si32(2, -2147483647)), 2);
-assert_eq!(call!(remi_si32(2, -1713183800)), 2);
-assert_eq!(call!(remi_si32(2, -1252582164)), 2);
-assert_eq!(call!(remi_si32(2, -1035405763)), 2);
-assert_eq!(call!(remi_si32(2, 3)), 2);
-assert_eq!(call!(remi_si32(2, 4)), 2);
-assert_eq!(call!(remi_si32(2, 2147483646)), 2);
-assert_eq!(call!(remi_si32(2, 2147483647)), 2);
-assert_eq!(call!(remi_si32(2147483646, 4)), 2);
-assert_eq!(call!(remi_si32(3, -2147483648)), 3);
-assert_eq!(call!(remi_si32(3, -2147483647)), 3);
-assert_eq!(call!(remi_si32(3, -1713183800)), 3);
-assert_eq!(call!(remi_si32(3, -1252582164)), 3);
-assert_eq!(call!(remi_si32(3, -1035405763)), 3);
-assert_eq!(call!(remi_si32(3, 4)), 3);
-assert_eq!(call!(remi_si32(3, 2147483646)), 3);
-assert_eq!(call!(remi_si32(3, 2147483647)), 3);
-assert_eq!(call!(remi_si32(2147483647, 4)), 3);
-assert_eq!(call!(remi_si32(4, -2147483648)), 4);
-assert_eq!(call!(remi_si32(4, -2147483647)), 4);
-assert_eq!(call!(remi_si32(4, -1713183800)), 4);
-assert_eq!(call!(remi_si32(4, -1252582164)), 4);
-assert_eq!(call!(remi_si32(4, -1035405763)), 4);
-assert_eq!(call!(remi_si32(4, 2147483646)), 4);
-assert_eq!(call!(remi_si32(4, 2147483647)), 4);
-assert_eq!(call!(remi_si32(2147483646, -1035405763)), 76672120);
-assert_eq!(call!(remi_si32(2147483647, -1035405763)), 76672121);
-assert_eq!(call!(remi_si32(2147483646, -1713183800)), 434299846);
-assert_eq!(call!(remi_si32(2147483647, -1713183800)), 434299847);
-assert_eq!(call!(remi_si32(2147483646, -1252582164)), 894901482);
-assert_eq!(call!(remi_si32(2147483647, -1252582164)), 894901483);
-assert_eq!(call!(remi_si32(2147483646, -2147483648)), 2147483646);
-assert_eq!(call!(remi_si32(2147483646, -2147483647)), 2147483646);
-assert_eq!(call!(remi_si32(2147483646, 2147483647)), 2147483646);
-assert_eq!(call!(remi_si32(2147483647, -2147483648)), 2147483647);
-assert_eq!(call!(remi_si64(-9223372036854775807, -9223372036854775808)), -9223372036854775807);
-assert_eq!(call!(remi_si64(-9223372036854775808, 5577148965131116544)), -3646223071723659264);
-assert_eq!(call!(remi_si64(-9223372036854775807, 5577148965131116544)), -3646223071723659263);
-assert_eq!(call!(remi_si64(-1741927215160008704, -9223372036854775808)), -1741927215160008704);
-assert_eq!(call!(remi_si64(-1741927215160008704, -9223372036854775807)), -1741927215160008704);
-assert_eq!(call!(remi_si64(-1741927215160008704, 5577148965131116544)), -1741927215160008704);
-assert_eq!(call!(remi_si64(-1741927215160008704, 9223372036854775806)), -1741927215160008704);
-assert_eq!(call!(remi_si64(-1741927215160008704, 9223372036854775807)), -1741927215160008704);
-assert_eq!(call!(remi_si64(-1328271339354574848, -9223372036854775808)), -1328271339354574848);
-assert_eq!(call!(remi_si64(-1328271339354574848, -9223372036854775807)), -1328271339354574848);
-assert_eq!(call!(remi_si64(-1328271339354574848, -1741927215160008704)), -1328271339354574848);
-assert_eq!(call!(remi_si64(-1328271339354574848, 5577148965131116544)), -1328271339354574848);
-assert_eq!(call!(remi_si64(-1328271339354574848, 9223372036854775806)), -1328271339354574848);
-assert_eq!(call!(remi_si64(-1328271339354574848, 9223372036854775807)), -1328271339354574848);
-assert_eq!(call!(remi_si64(-9223372036854775808, -1328271339354574848)), -1253744000727326720);
-assert_eq!(call!(remi_si64(-9223372036854775807, -1328271339354574848)), -1253744000727326719);
-assert_eq!(call!(remi_si64(-9223372036854775808, -1741927215160008704)), -513735961054732288);
-assert_eq!(call!(remi_si64(-9223372036854775807, -1741927215160008704)), -513735961054732287);
-assert_eq!(call!(remi_si64(-1741927215160008704, -1328271339354574848)), -413655875805433856);
-assert_eq!(call!(remi_si64(-9223372036854775807, 4)), -3);
-assert_eq!(call!(remi_si64(-9223372036854775808, 3)), -2);
-assert_eq!(call!(remi_si64(-9223372036854775808, 9223372036854775806)), -2);
-assert_eq!(call!(remi_si64(-1741927215160008704, 3)), -2);
-assert_eq!(call!(remi_si64(-9223372036854775808, -9223372036854775807)), -1);
-assert_eq!(call!(remi_si64(-9223372036854775808, 9223372036854775807)), -1);
-assert_eq!(call!(remi_si64(-9223372036854775807, 2)), -1);
-assert_eq!(call!(remi_si64(-9223372036854775807, 3)), -1);
-assert_eq!(call!(remi_si64(-9223372036854775807, 9223372036854775806)), -1);
-assert_eq!(call!(remi_si64(-9223372036854775808, -9223372036854775808)), 0);
-assert_eq!(call!(remi_si64(-9223372036854775808, 1)), 0);
-assert_eq!(call!(remi_si64(-9223372036854775808, 2)), 0);
-assert_eq!(call!(remi_si64(-9223372036854775808, 4)), 0);
-assert_eq!(call!(remi_si64(-9223372036854775807, -9223372036854775807)), 0);
-assert_eq!(call!(remi_si64(-9223372036854775807, 1)), 0);
-assert_eq!(call!(remi_si64(-9223372036854775807, 9223372036854775807)), 0);
-assert_eq!(call!(remi_si64(-1741927215160008704, -1741927215160008704)), 0);
-assert_eq!(call!(remi_si64(-1741927215160008704, 1)), 0);
-assert_eq!(call!(remi_si64(-1741927215160008704, 2)), 0);
-assert_eq!(call!(remi_si64(-1741927215160008704, 4)), 0);
-assert_eq!(call!(remi_si64(-1328271339354574848, -1328271339354574848)), 0);
-assert_eq!(call!(remi_si64(-1328271339354574848, 1)), 0);
-assert_eq!(call!(remi_si64(-1328271339354574848, 2)), 0);
-assert_eq!(call!(remi_si64(-1328271339354574848, 3)), 0);
-assert_eq!(call!(remi_si64(-1328271339354574848, 4)), 0);
-assert_eq!(call!(remi_si64(0, -9223372036854775808)), 0);
-assert_eq!(call!(remi_si64(0, -9223372036854775807)), 0);
-assert_eq!(call!(remi_si64(0, -1741927215160008704)), 0);
-assert_eq!(call!(remi_si64(0, -1328271339354574848)), 0);
-assert_eq!(call!(remi_si64(0, 1)), 0);
-assert_eq!(call!(remi_si64(0, 2)), 0);
-assert_eq!(call!(remi_si64(0, 3)), 0);
-assert_eq!(call!(remi_si64(0, 4)), 0);
-assert_eq!(call!(remi_si64(0, 5577148965131116544)), 0);
-assert_eq!(call!(remi_si64(0, 9223372036854775806)), 0);
-assert_eq!(call!(remi_si64(0, 9223372036854775807)), 0);
-assert_eq!(call!(remi_si64(1, 1)), 0);
-assert_eq!(call!(remi_si64(2, 1)), 0);
-assert_eq!(call!(remi_si64(2, 2)), 0);
-assert_eq!(call!(remi_si64(3, 1)), 0);
-assert_eq!(call!(remi_si64(3, 3)), 0);
-assert_eq!(call!(remi_si64(4, 1)), 0);
-assert_eq!(call!(remi_si64(4, 2)), 0);
-assert_eq!(call!(remi_si64(4, 4)), 0);
-assert_eq!(call!(remi_si64(5577148965131116544, 1)), 0);
-assert_eq!(call!(remi_si64(5577148965131116544, 2)), 0);
-assert_eq!(call!(remi_si64(5577148965131116544, 4)), 0);
-assert_eq!(call!(remi_si64(5577148965131116544, 5577148965131116544)), 0);
-assert_eq!(call!(remi_si64(9223372036854775806, 1)), 0);
-assert_eq!(call!(remi_si64(9223372036854775806, 2)), 0);
-assert_eq!(call!(remi_si64(9223372036854775806, 3)), 0);
-assert_eq!(call!(remi_si64(9223372036854775806, 9223372036854775806)), 0);
-assert_eq!(call!(remi_si64(9223372036854775807, -9223372036854775807)), 0);
-assert_eq!(call!(remi_si64(9223372036854775807, 1)), 0);
-assert_eq!(call!(remi_si64(9223372036854775807, 9223372036854775807)), 0);
-assert_eq!(call!(remi_si64(1, -9223372036854775808)), 1);
-assert_eq!(call!(remi_si64(1, -9223372036854775807)), 1);
-assert_eq!(call!(remi_si64(1, -1741927215160008704)), 1);
-assert_eq!(call!(remi_si64(1, -1328271339354574848)), 1);
-assert_eq!(call!(remi_si64(1, 2)), 1);
-assert_eq!(call!(remi_si64(1, 3)), 1);
-assert_eq!(call!(remi_si64(1, 4)), 1);
-assert_eq!(call!(remi_si64(1, 5577148965131116544)), 1);
-assert_eq!(call!(remi_si64(1, 9223372036854775806)), 1);
-assert_eq!(call!(remi_si64(1, 9223372036854775807)), 1);
-assert_eq!(call!(remi_si64(3, 2)), 1);
-assert_eq!(call!(remi_si64(4, 3)), 1);
-assert_eq!(call!(remi_si64(9223372036854775807, 2)), 1);
-assert_eq!(call!(remi_si64(9223372036854775807, 3)), 1);
-assert_eq!(call!(remi_si64(9223372036854775807, 9223372036854775806)), 1);
-assert_eq!(call!(remi_si64(2, -9223372036854775808)), 2);
-assert_eq!(call!(remi_si64(2, -9223372036854775807)), 2);
-assert_eq!(call!(remi_si64(2, -1741927215160008704)), 2);
-assert_eq!(call!(remi_si64(2, -1328271339354574848)), 2);
-assert_eq!(call!(remi_si64(2, 3)), 2);
-assert_eq!(call!(remi_si64(2, 4)), 2);
-assert_eq!(call!(remi_si64(2, 5577148965131116544)), 2);
-assert_eq!(call!(remi_si64(2, 9223372036854775806)), 2);
-assert_eq!(call!(remi_si64(2, 9223372036854775807)), 2);
-assert_eq!(call!(remi_si64(5577148965131116544, 3)), 2);
-assert_eq!(call!(remi_si64(9223372036854775806, 4)), 2);
-assert_eq!(call!(remi_si64(3, -9223372036854775808)), 3);
-assert_eq!(call!(remi_si64(3, -9223372036854775807)), 3);
-assert_eq!(call!(remi_si64(3, -1741927215160008704)), 3);
-assert_eq!(call!(remi_si64(3, -1328271339354574848)), 3);
-assert_eq!(call!(remi_si64(3, 4)), 3);
-assert_eq!(call!(remi_si64(3, 5577148965131116544)), 3);
-assert_eq!(call!(remi_si64(3, 9223372036854775806)), 3);
-assert_eq!(call!(remi_si64(3, 9223372036854775807)), 3);
-assert_eq!(call!(remi_si64(9223372036854775807, 4)), 3);
-assert_eq!(call!(remi_si64(4, -9223372036854775808)), 4);
-assert_eq!(call!(remi_si64(4, -9223372036854775807)), 4);
-assert_eq!(call!(remi_si64(4, -1741927215160008704)), 4);
-assert_eq!(call!(remi_si64(4, -1328271339354574848)), 4);
-assert_eq!(call!(remi_si64(4, 5577148965131116544)), 4);
-assert_eq!(call!(remi_si64(4, 9223372036854775806)), 4);
-assert_eq!(call!(remi_si64(4, 9223372036854775807)), 4);
-assert_eq!(call!(remi_si64(5577148965131116544, -1328271339354574848)), 264063607712817152);
-assert_eq!(call!(remi_si64(5577148965131116544, -1741927215160008704)), 351367319651090432);
-assert_eq!(call!(remi_si64(9223372036854775806, -1741927215160008704)), 513735961054732286);
-assert_eq!(call!(remi_si64(9223372036854775807, -1741927215160008704)), 513735961054732287);
-assert_eq!(call!(remi_si64(9223372036854775806, -1328271339354574848)), 1253744000727326718);
-assert_eq!(call!(remi_si64(9223372036854775807, -1328271339354574848)), 1253744000727326719);
-assert_eq!(call!(remi_si64(9223372036854775806, 5577148965131116544)), 3646223071723659262);
-assert_eq!(call!(remi_si64(9223372036854775807, 5577148965131116544)), 3646223071723659263);
-assert_eq!(call!(remi_si64(5577148965131116544, -9223372036854775808)), 5577148965131116544);
-assert_eq!(call!(remi_si64(5577148965131116544, -9223372036854775807)), 5577148965131116544);
-assert_eq!(call!(remi_si64(5577148965131116544, 9223372036854775806)), 5577148965131116544);
-assert_eq!(call!(remi_si64(5577148965131116544, 9223372036854775807)), 5577148965131116544);
-assert_eq!(call!(remi_si64(9223372036854775806, -9223372036854775808)), 9223372036854775806);
-assert_eq!(call!(remi_si64(9223372036854775806, -9223372036854775807)), 9223372036854775806);
-assert_eq!(call!(remi_si64(9223372036854775806, 9223372036854775807)), 9223372036854775806);
-assert_eq!(call!(remi_si64(9223372036854775807, -9223372036854775808)), 9223372036854775807);
-assert_eq!(call!(remi_si8(-127, -128)), -127);
-assert_eq!(call!(remi_si8(-127, 16)), -15);
-assert_eq!(call!(remi_si8(-127, 4)), -3);
-assert_eq!(call!(remi_si8(-128, 3)), -2);
-assert_eq!(call!(remi_si8(-128, 126)), -2);
-assert_eq!(call!(remi_si8(-128, -127)), -1);
-assert_eq!(call!(remi_si8(-128, 127)), -1);
-assert_eq!(call!(remi_si8(-127, 2)), -1);
-assert_eq!(call!(remi_si8(-127, 3)), -1);
-assert_eq!(call!(remi_si8(-127, 126)), -1);
-assert_eq!(call!(remi_si8(-128, -128)), 0);
-assert_eq!(call!(remi_si8(-128, 1)), 0);
-assert_eq!(call!(remi_si8(-128, 2)), 0);
-assert_eq!(call!(remi_si8(-128, 4)), 0);
-assert_eq!(call!(remi_si8(-128, 16)), 0);
-assert_eq!(call!(remi_si8(-127, -127)), 0);
-assert_eq!(call!(remi_si8(-127, 1)), 0);
-assert_eq!(call!(remi_si8(-127, 127)), 0);
-assert_eq!(call!(remi_si8(0, -128)), 0);
-assert_eq!(call!(remi_si8(0, -127)), 0);
-assert_eq!(call!(remi_si8(0, 1)), 0);
-assert_eq!(call!(remi_si8(0, 2)), 0);
-assert_eq!(call!(remi_si8(0, 3)), 0);
-assert_eq!(call!(remi_si8(0, 4)), 0);
-assert_eq!(call!(remi_si8(0, 16)), 0);
-assert_eq!(call!(remi_si8(0, 126)), 0);
-assert_eq!(call!(remi_si8(0, 127)), 0);
-assert_eq!(call!(remi_si8(1, 1)), 0);
-assert_eq!(call!(remi_si8(2, 1)), 0);
-assert_eq!(call!(remi_si8(2, 2)), 0);
-assert_eq!(call!(remi_si8(3, 1)), 0);
-assert_eq!(call!(remi_si8(3, 3)), 0);
-assert_eq!(call!(remi_si8(4, 1)), 0);
-assert_eq!(call!(remi_si8(4, 2)), 0);
-assert_eq!(call!(remi_si8(4, 4)), 0);
-assert_eq!(call!(remi_si8(16, 1)), 0);
-assert_eq!(call!(remi_si8(16, 2)), 0);
-assert_eq!(call!(remi_si8(16, 4)), 0);
-assert_eq!(call!(remi_si8(16, 16)), 0);
-assert_eq!(call!(remi_si8(126, 1)), 0);
-assert_eq!(call!(remi_si8(126, 2)), 0);
-assert_eq!(call!(remi_si8(126, 3)), 0);
-assert_eq!(call!(remi_si8(126, 126)), 0);
-assert_eq!(call!(remi_si8(127, -127)), 0);
-assert_eq!(call!(remi_si8(127, 1)), 0);
-assert_eq!(call!(remi_si8(127, 127)), 0);
-assert_eq!(call!(remi_si8(1, -128)), 1);
-assert_eq!(call!(remi_si8(1, -127)), 1);
-assert_eq!(call!(remi_si8(1, 2)), 1);
-assert_eq!(call!(remi_si8(1, 3)), 1);
-assert_eq!(call!(remi_si8(1, 4)), 1);
-assert_eq!(call!(remi_si8(1, 16)), 1);
-assert_eq!(call!(remi_si8(1, 126)), 1);
-assert_eq!(call!(remi_si8(1, 127)), 1);
-assert_eq!(call!(remi_si8(3, 2)), 1);
-assert_eq!(call!(remi_si8(4, 3)), 1);
-assert_eq!(call!(remi_si8(16, 3)), 1);
-assert_eq!(call!(remi_si8(127, 2)), 1);
-assert_eq!(call!(remi_si8(127, 3)), 1);
-assert_eq!(call!(remi_si8(127, 126)), 1);
-assert_eq!(call!(remi_si8(2, -128)), 2);
-assert_eq!(call!(remi_si8(2, -127)), 2);
-assert_eq!(call!(remi_si8(2, 3)), 2);
-assert_eq!(call!(remi_si8(2, 4)), 2);
-assert_eq!(call!(remi_si8(2, 16)), 2);
-assert_eq!(call!(remi_si8(2, 126)), 2);
-assert_eq!(call!(remi_si8(2, 127)), 2);
-assert_eq!(call!(remi_si8(126, 4)), 2);
-assert_eq!(call!(remi_si8(3, -128)), 3);
-assert_eq!(call!(remi_si8(3, -127)), 3);
-assert_eq!(call!(remi_si8(3, 4)), 3);
-assert_eq!(call!(remi_si8(3, 16)), 3);
-assert_eq!(call!(remi_si8(3, 126)), 3);
-assert_eq!(call!(remi_si8(3, 127)), 3);
-assert_eq!(call!(remi_si8(127, 4)), 3);
-assert_eq!(call!(remi_si8(4, -128)), 4);
-assert_eq!(call!(remi_si8(4, -127)), 4);
-assert_eq!(call!(remi_si8(4, 16)), 4);
-assert_eq!(call!(remi_si8(4, 126)), 4);
-assert_eq!(call!(remi_si8(4, 127)), 4);
-assert_eq!(call!(remi_si8(126, 16)), 14);
-assert_eq!(call!(remi_si8(127, 16)), 15);
-assert_eq!(call!(remi_si8(16, -128)), 16);
-assert_eq!(call!(remi_si8(16, -127)), 16);
-assert_eq!(call!(remi_si8(16, 126)), 16);
-assert_eq!(call!(remi_si8(16, 127)), 16);
-assert_eq!(call!(remi_si8(126, -128)), 126);
-assert_eq!(call!(remi_si8(126, -127)), 126);
-assert_eq!(call!(remi_si8(126, 127)), 126);
-assert_eq!(call!(remi_si8(127, -128)), 127);
-assert_eq!(call!(remi_ui16(0, 1)), 0);
-assert_eq!(call!(remi_ui16(0, 2)), 0);
-assert_eq!(call!(remi_ui16(0, 3)), 0);
-assert_eq!(call!(remi_ui16(0, 4)), 0);
-assert_eq!(call!(remi_ui16(0, 1717)), 0);
-assert_eq!(call!(remi_ui16(0, 17988)), 0);
-assert_eq!(call!(remi_ui16(0, 65096)), 0);
-assert_eq!(call!(remi_ui16(0, 65534)), 0);
-assert_eq!(call!(remi_ui16(0, 65535)), 0);
-assert_eq!(call!(remi_ui16(1, 1)), 0);
-assert_eq!(call!(remi_ui16(2, 1)), 0);
-assert_eq!(call!(remi_ui16(2, 2)), 0);
-assert_eq!(call!(remi_ui16(3, 1)), 0);
-assert_eq!(call!(remi_ui16(3, 3)), 0);
-assert_eq!(call!(remi_ui16(4, 1)), 0);
-assert_eq!(call!(remi_ui16(4, 2)), 0);
-assert_eq!(call!(remi_ui16(4, 4)), 0);
-assert_eq!(call!(remi_ui16(1717, 1)), 0);
-assert_eq!(call!(remi_ui16(1717, 1717)), 0);
-assert_eq!(call!(remi_ui16(17988, 1)), 0);
-assert_eq!(call!(remi_ui16(17988, 2)), 0);
-assert_eq!(call!(remi_ui16(17988, 3)), 0);
-assert_eq!(call!(remi_ui16(17988, 4)), 0);
-assert_eq!(call!(remi_ui16(17988, 17988)), 0);
-assert_eq!(call!(remi_ui16(65096, 1)), 0);
-assert_eq!(call!(remi_ui16(65096, 2)), 0);
-assert_eq!(call!(remi_ui16(65096, 4)), 0);
-assert_eq!(call!(remi_ui16(65096, 65096)), 0);
-assert_eq!(call!(remi_ui16(65534, 1)), 0);
-assert_eq!(call!(remi_ui16(65534, 2)), 0);
-assert_eq!(call!(remi_ui16(65534, 65534)), 0);
-assert_eq!(call!(remi_ui16(65535, 1)), 0);
-assert_eq!(call!(remi_ui16(65535, 3)), 0);
-assert_eq!(call!(remi_ui16(65535, 65535)), 0);
-assert_eq!(call!(remi_ui16(1, 2)), 1);
-assert_eq!(call!(remi_ui16(1, 3)), 1);
-assert_eq!(call!(remi_ui16(1, 4)), 1);
-assert_eq!(call!(remi_ui16(1, 1717)), 1);
-assert_eq!(call!(remi_ui16(1, 17988)), 1);
-assert_eq!(call!(remi_ui16(1, 65096)), 1);
-assert_eq!(call!(remi_ui16(1, 65534)), 1);
-assert_eq!(call!(remi_ui16(1, 65535)), 1);
-assert_eq!(call!(remi_ui16(3, 2)), 1);
-assert_eq!(call!(remi_ui16(4, 3)), 1);
-assert_eq!(call!(remi_ui16(1717, 2)), 1);
-assert_eq!(call!(remi_ui16(1717, 3)), 1);
-assert_eq!(call!(remi_ui16(1717, 4)), 1);
-assert_eq!(call!(remi_ui16(65535, 2)), 1);
-assert_eq!(call!(remi_ui16(65535, 65534)), 1);
-assert_eq!(call!(remi_ui16(2, 3)), 2);
-assert_eq!(call!(remi_ui16(2, 4)), 2);
-assert_eq!(call!(remi_ui16(2, 1717)), 2);
-assert_eq!(call!(remi_ui16(2, 17988)), 2);
-assert_eq!(call!(remi_ui16(2, 65096)), 2);
-assert_eq!(call!(remi_ui16(2, 65534)), 2);
-assert_eq!(call!(remi_ui16(2, 65535)), 2);
-assert_eq!(call!(remi_ui16(65096, 3)), 2);
-assert_eq!(call!(remi_ui16(65534, 3)), 2);
-assert_eq!(call!(remi_ui16(65534, 4)), 2);
-assert_eq!(call!(remi_ui16(3, 4)), 3);
-assert_eq!(call!(remi_ui16(3, 1717)), 3);
-assert_eq!(call!(remi_ui16(3, 17988)), 3);
-assert_eq!(call!(remi_ui16(3, 65096)), 3);
-assert_eq!(call!(remi_ui16(3, 65534)), 3);
-assert_eq!(call!(remi_ui16(3, 65535)), 3);
-assert_eq!(call!(remi_ui16(65535, 4)), 3);
-assert_eq!(call!(remi_ui16(4, 1717)), 4);
-assert_eq!(call!(remi_ui16(4, 17988)), 4);
-assert_eq!(call!(remi_ui16(4, 65096)), 4);
-assert_eq!(call!(remi_ui16(4, 65534)), 4);
-assert_eq!(call!(remi_ui16(4, 65535)), 4);
-assert_eq!(call!(remi_ui16(65534, 1717)), 288);
-assert_eq!(call!(remi_ui16(65535, 1717)), 289);
-assert_eq!(call!(remi_ui16(65534, 65096)), 438);
-assert_eq!(call!(remi_ui16(65535, 65096)), 439);
-assert_eq!(call!(remi_ui16(17988, 1717)), 818);
-assert_eq!(call!(remi_ui16(65096, 1717)), 1567);
-assert_eq!(call!(remi_ui16(1717, 17988)), 1717);
-assert_eq!(call!(remi_ui16(1717, 65096)), 1717);
-assert_eq!(call!(remi_ui16(1717, 65534)), 1717);
-assert_eq!(call!(remi_ui16(1717, 65535)), 1717);
-assert_eq!(call!(remi_ui16(65096, 17988)), 11132);
-assert_eq!(call!(remi_ui16(65534, 17988)), 11570);
-assert_eq!(call!(remi_ui16(65535, 17988)), 11571);
-assert_eq!(call!(remi_ui16(17988, 65096)), 17988);
-assert_eq!(call!(remi_ui16(17988, 65534)), 17988);
-assert_eq!(call!(remi_ui16(17988, 65535)), 17988);
-assert_eq!(call!(remi_ui16(65096, 65534)), 65096);
-assert_eq!(call!(remi_ui16(65096, 65535)), 65096);
-assert_eq!(call!(remi_ui16(65534, 65535)), 65534);
-assert_eq!(call!(remi_ui32(0, 1)), 0);
-assert_eq!(call!(remi_ui32(0, 2)), 0);
-assert_eq!(call!(remi_ui32(0, 3)), 0);
-assert_eq!(call!(remi_ui32(0, 4)), 0);
-assert_eq!(call!(remi_ui32(0, 2119154652)), 0);
-assert_eq!(call!(remi_ui32(0, 3002788344)), 0);
-assert_eq!(call!(remi_ui32(0, 3482297128)), 0);
-assert_eq!(call!(remi_ui32(0, 4294967294)), 0);
-assert_eq!(call!(remi_ui32(0, 4294967295)), 0);
-assert_eq!(call!(remi_ui32(1, 1)), 0);
-assert_eq!(call!(remi_ui32(2, 1)), 0);
-assert_eq!(call!(remi_ui32(2, 2)), 0);
-assert_eq!(call!(remi_ui32(3, 1)), 0);
-assert_eq!(call!(remi_ui32(3, 3)), 0);
-assert_eq!(call!(remi_ui32(4, 1)), 0);
-assert_eq!(call!(remi_ui32(4, 2)), 0);
-assert_eq!(call!(remi_ui32(4, 4)), 0);
-assert_eq!(call!(remi_ui32(2119154652, 1)), 0);
-assert_eq!(call!(remi_ui32(2119154652, 2)), 0);
-assert_eq!(call!(remi_ui32(2119154652, 3)), 0);
-assert_eq!(call!(remi_ui32(2119154652, 4)), 0);
-assert_eq!(call!(remi_ui32(2119154652, 2119154652)), 0);
-assert_eq!(call!(remi_ui32(3002788344, 1)), 0);
-assert_eq!(call!(remi_ui32(3002788344, 2)), 0);
-assert_eq!(call!(remi_ui32(3002788344, 3)), 0);
-assert_eq!(call!(remi_ui32(3002788344, 4)), 0);
-assert_eq!(call!(remi_ui32(3002788344, 3002788344)), 0);
-assert_eq!(call!(remi_ui32(3482297128, 1)), 0);
-assert_eq!(call!(remi_ui32(3482297128, 2)), 0);
-assert_eq!(call!(remi_ui32(3482297128, 4)), 0);
-assert_eq!(call!(remi_ui32(3482297128, 3482297128)), 0);
-assert_eq!(call!(remi_ui32(4294967294, 1)), 0);
-assert_eq!(call!(remi_ui32(4294967294, 2)), 0);
-assert_eq!(call!(remi_ui32(4294967294, 4294967294)), 0);
-assert_eq!(call!(remi_ui32(4294967295, 1)), 0);
-assert_eq!(call!(remi_ui32(4294967295, 3)), 0);
-assert_eq!(call!(remi_ui32(4294967295, 4294967295)), 0);
-assert_eq!(call!(remi_ui32(1, 2)), 1);
-assert_eq!(call!(remi_ui32(1, 3)), 1);
-assert_eq!(call!(remi_ui32(1, 4)), 1);
-assert_eq!(call!(remi_ui32(1, 2119154652)), 1);
-assert_eq!(call!(remi_ui32(1, 3002788344)), 1);
-assert_eq!(call!(remi_ui32(1, 3482297128)), 1);
-assert_eq!(call!(remi_ui32(1, 4294967294)), 1);
-assert_eq!(call!(remi_ui32(1, 4294967295)), 1);
-assert_eq!(call!(remi_ui32(3, 2)), 1);
-assert_eq!(call!(remi_ui32(4, 3)), 1);
-assert_eq!(call!(remi_ui32(3482297128, 3)), 1);
-assert_eq!(call!(remi_ui32(4294967295, 2)), 1);
-assert_eq!(call!(remi_ui32(4294967295, 4294967294)), 1);
-assert_eq!(call!(remi_ui32(2, 3)), 2);
-assert_eq!(call!(remi_ui32(2, 4)), 2);
-assert_eq!(call!(remi_ui32(2, 2119154652)), 2);
-assert_eq!(call!(remi_ui32(2, 3002788344)), 2);
-assert_eq!(call!(remi_ui32(2, 3482297128)), 2);
-assert_eq!(call!(remi_ui32(2, 4294967294)), 2);
-assert_eq!(call!(remi_ui32(2, 4294967295)), 2);
-assert_eq!(call!(remi_ui32(4294967294, 3)), 2);
-assert_eq!(call!(remi_ui32(4294967294, 4)), 2);
-assert_eq!(call!(remi_ui32(3, 4)), 3);
-assert_eq!(call!(remi_ui32(3, 2119154652)), 3);
-assert_eq!(call!(remi_ui32(3, 3002788344)), 3);
-assert_eq!(call!(remi_ui32(3, 3482297128)), 3);
-assert_eq!(call!(remi_ui32(3, 4294967294)), 3);
-assert_eq!(call!(remi_ui32(3, 4294967295)), 3);
-assert_eq!(call!(remi_ui32(4294967295, 4)), 3);
-assert_eq!(call!(remi_ui32(4, 2119154652)), 4);
-assert_eq!(call!(remi_ui32(4, 3002788344)), 4);
-assert_eq!(call!(remi_ui32(4, 3482297128)), 4);
-assert_eq!(call!(remi_ui32(4, 4294967294)), 4);
-assert_eq!(call!(remi_ui32(4, 4294967295)), 4);
-assert_eq!(call!(remi_ui32(4294967294, 2119154652)), 56657990);
-assert_eq!(call!(remi_ui32(4294967295, 2119154652)), 56657991);
-assert_eq!(call!(remi_ui32(3482297128, 3002788344)), 479508784);
-assert_eq!(call!(remi_ui32(4294967294, 3482297128)), 812670166);
-assert_eq!(call!(remi_ui32(4294967295, 3482297128)), 812670167);
-assert_eq!(call!(remi_ui32(3002788344, 2119154652)), 883633692);
-assert_eq!(call!(remi_ui32(4294967294, 3002788344)), 1292178950);
-assert_eq!(call!(remi_ui32(4294967295, 3002788344)), 1292178951);
-assert_eq!(call!(remi_ui32(3482297128, 2119154652)), 1363142476);
-assert_eq!(call!(remi_ui32(2119154652, 3002788344)), 2119154652);
-assert_eq!(call!(remi_ui32(2119154652, 3482297128)), 2119154652);
-assert_eq!(call!(remi_ui32(2119154652, 4294967294)), 2119154652);
-assert_eq!(call!(remi_ui32(2119154652, 4294967295)), 2119154652);
-assert_eq!(call!(remi_ui32(3002788344, 3482297128)), 3002788344);
-assert_eq!(call!(remi_ui32(3002788344, 4294967294)), 3002788344);
-assert_eq!(call!(remi_ui32(3002788344, 4294967295)), 3002788344);
-assert_eq!(call!(remi_ui32(3482297128, 4294967294)), 3482297128);
-assert_eq!(call!(remi_ui32(3482297128, 4294967295)), 3482297128);
-assert_eq!(call!(remi_ui32(4294967294, 4294967295)), 4294967294);
-assert_eq!(call!(remi_ui64(0, 1)), 0);
-assert_eq!(call!(remi_ui64(0, 2)), 0);
-assert_eq!(call!(remi_ui64(0, 3)), 0);
-assert_eq!(call!(remi_ui64(0, 4)), 0);
-assert_eq!(call!(remi_ui64(0, 191084152064409600)), 0);
-assert_eq!(call!(remi_ui64(0, 11015955194427482112)), 0);
-assert_eq!(call!(remi_ui64(0, 16990600415051759616)), 0);
-assert_eq!(call!(remi_ui64(0, 18446744073709551614)), 0);
-assert_eq!(call!(remi_ui64(0, 18446744073709551615)), 0);
-assert_eq!(call!(remi_ui64(1, 1)), 0);
-assert_eq!(call!(remi_ui64(2, 1)), 0);
-assert_eq!(call!(remi_ui64(2, 2)), 0);
-assert_eq!(call!(remi_ui64(3, 1)), 0);
-assert_eq!(call!(remi_ui64(3, 3)), 0);
-assert_eq!(call!(remi_ui64(4, 1)), 0);
-assert_eq!(call!(remi_ui64(4, 2)), 0);
-assert_eq!(call!(remi_ui64(4, 4)), 0);
-assert_eq!(call!(remi_ui64(191084152064409600, 1)), 0);
-assert_eq!(call!(remi_ui64(191084152064409600, 2)), 0);
-assert_eq!(call!(remi_ui64(191084152064409600, 3)), 0);
-assert_eq!(call!(remi_ui64(191084152064409600, 4)), 0);
-assert_eq!(call!(remi_ui64(191084152064409600, 191084152064409600)), 0);
-assert_eq!(call!(remi_ui64(11015955194427482112, 1)), 0);
-assert_eq!(call!(remi_ui64(11015955194427482112, 2)), 0);
-assert_eq!(call!(remi_ui64(11015955194427482112, 3)), 0);
-assert_eq!(call!(remi_ui64(11015955194427482112, 4)), 0);
-assert_eq!(call!(remi_ui64(11015955194427482112, 11015955194427482112)), 0);
-assert_eq!(call!(remi_ui64(16990600415051759616, 1)), 0);
-assert_eq!(call!(remi_ui64(16990600415051759616, 2)), 0);
-assert_eq!(call!(remi_ui64(16990600415051759616, 3)), 0);
-assert_eq!(call!(remi_ui64(16990600415051759616, 4)), 0);
-assert_eq!(call!(remi_ui64(16990600415051759616, 16990600415051759616)), 0);
-assert_eq!(call!(remi_ui64(18446744073709551614, 1)), 0);
-assert_eq!(call!(remi_ui64(18446744073709551614, 2)), 0);
-assert_eq!(call!(remi_ui64(18446744073709551614, 18446744073709551614)), 0);
-assert_eq!(call!(remi_ui64(18446744073709551615, 1)), 0);
-assert_eq!(call!(remi_ui64(18446744073709551615, 3)), 0);
-assert_eq!(call!(remi_ui64(18446744073709551615, 18446744073709551615)), 0);
-assert_eq!(call!(remi_ui64(1, 2)), 1);
-assert_eq!(call!(remi_ui64(1, 3)), 1);
-assert_eq!(call!(remi_ui64(1, 4)), 1);
-assert_eq!(call!(remi_ui64(1, 191084152064409600)), 1);
-assert_eq!(call!(remi_ui64(1, 11015955194427482112)), 1);
-assert_eq!(call!(remi_ui64(1, 16990600415051759616)), 1);
-assert_eq!(call!(remi_ui64(1, 18446744073709551614)), 1);
-assert_eq!(call!(remi_ui64(1, 18446744073709551615)), 1);
-assert_eq!(call!(remi_ui64(3, 2)), 1);
-assert_eq!(call!(remi_ui64(4, 3)), 1);
-assert_eq!(call!(remi_ui64(18446744073709551615, 2)), 1);
-assert_eq!(call!(remi_ui64(18446744073709551615, 18446744073709551614)), 1);
-assert_eq!(call!(remi_ui64(2, 3)), 2);
-assert_eq!(call!(remi_ui64(2, 4)), 2);
-assert_eq!(call!(remi_ui64(2, 191084152064409600)), 2);
-assert_eq!(call!(remi_ui64(2, 11015955194427482112)), 2);
-assert_eq!(call!(remi_ui64(2, 16990600415051759616)), 2);
-assert_eq!(call!(remi_ui64(2, 18446744073709551614)), 2);
-assert_eq!(call!(remi_ui64(2, 18446744073709551615)), 2);
-assert_eq!(call!(remi_ui64(18446744073709551614, 3)), 2);
-assert_eq!(call!(remi_ui64(18446744073709551614, 4)), 2);
-assert_eq!(call!(remi_ui64(3, 4)), 3);
-assert_eq!(call!(remi_ui64(3, 191084152064409600)), 3);
-assert_eq!(call!(remi_ui64(3, 11015955194427482112)), 3);
-assert_eq!(call!(remi_ui64(3, 16990600415051759616)), 3);
-assert_eq!(call!(remi_ui64(3, 18446744073709551614)), 3);
-assert_eq!(call!(remi_ui64(3, 18446744073709551615)), 3);
-assert_eq!(call!(remi_ui64(18446744073709551615, 4)), 3);
-assert_eq!(call!(remi_ui64(4, 191084152064409600)), 4);
-assert_eq!(call!(remi_ui64(4, 11015955194427482112)), 4);
-assert_eq!(call!(remi_ui64(4, 16990600415051759616)), 4);
-assert_eq!(call!(remi_ui64(4, 18446744073709551614)), 4);
-assert_eq!(call!(remi_ui64(4, 18446744073709551615)), 4);
-assert_eq!(call!(remi_ui64(18446744073709551614, 191084152064409600)), 102665475526230014);
-assert_eq!(call!(remi_ui64(18446744073709551615, 191084152064409600)), 102665475526230015);
-assert_eq!(call!(remi_ui64(11015955194427482112, 191084152064409600)), 124158526756134912);
-assert_eq!(call!(remi_ui64(16990600415051759616, 191084152064409600)), 175195033383714816);
-assert_eq!(call!(remi_ui64(191084152064409600, 11015955194427482112)), 191084152064409600);
-assert_eq!(call!(remi_ui64(191084152064409600, 16990600415051759616)), 191084152064409600);
-assert_eq!(call!(remi_ui64(191084152064409600, 18446744073709551614)), 191084152064409600);
-assert_eq!(call!(remi_ui64(191084152064409600, 18446744073709551615)), 191084152064409600);
-assert_eq!(call!(remi_ui64(18446744073709551614, 16990600415051759616)), 1456143658657791998);
-assert_eq!(call!(remi_ui64(18446744073709551615, 16990600415051759616)), 1456143658657791999);
-assert_eq!(call!(remi_ui64(16990600415051759616, 11015955194427482112)), 5974645220624277504);
-assert_eq!(call!(remi_ui64(18446744073709551614, 11015955194427482112)), 7430788879282069502);
-assert_eq!(call!(remi_ui64(18446744073709551615, 11015955194427482112)), 7430788879282069503);
-assert_eq!(call!(remi_ui64(11015955194427482112, 16990600415051759616)), 11015955194427482112);
-assert_eq!(call!(remi_ui64(11015955194427482112, 18446744073709551614)), 11015955194427482112);
-assert_eq!(call!(remi_ui64(11015955194427482112, 18446744073709551615)), 11015955194427482112);
-assert_eq!(call!(remi_ui64(16990600415051759616, 18446744073709551614)), 16990600415051759616);
-assert_eq!(call!(remi_ui64(16990600415051759616, 18446744073709551615)), 16990600415051759616);
-assert_eq!(call!(remi_ui64(18446744073709551614, 18446744073709551615)), 18446744073709551614);
-assert_eq!(call!(remi_ui8(0, 1)), 0);
-assert_eq!(call!(remi_ui8(0, 2)), 0);
-assert_eq!(call!(remi_ui8(0, 3)), 0);
-assert_eq!(call!(remi_ui8(0, 4)), 0);
-assert_eq!(call!(remi_ui8(0, 72)), 0);
-assert_eq!(call!(remi_ui8(0, 100)), 0);
-assert_eq!(call!(remi_ui8(0, 162)), 0);
-assert_eq!(call!(remi_ui8(0, 254)), 0);
-assert_eq!(call!(remi_ui8(0, 255)), 0);
-assert_eq!(call!(remi_ui8(1, 1)), 0);
-assert_eq!(call!(remi_ui8(2, 1)), 0);
-assert_eq!(call!(remi_ui8(2, 2)), 0);
-assert_eq!(call!(remi_ui8(3, 1)), 0);
-assert_eq!(call!(remi_ui8(3, 3)), 0);
-assert_eq!(call!(remi_ui8(4, 1)), 0);
-assert_eq!(call!(remi_ui8(4, 2)), 0);
-assert_eq!(call!(remi_ui8(4, 4)), 0);
-assert_eq!(call!(remi_ui8(72, 1)), 0);
-assert_eq!(call!(remi_ui8(72, 2)), 0);
-assert_eq!(call!(remi_ui8(72, 3)), 0);
-assert_eq!(call!(remi_ui8(72, 4)), 0);
-assert_eq!(call!(remi_ui8(72, 72)), 0);
-assert_eq!(call!(remi_ui8(100, 1)), 0);
-assert_eq!(call!(remi_ui8(100, 2)), 0);
-assert_eq!(call!(remi_ui8(100, 4)), 0);
-assert_eq!(call!(remi_ui8(100, 100)), 0);
-assert_eq!(call!(remi_ui8(162, 1)), 0);
-assert_eq!(call!(remi_ui8(162, 2)), 0);
-assert_eq!(call!(remi_ui8(162, 3)), 0);
-assert_eq!(call!(remi_ui8(162, 162)), 0);
-assert_eq!(call!(remi_ui8(254, 1)), 0);
-assert_eq!(call!(remi_ui8(254, 2)), 0);
-assert_eq!(call!(remi_ui8(254, 254)), 0);
-assert_eq!(call!(remi_ui8(255, 1)), 0);
-assert_eq!(call!(remi_ui8(255, 3)), 0);
-assert_eq!(call!(remi_ui8(255, 255)), 0);
-assert_eq!(call!(remi_ui8(1, 2)), 1);
-assert_eq!(call!(remi_ui8(1, 3)), 1);
-assert_eq!(call!(remi_ui8(1, 4)), 1);
-assert_eq!(call!(remi_ui8(1, 72)), 1);
-assert_eq!(call!(remi_ui8(1, 100)), 1);
-assert_eq!(call!(remi_ui8(1, 162)), 1);
-assert_eq!(call!(remi_ui8(1, 254)), 1);
-assert_eq!(call!(remi_ui8(1, 255)), 1);
-assert_eq!(call!(remi_ui8(3, 2)), 1);
-assert_eq!(call!(remi_ui8(4, 3)), 1);
-assert_eq!(call!(remi_ui8(100, 3)), 1);
-assert_eq!(call!(remi_ui8(255, 2)), 1);
-assert_eq!(call!(remi_ui8(255, 254)), 1);
-assert_eq!(call!(remi_ui8(2, 3)), 2);
-assert_eq!(call!(remi_ui8(2, 4)), 2);
-assert_eq!(call!(remi_ui8(2, 72)), 2);
-assert_eq!(call!(remi_ui8(2, 100)), 2);
-assert_eq!(call!(remi_ui8(2, 162)), 2);
-assert_eq!(call!(remi_ui8(2, 254)), 2);
-assert_eq!(call!(remi_ui8(2, 255)), 2);
-assert_eq!(call!(remi_ui8(162, 4)), 2);
-assert_eq!(call!(remi_ui8(254, 3)), 2);
-assert_eq!(call!(remi_ui8(254, 4)), 2);
-assert_eq!(call!(remi_ui8(3, 4)), 3);
-assert_eq!(call!(remi_ui8(3, 72)), 3);
-assert_eq!(call!(remi_ui8(3, 100)), 3);
-assert_eq!(call!(remi_ui8(3, 162)), 3);
-assert_eq!(call!(remi_ui8(3, 254)), 3);
-assert_eq!(call!(remi_ui8(3, 255)), 3);
-assert_eq!(call!(remi_ui8(255, 4)), 3);
-assert_eq!(call!(remi_ui8(4, 72)), 4);
-assert_eq!(call!(remi_ui8(4, 100)), 4);
-assert_eq!(call!(remi_ui8(4, 162)), 4);
-assert_eq!(call!(remi_ui8(4, 254)), 4);
-assert_eq!(call!(remi_ui8(4, 255)), 4);
-assert_eq!(call!(remi_ui8(162, 72)), 18);
-assert_eq!(call!(remi_ui8(100, 72)), 28);
-assert_eq!(call!(remi_ui8(254, 72)), 38);
-assert_eq!(call!(remi_ui8(255, 72)), 39);
-assert_eq!(call!(remi_ui8(254, 100)), 54);
-assert_eq!(call!(remi_ui8(255, 100)), 55);
-assert_eq!(call!(remi_ui8(162, 100)), 62);
-assert_eq!(call!(remi_ui8(72, 100)), 72);
-assert_eq!(call!(remi_ui8(72, 162)), 72);
-assert_eq!(call!(remi_ui8(72, 254)), 72);
-assert_eq!(call!(remi_ui8(72, 255)), 72);
-assert_eq!(call!(remi_ui8(254, 162)), 92);
-assert_eq!(call!(remi_ui8(255, 162)), 93);
-assert_eq!(call!(remi_ui8(100, 162)), 100);
-assert_eq!(call!(remi_ui8(100, 254)), 100);
-assert_eq!(call!(remi_ui8(100, 255)), 100);
-assert_eq!(call!(remi_ui8(162, 254)), 162);
-assert_eq!(call!(remi_ui8(162, 255)), 162);
-assert_eq!(call!(remi_ui8(254, 255)), 254);
-assert_eq!(call!(subi_si16(-32768, 0)), -32768);
-assert_eq!(call!(subi_si16(-32767, 1)), -32768);
-assert_eq!(call!(subi_si16(-32767, 0)), -32767);
-assert_eq!(call!(subi_si16(0, 32767)), -32767);
-assert_eq!(call!(subi_si16(0, 32766)), -32766);
-assert_eq!(call!(subi_si16(1, 32767)), -32766);
-assert_eq!(call!(subi_si16(1, 32766)), -32765);
-assert_eq!(call!(subi_si16(2, 32767)), -32765);
-assert_eq!(call!(subi_si16(2, 32766)), -32764);
-assert_eq!(call!(subi_si16(3, 32767)), -32764);
-assert_eq!(call!(subi_si16(3, 32766)), -32763);
-assert_eq!(call!(subi_si16(4, 32767)), -32763);
-assert_eq!(call!(subi_si16(4, 32766)), -32762);
-assert_eq!(call!(subi_si16(-32547, 4)), -32551);
-assert_eq!(call!(subi_si16(-32547, 3)), -32550);
-assert_eq!(call!(subi_si16(-32547, 2)), -32549);
-assert_eq!(call!(subi_si16(-32547, 1)), -32548);
-assert_eq!(call!(subi_si16(-32547, 0)), -32547);
-assert_eq!(call!(subi_si16(10486, 32767)), -22281);
-assert_eq!(call!(subi_si16(10486, 32766)), -22280);
-assert_eq!(call!(subi_si16(0, 16514)), -16514);
-assert_eq!(call!(subi_si16(1, 16514)), -16513);
-assert_eq!(call!(subi_si16(2, 16514)), -16512);
-assert_eq!(call!(subi_si16(3, 16514)), -16511);
-assert_eq!(call!(subi_si16(4, 16514)), -16510);
-assert_eq!(call!(subi_si16(16514, 32767)), -16253);
-assert_eq!(call!(subi_si16(16514, 32766)), -16252);
-assert_eq!(call!(subi_si16(0, 10486)), -10486);
-assert_eq!(call!(subi_si16(1, 10486)), -10485);
-assert_eq!(call!(subi_si16(2, 10486)), -10484);
-assert_eq!(call!(subi_si16(3, 10486)), -10483);
-assert_eq!(call!(subi_si16(4, 10486)), -10482);
-assert_eq!(call!(subi_si16(10486, 16514)), -6028);
-assert_eq!(call!(subi_si16(-32768, -32547)), -221);
-assert_eq!(call!(subi_si16(-32767, -32547)), -220);
-assert_eq!(call!(subi_si16(0, 4)), -4);
-assert_eq!(call!(subi_si16(0, 3)), -3);
-assert_eq!(call!(subi_si16(1, 4)), -3);
-assert_eq!(call!(subi_si16(0, 2)), -2);
-assert_eq!(call!(subi_si16(1, 3)), -2);
-assert_eq!(call!(subi_si16(2, 4)), -2);
-assert_eq!(call!(subi_si16(-32768, -32767)), -1);
-assert_eq!(call!(subi_si16(0, 1)), -1);
-assert_eq!(call!(subi_si16(1, 2)), -1);
-assert_eq!(call!(subi_si16(2, 3)), -1);
-assert_eq!(call!(subi_si16(3, 4)), -1);
-assert_eq!(call!(subi_si16(32766, 32767)), -1);
-assert_eq!(call!(subi_si16(-32768, -32768)), 0);
-assert_eq!(call!(subi_si16(-32767, -32767)), 0);
-assert_eq!(call!(subi_si16(-32547, -32547)), 0);
-assert_eq!(call!(subi_si16(0, 0)), 0);
-assert_eq!(call!(subi_si16(1, 1)), 0);
-assert_eq!(call!(subi_si16(2, 2)), 0);
-assert_eq!(call!(subi_si16(3, 3)), 0);
-assert_eq!(call!(subi_si16(4, 4)), 0);
-assert_eq!(call!(subi_si16(10486, 10486)), 0);
-assert_eq!(call!(subi_si16(16514, 16514)), 0);
-assert_eq!(call!(subi_si16(32766, 32766)), 0);
-assert_eq!(call!(subi_si16(32767, 32767)), 0);
-assert_eq!(call!(subi_si16(-32767, -32768)), 1);
-assert_eq!(call!(subi_si16(1, 0)), 1);
-assert_eq!(call!(subi_si16(2, 1)), 1);
-assert_eq!(call!(subi_si16(3, 2)), 1);
-assert_eq!(call!(subi_si16(4, 3)), 1);
-assert_eq!(call!(subi_si16(32767, 32766)), 1);
-assert_eq!(call!(subi_si16(2, 0)), 2);
-assert_eq!(call!(subi_si16(3, 1)), 2);
-assert_eq!(call!(subi_si16(4, 2)), 2);
-assert_eq!(call!(subi_si16(3, 0)), 3);
-assert_eq!(call!(subi_si16(4, 1)), 3);
-assert_eq!(call!(subi_si16(4, 0)), 4);
-assert_eq!(call!(subi_si16(-32547, -32767)), 220);
-assert_eq!(call!(subi_si16(-32547, -32768)), 221);
-assert_eq!(call!(subi_si16(16514, 10486)), 6028);
-assert_eq!(call!(subi_si16(10486, 4)), 10482);
-assert_eq!(call!(subi_si16(10486, 3)), 10483);
-assert_eq!(call!(subi_si16(10486, 2)), 10484);
-assert_eq!(call!(subi_si16(10486, 1)), 10485);
-assert_eq!(call!(subi_si16(10486, 0)), 10486);
-assert_eq!(call!(subi_si16(32766, 16514)), 16252);
-assert_eq!(call!(subi_si16(32767, 16514)), 16253);
-assert_eq!(call!(subi_si16(16514, 4)), 16510);
-assert_eq!(call!(subi_si16(16514, 3)), 16511);
-assert_eq!(call!(subi_si16(16514, 2)), 16512);
-assert_eq!(call!(subi_si16(16514, 1)), 16513);
-assert_eq!(call!(subi_si16(16514, 0)), 16514);
-assert_eq!(call!(subi_si16(32766, 10486)), 22280);
-assert_eq!(call!(subi_si16(32767, 10486)), 22281);
-assert_eq!(call!(subi_si16(0, -32547)), 32547);
-assert_eq!(call!(subi_si16(1, -32547)), 32548);
-assert_eq!(call!(subi_si16(2, -32547)), 32549);
-assert_eq!(call!(subi_si16(3, -32547)), 32550);
-assert_eq!(call!(subi_si16(4, -32547)), 32551);
-assert_eq!(call!(subi_si16(32766, 4)), 32762);
-assert_eq!(call!(subi_si16(32766, 3)), 32763);
-assert_eq!(call!(subi_si16(32767, 4)), 32763);
-assert_eq!(call!(subi_si16(32766, 2)), 32764);
-assert_eq!(call!(subi_si16(32767, 3)), 32764);
-assert_eq!(call!(subi_si16(32766, 1)), 32765);
-assert_eq!(call!(subi_si16(32767, 2)), 32765);
-assert_eq!(call!(subi_si16(32766, 0)), 32766);
-assert_eq!(call!(subi_si16(32767, 1)), 32766);
-assert_eq!(call!(subi_si16(0, -32767)), 32767);
-assert_eq!(call!(subi_si16(32767, 0)), 32767);
-assert_eq!(call!(subi_si32(-2147483648, 0)), -2147483648);
-assert_eq!(call!(subi_si32(-2147483647, 1)), -2147483648);
-assert_eq!(call!(subi_si32(-2147483647, 0)), -2147483647);
-assert_eq!(call!(subi_si32(0, 2147483647)), -2147483647);
-assert_eq!(call!(subi_si32(0, 2147483646)), -2147483646);
-assert_eq!(call!(subi_si32(1, 2147483647)), -2147483646);
-assert_eq!(call!(subi_si32(1, 2147483646)), -2147483645);
-assert_eq!(call!(subi_si32(2, 2147483647)), -2147483645);
-assert_eq!(call!(subi_si32(2, 2147483646)), -2147483644);
-assert_eq!(call!(subi_si32(3, 2147483647)), -2147483644);
-assert_eq!(call!(subi_si32(3, 2147483646)), -2147483643);
-assert_eq!(call!(subi_si32(4, 2147483647)), -2147483643);
-assert_eq!(call!(subi_si32(4, 2147483646)), -2147483642);
-assert_eq!(call!(subi_si32(-1713183800, 4)), -1713183804);
-assert_eq!(call!(subi_si32(-1713183800, 3)), -1713183803);
-assert_eq!(call!(subi_si32(-1713183800, 2)), -1713183802);
-assert_eq!(call!(subi_si32(-1713183800, 1)), -1713183801);
-assert_eq!(call!(subi_si32(-1713183800, 0)), -1713183800);
-assert_eq!(call!(subi_si32(-1252582164, 4)), -1252582168);
-assert_eq!(call!(subi_si32(-1252582164, 3)), -1252582167);
-assert_eq!(call!(subi_si32(-1252582164, 2)), -1252582166);
-assert_eq!(call!(subi_si32(-1252582164, 1)), -1252582165);
-assert_eq!(call!(subi_si32(-1252582164, 0)), -1252582164);
-assert_eq!(call!(subi_si32(-2147483648, -1035405763)), -1112077885);
-assert_eq!(call!(subi_si32(-2147483647, -1035405763)), -1112077884);
-assert_eq!(call!(subi_si32(-1035405763, 4)), -1035405767);
-assert_eq!(call!(subi_si32(-1035405763, 3)), -1035405766);
-assert_eq!(call!(subi_si32(-1035405763, 2)), -1035405765);
-assert_eq!(call!(subi_si32(-1035405763, 1)), -1035405764);
-assert_eq!(call!(subi_si32(-1035405763, 0)), -1035405763);
-assert_eq!(call!(subi_si32(-2147483648, -1252582164)), -894901484);
-assert_eq!(call!(subi_si32(-2147483647, -1252582164)), -894901483);
-assert_eq!(call!(subi_si32(-1713183800, -1035405763)), -677778037);
-assert_eq!(call!(subi_si32(-1713183800, -1252582164)), -460601636);
-assert_eq!(call!(subi_si32(-2147483648, -1713183800)), -434299848);
-assert_eq!(call!(subi_si32(-2147483647, -1713183800)), -434299847);
-assert_eq!(call!(subi_si32(-1252582164, -1035405763)), -217176401);
-assert_eq!(call!(subi_si32(0, 4)), -4);
-assert_eq!(call!(subi_si32(0, 3)), -3);
-assert_eq!(call!(subi_si32(1, 4)), -3);
-assert_eq!(call!(subi_si32(0, 2)), -2);
-assert_eq!(call!(subi_si32(1, 3)), -2);
-assert_eq!(call!(subi_si32(2, 4)), -2);
-assert_eq!(call!(subi_si32(-2147483648, -2147483647)), -1);
-assert_eq!(call!(subi_si32(0, 1)), -1);
-assert_eq!(call!(subi_si32(1, 2)), -1);
-assert_eq!(call!(subi_si32(2, 3)), -1);
-assert_eq!(call!(subi_si32(3, 4)), -1);
-assert_eq!(call!(subi_si32(2147483646, 2147483647)), -1);
-assert_eq!(call!(subi_si32(-2147483648, -2147483648)), 0);
-assert_eq!(call!(subi_si32(-2147483647, -2147483647)), 0);
-assert_eq!(call!(subi_si32(-1713183800, -1713183800)), 0);
-assert_eq!(call!(subi_si32(-1252582164, -1252582164)), 0);
-assert_eq!(call!(subi_si32(-1035405763, -1035405763)), 0);
-assert_eq!(call!(subi_si32(0, 0)), 0);
-assert_eq!(call!(subi_si32(1, 1)), 0);
-assert_eq!(call!(subi_si32(2, 2)), 0);
-assert_eq!(call!(subi_si32(3, 3)), 0);
-assert_eq!(call!(subi_si32(4, 4)), 0);
-assert_eq!(call!(subi_si32(2147483646, 2147483646)), 0);
-assert_eq!(call!(subi_si32(2147483647, 2147483647)), 0);
-assert_eq!(call!(subi_si32(-2147483647, -2147483648)), 1);
-assert_eq!(call!(subi_si32(1, 0)), 1);
-assert_eq!(call!(subi_si32(2, 1)), 1);
-assert_eq!(call!(subi_si32(3, 2)), 1);
-assert_eq!(call!(subi_si32(4, 3)), 1);
-assert_eq!(call!(subi_si32(2147483647, 2147483646)), 1);
-assert_eq!(call!(subi_si32(2, 0)), 2);
-assert_eq!(call!(subi_si32(3, 1)), 2);
-assert_eq!(call!(subi_si32(4, 2)), 2);
-assert_eq!(call!(subi_si32(3, 0)), 3);
-assert_eq!(call!(subi_si32(4, 1)), 3);
-assert_eq!(call!(subi_si32(4, 0)), 4);
-assert_eq!(call!(subi_si32(-1035405763, -1252582164)), 217176401);
-assert_eq!(call!(subi_si32(-1713183800, -2147483647)), 434299847);
-assert_eq!(call!(subi_si32(-1713183800, -2147483648)), 434299848);
-assert_eq!(call!(subi_si32(-1252582164, -1713183800)), 460601636);
-assert_eq!(call!(subi_si32(-1035405763, -1713183800)), 677778037);
-assert_eq!(call!(subi_si32(-1252582164, -2147483647)), 894901483);
-assert_eq!(call!(subi_si32(-1252582164, -2147483648)), 894901484);
-assert_eq!(call!(subi_si32(0, -1035405763)), 1035405763);
-assert_eq!(call!(subi_si32(1, -1035405763)), 1035405764);
-assert_eq!(call!(subi_si32(2, -1035405763)), 1035405765);
-assert_eq!(call!(subi_si32(3, -1035405763)), 1035405766);
-assert_eq!(call!(subi_si32(4, -1035405763)), 1035405767);
-assert_eq!(call!(subi_si32(-1035405763, -2147483647)), 1112077884);
-assert_eq!(call!(subi_si32(-1035405763, -2147483648)), 1112077885);
-assert_eq!(call!(subi_si32(0, -1252582164)), 1252582164);
-assert_eq!(call!(subi_si32(1, -1252582164)), 1252582165);
-assert_eq!(call!(subi_si32(2, -1252582164)), 1252582166);
-assert_eq!(call!(subi_si32(3, -1252582164)), 1252582167);
-assert_eq!(call!(subi_si32(4, -1252582164)), 1252582168);
-assert_eq!(call!(subi_si32(0, -1713183800)), 1713183800);
-assert_eq!(call!(subi_si32(1, -1713183800)), 1713183801);
-assert_eq!(call!(subi_si32(2, -1713183800)), 1713183802);
-assert_eq!(call!(subi_si32(3, -1713183800)), 1713183803);
-assert_eq!(call!(subi_si32(4, -1713183800)), 1713183804);
-assert_eq!(call!(subi_si32(2147483646, 4)), 2147483642);
-assert_eq!(call!(subi_si32(2147483646, 3)), 2147483643);
-assert_eq!(call!(subi_si32(2147483647, 4)), 2147483643);
-assert_eq!(call!(subi_si32(2147483646, 2)), 2147483644);
-assert_eq!(call!(subi_si32(2147483647, 3)), 2147483644);
-assert_eq!(call!(subi_si32(2147483646, 1)), 2147483645);
-assert_eq!(call!(subi_si32(2147483647, 2)), 2147483645);
-assert_eq!(call!(subi_si32(2147483646, 0)), 2147483646);
-assert_eq!(call!(subi_si32(2147483647, 1)), 2147483646);
-assert_eq!(call!(subi_si32(0, -2147483647)), 2147483647);
-assert_eq!(call!(subi_si32(2147483647, 0)), 2147483647);
-assert_eq!(call!(subi_si64(-9223372036854775808, 0)), -9223372036854775808);
-assert_eq!(call!(subi_si64(-9223372036854775807, 1)), -9223372036854775808);
-assert_eq!(call!(subi_si64(-9223372036854775807, 0)), -9223372036854775807);
-assert_eq!(call!(subi_si64(0, 9223372036854775807)), -9223372036854775807);
-assert_eq!(call!(subi_si64(0, 9223372036854775806)), -9223372036854775806);
-assert_eq!(call!(subi_si64(1, 9223372036854775807)), -9223372036854775806);
-assert_eq!(call!(subi_si64(1, 9223372036854775806)), -9223372036854775805);
-assert_eq!(call!(subi_si64(2, 9223372036854775807)), -9223372036854775805);
-assert_eq!(call!(subi_si64(2, 9223372036854775806)), -9223372036854775804);
-assert_eq!(call!(subi_si64(3, 9223372036854775807)), -9223372036854775804);
-assert_eq!(call!(subi_si64(3, 9223372036854775806)), -9223372036854775803);
-assert_eq!(call!(subi_si64(4, 9223372036854775807)), -9223372036854775803);
-assert_eq!(call!(subi_si64(4, 9223372036854775806)), -9223372036854775802);
-assert_eq!(call!(subi_si64(-9223372036854775808, -1328271339354574848)), -7895100697500200960);
-assert_eq!(call!(subi_si64(-9223372036854775807, -1328271339354574848)), -7895100697500200959);
-assert_eq!(call!(subi_si64(-9223372036854775808, -1741927215160008704)), -7481444821694767104);
-assert_eq!(call!(subi_si64(-9223372036854775807, -1741927215160008704)), -7481444821694767103);
-assert_eq!(call!(subi_si64(-1741927215160008704, 5577148965131116544)), -7319076180291125248);
-assert_eq!(call!(subi_si64(-1328271339354574848, 5577148965131116544)), -6905420304485691392);
-assert_eq!(call!(subi_si64(0, 5577148965131116544)), -5577148965131116544);
-assert_eq!(call!(subi_si64(1, 5577148965131116544)), -5577148965131116543);
-assert_eq!(call!(subi_si64(2, 5577148965131116544)), -5577148965131116542);
-assert_eq!(call!(subi_si64(3, 5577148965131116544)), -5577148965131116541);
-assert_eq!(call!(subi_si64(4, 5577148965131116544)), -5577148965131116540);
-assert_eq!(call!(subi_si64(5577148965131116544, 9223372036854775807)), -3646223071723659263);
-assert_eq!(call!(subi_si64(5577148965131116544, 9223372036854775806)), -3646223071723659262);
-assert_eq!(call!(subi_si64(-1741927215160008704, 4)), -1741927215160008708);
-assert_eq!(call!(subi_si64(-1741927215160008704, 3)), -1741927215160008707);
-assert_eq!(call!(subi_si64(-1741927215160008704, 2)), -1741927215160008706);
-assert_eq!(call!(subi_si64(-1741927215160008704, 1)), -1741927215160008705);
-assert_eq!(call!(subi_si64(-1741927215160008704, 0)), -1741927215160008704);
-assert_eq!(call!(subi_si64(-1328271339354574848, 4)), -1328271339354574852);
-assert_eq!(call!(subi_si64(-1328271339354574848, 3)), -1328271339354574851);
-assert_eq!(call!(subi_si64(-1328271339354574848, 2)), -1328271339354574850);
-assert_eq!(call!(subi_si64(-1328271339354574848, 1)), -1328271339354574849);
-assert_eq!(call!(subi_si64(-1328271339354574848, 0)), -1328271339354574848);
-assert_eq!(call!(subi_si64(-1741927215160008704, -1328271339354574848)), -413655875805433856);
-assert_eq!(call!(subi_si64(0, 4)), -4);
-assert_eq!(call!(subi_si64(0, 3)), -3);
-assert_eq!(call!(subi_si64(1, 4)), -3);
-assert_eq!(call!(subi_si64(0, 2)), -2);
-assert_eq!(call!(subi_si64(1, 3)), -2);
-assert_eq!(call!(subi_si64(2, 4)), -2);
-assert_eq!(call!(subi_si64(-9223372036854775808, -9223372036854775807)), -1);
-assert_eq!(call!(subi_si64(0, 1)), -1);
-assert_eq!(call!(subi_si64(1, 2)), -1);
-assert_eq!(call!(subi_si64(2, 3)), -1);
-assert_eq!(call!(subi_si64(3, 4)), -1);
-assert_eq!(call!(subi_si64(9223372036854775806, 9223372036854775807)), -1);
-assert_eq!(call!(subi_si64(-9223372036854775808, -9223372036854775808)), 0);
-assert_eq!(call!(subi_si64(-9223372036854775807, -9223372036854775807)), 0);
-assert_eq!(call!(subi_si64(-1741927215160008704, -1741927215160008704)), 0);
-assert_eq!(call!(subi_si64(-1328271339354574848, -1328271339354574848)), 0);
-assert_eq!(call!(subi_si64(0, 0)), 0);
-assert_eq!(call!(subi_si64(1, 1)), 0);
-assert_eq!(call!(subi_si64(2, 2)), 0);
-assert_eq!(call!(subi_si64(3, 3)), 0);
-assert_eq!(call!(subi_si64(4, 4)), 0);
-assert_eq!(call!(subi_si64(5577148965131116544, 5577148965131116544)), 0);
-assert_eq!(call!(subi_si64(9223372036854775806, 9223372036854775806)), 0);
-assert_eq!(call!(subi_si64(9223372036854775807, 9223372036854775807)), 0);
-assert_eq!(call!(subi_si64(-9223372036854775807, -9223372036854775808)), 1);
-assert_eq!(call!(subi_si64(1, 0)), 1);
-assert_eq!(call!(subi_si64(2, 1)), 1);
-assert_eq!(call!(subi_si64(3, 2)), 1);
-assert_eq!(call!(subi_si64(4, 3)), 1);
-assert_eq!(call!(subi_si64(9223372036854775807, 9223372036854775806)), 1);
-assert_eq!(call!(subi_si64(2, 0)), 2);
-assert_eq!(call!(subi_si64(3, 1)), 2);
-assert_eq!(call!(subi_si64(4, 2)), 2);
-assert_eq!(call!(subi_si64(3, 0)), 3);
-assert_eq!(call!(subi_si64(4, 1)), 3);
-assert_eq!(call!(subi_si64(4, 0)), 4);
-assert_eq!(call!(subi_si64(-1328271339354574848, -1741927215160008704)), 413655875805433856);
-assert_eq!(call!(subi_si64(0, -1328271339354574848)), 1328271339354574848);
-assert_eq!(call!(subi_si64(1, -1328271339354574848)), 1328271339354574849);
-assert_eq!(call!(subi_si64(2, -1328271339354574848)), 1328271339354574850);
-assert_eq!(call!(subi_si64(3, -1328271339354574848)), 1328271339354574851);
-assert_eq!(call!(subi_si64(4, -1328271339354574848)), 1328271339354574852);
-assert_eq!(call!(subi_si64(0, -1741927215160008704)), 1741927215160008704);
-assert_eq!(call!(subi_si64(1, -1741927215160008704)), 1741927215160008705);
-assert_eq!(call!(subi_si64(2, -1741927215160008704)), 1741927215160008706);
-assert_eq!(call!(subi_si64(3, -1741927215160008704)), 1741927215160008707);
-assert_eq!(call!(subi_si64(4, -1741927215160008704)), 1741927215160008708);
-assert_eq!(call!(subi_si64(9223372036854775806, 5577148965131116544)), 3646223071723659262);
-assert_eq!(call!(subi_si64(9223372036854775807, 5577148965131116544)), 3646223071723659263);
-assert_eq!(call!(subi_si64(5577148965131116544, 4)), 5577148965131116540);
-assert_eq!(call!(subi_si64(5577148965131116544, 3)), 5577148965131116541);
-assert_eq!(call!(subi_si64(5577148965131116544, 2)), 5577148965131116542);
-assert_eq!(call!(subi_si64(5577148965131116544, 1)), 5577148965131116543);
-assert_eq!(call!(subi_si64(5577148965131116544, 0)), 5577148965131116544);
-assert_eq!(call!(subi_si64(5577148965131116544, -1328271339354574848)), 6905420304485691392);
-assert_eq!(call!(subi_si64(5577148965131116544, -1741927215160008704)), 7319076180291125248);
-assert_eq!(call!(subi_si64(-1741927215160008704, -9223372036854775807)), 7481444821694767103);
-assert_eq!(call!(subi_si64(-1741927215160008704, -9223372036854775808)), 7481444821694767104);
-assert_eq!(call!(subi_si64(-1328271339354574848, -9223372036854775807)), 7895100697500200959);
-assert_eq!(call!(subi_si64(-1328271339354574848, -9223372036854775808)), 7895100697500200960);
-assert_eq!(call!(subi_si64(9223372036854775806, 4)), 9223372036854775802);
-assert_eq!(call!(subi_si64(9223372036854775806, 3)), 9223372036854775803);
-assert_eq!(call!(subi_si64(9223372036854775807, 4)), 9223372036854775803);
-assert_eq!(call!(subi_si64(9223372036854775806, 2)), 9223372036854775804);
-assert_eq!(call!(subi_si64(9223372036854775807, 3)), 9223372036854775804);
-assert_eq!(call!(subi_si64(9223372036854775806, 1)), 9223372036854775805);
-assert_eq!(call!(subi_si64(9223372036854775807, 2)), 9223372036854775805);
-assert_eq!(call!(subi_si64(9223372036854775806, 0)), 9223372036854775806);
-assert_eq!(call!(subi_si64(9223372036854775807, 1)), 9223372036854775806);
-assert_eq!(call!(subi_si64(0, -9223372036854775807)), 9223372036854775807);
-assert_eq!(call!(subi_si64(9223372036854775807, 0)), 9223372036854775807);
-assert_eq!(call!(subi_si8(-128, 0)), -128);
-assert_eq!(call!(subi_si8(-127, 1)), -128);
-assert_eq!(call!(subi_si8(-127, 0)), -127);
-assert_eq!(call!(subi_si8(0, 127)), -127);
-assert_eq!(call!(subi_si8(0, 126)), -126);
-assert_eq!(call!(subi_si8(1, 127)), -126);
-assert_eq!(call!(subi_si8(1, 126)), -125);
-assert_eq!(call!(subi_si8(2, 127)), -125);
-assert_eq!(call!(subi_si8(2, 126)), -124);
-assert_eq!(call!(subi_si8(3, 127)), -124);
-assert_eq!(call!(subi_si8(3, 126)), -123);
-assert_eq!(call!(subi_si8(4, 127)), -123);
-assert_eq!(call!(subi_si8(4, 126)), -122);
-assert_eq!(call!(subi_si8(16, 127)), -111);
-assert_eq!(call!(subi_si8(16, 126)), -110);
-assert_eq!(call!(subi_si8(0, 16)), -16);
-assert_eq!(call!(subi_si8(1, 16)), -15);
-assert_eq!(call!(subi_si8(2, 16)), -14);
-assert_eq!(call!(subi_si8(3, 16)), -13);
-assert_eq!(call!(subi_si8(4, 16)), -12);
-assert_eq!(call!(subi_si8(0, 4)), -4);
-assert_eq!(call!(subi_si8(0, 3)), -3);
-assert_eq!(call!(subi_si8(1, 4)), -3);
-assert_eq!(call!(subi_si8(0, 2)), -2);
-assert_eq!(call!(subi_si8(1, 3)), -2);
-assert_eq!(call!(subi_si8(2, 4)), -2);
-assert_eq!(call!(subi_si8(-128, -127)), -1);
-assert_eq!(call!(subi_si8(0, 1)), -1);
-assert_eq!(call!(subi_si8(1, 2)), -1);
-assert_eq!(call!(subi_si8(2, 3)), -1);
-assert_eq!(call!(subi_si8(3, 4)), -1);
-assert_eq!(call!(subi_si8(126, 127)), -1);
-assert_eq!(call!(subi_si8(-128, -128)), 0);
-assert_eq!(call!(subi_si8(-127, -127)), 0);
-assert_eq!(call!(subi_si8(0, 0)), 0);
-assert_eq!(call!(subi_si8(1, 1)), 0);
-assert_eq!(call!(subi_si8(2, 2)), 0);
-assert_eq!(call!(subi_si8(3, 3)), 0);
-assert_eq!(call!(subi_si8(4, 4)), 0);
-assert_eq!(call!(subi_si8(16, 16)), 0);
-assert_eq!(call!(subi_si8(126, 126)), 0);
-assert_eq!(call!(subi_si8(127, 127)), 0);
-assert_eq!(call!(subi_si8(-127, -128)), 1);
-assert_eq!(call!(subi_si8(1, 0)), 1);
-assert_eq!(call!(subi_si8(2, 1)), 1);
-assert_eq!(call!(subi_si8(3, 2)), 1);
-assert_eq!(call!(subi_si8(4, 3)), 1);
-assert_eq!(call!(subi_si8(127, 126)), 1);
-assert_eq!(call!(subi_si8(2, 0)), 2);
-assert_eq!(call!(subi_si8(3, 1)), 2);
-assert_eq!(call!(subi_si8(4, 2)), 2);
-assert_eq!(call!(subi_si8(3, 0)), 3);
-assert_eq!(call!(subi_si8(4, 1)), 3);
-assert_eq!(call!(subi_si8(4, 0)), 4);
-assert_eq!(call!(subi_si8(16, 4)), 12);
-assert_eq!(call!(subi_si8(16, 3)), 13);
-assert_eq!(call!(subi_si8(16, 2)), 14);
-assert_eq!(call!(subi_si8(16, 1)), 15);
-assert_eq!(call!(subi_si8(16, 0)), 16);
-assert_eq!(call!(subi_si8(126, 16)), 110);
-assert_eq!(call!(subi_si8(127, 16)), 111);
-assert_eq!(call!(subi_si8(126, 4)), 122);
-assert_eq!(call!(subi_si8(126, 3)), 123);
-assert_eq!(call!(subi_si8(127, 4)), 123);
-assert_eq!(call!(subi_si8(126, 2)), 124);
-assert_eq!(call!(subi_si8(127, 3)), 124);
-assert_eq!(call!(subi_si8(126, 1)), 125);
-assert_eq!(call!(subi_si8(127, 2)), 125);
-assert_eq!(call!(subi_si8(126, 0)), 126);
-assert_eq!(call!(subi_si8(127, 1)), 126);
-assert_eq!(call!(subi_si8(0, -127)), 127);
-assert_eq!(call!(subi_si8(127, 0)), 127);
-assert_eq!(call!(subi_ui16(0, 0)), 0);
-assert_eq!(call!(subi_ui16(1, 1)), 0);
-assert_eq!(call!(subi_ui16(2, 2)), 0);
-assert_eq!(call!(subi_ui16(3, 3)), 0);
-assert_eq!(call!(subi_ui16(4, 4)), 0);
-assert_eq!(call!(subi_ui16(1717, 1717)), 0);
-assert_eq!(call!(subi_ui16(17988, 17988)), 0);
-assert_eq!(call!(subi_ui16(65096, 65096)), 0);
-assert_eq!(call!(subi_ui16(65534, 65534)), 0);
-assert_eq!(call!(subi_ui16(65535, 65535)), 0);
-assert_eq!(call!(subi_ui16(1, 0)), 1);
-assert_eq!(call!(subi_ui16(2, 1)), 1);
-assert_eq!(call!(subi_ui16(3, 2)), 1);
-assert_eq!(call!(subi_ui16(4, 3)), 1);
-assert_eq!(call!(subi_ui16(65535, 65534)), 1);
-assert_eq!(call!(subi_ui16(2, 0)), 2);
-assert_eq!(call!(subi_ui16(3, 1)), 2);
-assert_eq!(call!(subi_ui16(4, 2)), 2);
-assert_eq!(call!(subi_ui16(3, 0)), 3);
-assert_eq!(call!(subi_ui16(4, 1)), 3);
-assert_eq!(call!(subi_ui16(4, 0)), 4);
-assert_eq!(call!(subi_ui16(65534, 65096)), 438);
-assert_eq!(call!(subi_ui16(65535, 65096)), 439);
-assert_eq!(call!(subi_ui16(1717, 4)), 1713);
-assert_eq!(call!(subi_ui16(1717, 3)), 1714);
-assert_eq!(call!(subi_ui16(1717, 2)), 1715);
-assert_eq!(call!(subi_ui16(1717, 1)), 1716);
-assert_eq!(call!(subi_ui16(1717, 0)), 1717);
-assert_eq!(call!(subi_ui16(17988, 1717)), 16271);
-assert_eq!(call!(subi_ui16(17988, 4)), 17984);
-assert_eq!(call!(subi_ui16(17988, 3)), 17985);
-assert_eq!(call!(subi_ui16(17988, 2)), 17986);
-assert_eq!(call!(subi_ui16(17988, 1)), 17987);
-assert_eq!(call!(subi_ui16(17988, 0)), 17988);
-assert_eq!(call!(subi_ui16(65096, 17988)), 47108);
-assert_eq!(call!(subi_ui16(65534, 17988)), 47546);
-assert_eq!(call!(subi_ui16(65535, 17988)), 47547);
-assert_eq!(call!(subi_ui16(65096, 1717)), 63379);
-assert_eq!(call!(subi_ui16(65534, 1717)), 63817);
-assert_eq!(call!(subi_ui16(65535, 1717)), 63818);
-assert_eq!(call!(subi_ui16(65096, 4)), 65092);
-assert_eq!(call!(subi_ui16(65096, 3)), 65093);
-assert_eq!(call!(subi_ui16(65096, 2)), 65094);
-assert_eq!(call!(subi_ui16(65096, 1)), 65095);
-assert_eq!(call!(subi_ui16(65096, 0)), 65096);
-assert_eq!(call!(subi_ui16(65534, 4)), 65530);
-assert_eq!(call!(subi_ui16(65534, 3)), 65531);
-assert_eq!(call!(subi_ui16(65535, 4)), 65531);
-assert_eq!(call!(subi_ui16(65534, 2)), 65532);
-assert_eq!(call!(subi_ui16(65535, 3)), 65532);
-assert_eq!(call!(subi_ui16(65534, 1)), 65533);
-assert_eq!(call!(subi_ui16(65535, 2)), 65533);
-assert_eq!(call!(subi_ui16(65534, 0)), 65534);
-assert_eq!(call!(subi_ui16(65535, 1)), 65534);
-assert_eq!(call!(subi_ui16(65535, 0)), 65535);
-assert_eq!(call!(subi_ui32(0, 0)), 0);
-assert_eq!(call!(subi_ui32(1, 1)), 0);
-assert_eq!(call!(subi_ui32(2, 2)), 0);
-assert_eq!(call!(subi_ui32(3, 3)), 0);
-assert_eq!(call!(subi_ui32(4, 4)), 0);
-assert_eq!(call!(subi_ui32(2119154652, 2119154652)), 0);
-assert_eq!(call!(subi_ui32(3002788344, 3002788344)), 0);
-assert_eq!(call!(subi_ui32(3482297128, 3482297128)), 0);
-assert_eq!(call!(subi_ui32(4294967294, 4294967294)), 0);
-assert_eq!(call!(subi_ui32(4294967295, 4294967295)), 0);
-assert_eq!(call!(subi_ui32(1, 0)), 1);
-assert_eq!(call!(subi_ui32(2, 1)), 1);
-assert_eq!(call!(subi_ui32(3, 2)), 1);
-assert_eq!(call!(subi_ui32(4, 3)), 1);
-assert_eq!(call!(subi_ui32(4294967295, 4294967294)), 1);
-assert_eq!(call!(subi_ui32(2, 0)), 2);
-assert_eq!(call!(subi_ui32(3, 1)), 2);
-assert_eq!(call!(subi_ui32(4, 2)), 2);
-assert_eq!(call!(subi_ui32(3, 0)), 3);
-assert_eq!(call!(subi_ui32(4, 1)), 3);
-assert_eq!(call!(subi_ui32(4, 0)), 4);
-assert_eq!(call!(subi_ui32(3482297128, 3002788344)), 479508784);
-assert_eq!(call!(subi_ui32(4294967294, 3482297128)), 812670166);
-assert_eq!(call!(subi_ui32(4294967295, 3482297128)), 812670167);
-assert_eq!(call!(subi_ui32(3002788344, 2119154652)), 883633692);
-assert_eq!(call!(subi_ui32(4294967294, 3002788344)), 1292178950);
-assert_eq!(call!(subi_ui32(4294967295, 3002788344)), 1292178951);
-assert_eq!(call!(subi_ui32(3482297128, 2119154652)), 1363142476);
-assert_eq!(call!(subi_ui32(2119154652, 4)), 2119154648);
-assert_eq!(call!(subi_ui32(2119154652, 3)), 2119154649);
-assert_eq!(call!(subi_ui32(2119154652, 2)), 2119154650);
-assert_eq!(call!(subi_ui32(2119154652, 1)), 2119154651);
-assert_eq!(call!(subi_ui32(2119154652, 0)), 2119154652);
-assert_eq!(call!(subi_ui32(4294967294, 2119154652)), 2175812642);
-assert_eq!(call!(subi_ui32(4294967295, 2119154652)), 2175812643);
-assert_eq!(call!(subi_ui32(3002788344, 4)), 3002788340);
-assert_eq!(call!(subi_ui32(3002788344, 3)), 3002788341);
-assert_eq!(call!(subi_ui32(3002788344, 2)), 3002788342);
-assert_eq!(call!(subi_ui32(3002788344, 1)), 3002788343);
-assert_eq!(call!(subi_ui32(3002788344, 0)), 3002788344);
-assert_eq!(call!(subi_ui32(3482297128, 4)), 3482297124);
-assert_eq!(call!(subi_ui32(3482297128, 3)), 3482297125);
-assert_eq!(call!(subi_ui32(3482297128, 2)), 3482297126);
-assert_eq!(call!(subi_ui32(3482297128, 1)), 3482297127);
-assert_eq!(call!(subi_ui32(3482297128, 0)), 3482297128);
-assert_eq!(call!(subi_ui32(4294967294, 4)), 4294967290);
-assert_eq!(call!(subi_ui32(4294967294, 3)), 4294967291);
-assert_eq!(call!(subi_ui32(4294967295, 4)), 4294967291);
-assert_eq!(call!(subi_ui32(4294967294, 2)), 4294967292);
-assert_eq!(call!(subi_ui32(4294967295, 3)), 4294967292);
-assert_eq!(call!(subi_ui32(4294967294, 1)), 4294967293);
-assert_eq!(call!(subi_ui32(4294967295, 2)), 4294967293);
-assert_eq!(call!(subi_ui32(4294967294, 0)), 4294967294);
-assert_eq!(call!(subi_ui32(4294967295, 1)), 4294967294);
-assert_eq!(call!(subi_ui32(4294967295, 0)), 4294967295);
-assert_eq!(call!(subi_ui64(0, 0)), 0);
-assert_eq!(call!(subi_ui64(1, 1)), 0);
-assert_eq!(call!(subi_ui64(2, 2)), 0);
-assert_eq!(call!(subi_ui64(3, 3)), 0);
-assert_eq!(call!(subi_ui64(4, 4)), 0);
-assert_eq!(call!(subi_ui64(191084152064409600, 191084152064409600)), 0);
-assert_eq!(call!(subi_ui64(11015955194427482112, 11015955194427482112)), 0);
-assert_eq!(call!(subi_ui64(16990600415051759616, 16990600415051759616)), 0);
-assert_eq!(call!(subi_ui64(18446744073709551614, 18446744073709551614)), 0);
-assert_eq!(call!(subi_ui64(18446744073709551615, 18446744073709551615)), 0);
-assert_eq!(call!(subi_ui64(1, 0)), 1);
-assert_eq!(call!(subi_ui64(2, 1)), 1);
-assert_eq!(call!(subi_ui64(3, 2)), 1);
-assert_eq!(call!(subi_ui64(4, 3)), 1);
-assert_eq!(call!(subi_ui64(18446744073709551615, 18446744073709551614)), 1);
-assert_eq!(call!(subi_ui64(2, 0)), 2);
-assert_eq!(call!(subi_ui64(3, 1)), 2);
-assert_eq!(call!(subi_ui64(4, 2)), 2);
-assert_eq!(call!(subi_ui64(3, 0)), 3);
-assert_eq!(call!(subi_ui64(4, 1)), 3);
-assert_eq!(call!(subi_ui64(4, 0)), 4);
-assert_eq!(call!(subi_ui64(191084152064409600, 4)), 191084152064409596);
-assert_eq!(call!(subi_ui64(191084152064409600, 3)), 191084152064409597);
-assert_eq!(call!(subi_ui64(191084152064409600, 2)), 191084152064409598);
-assert_eq!(call!(subi_ui64(191084152064409600, 1)), 191084152064409599);
-assert_eq!(call!(subi_ui64(191084152064409600, 0)), 191084152064409600);
-assert_eq!(call!(subi_ui64(18446744073709551614, 16990600415051759616)), 1456143658657791998);
-assert_eq!(call!(subi_ui64(18446744073709551615, 16990600415051759616)), 1456143658657791999);
-assert_eq!(call!(subi_ui64(16990600415051759616, 11015955194427482112)), 5974645220624277504);
-assert_eq!(call!(subi_ui64(18446744073709551614, 11015955194427482112)), 7430788879282069502);
-assert_eq!(call!(subi_ui64(18446744073709551615, 11015955194427482112)), 7430788879282069503);
-assert_eq!(call!(subi_ui64(11015955194427482112, 191084152064409600)), 10824871042363072512);
-assert_eq!(call!(subi_ui64(11015955194427482112, 4)), 11015955194427482108);
-assert_eq!(call!(subi_ui64(11015955194427482112, 3)), 11015955194427482109);
-assert_eq!(call!(subi_ui64(11015955194427482112, 2)), 11015955194427482110);
-assert_eq!(call!(subi_ui64(11015955194427482112, 1)), 11015955194427482111);
-assert_eq!(call!(subi_ui64(11015955194427482112, 0)), 11015955194427482112);
-assert_eq!(call!(subi_ui64(16990600415051759616, 191084152064409600)), 16799516262987350016);
-assert_eq!(call!(subi_ui64(16990600415051759616, 4)), 16990600415051759612);
-assert_eq!(call!(subi_ui64(16990600415051759616, 3)), 16990600415051759613);
-assert_eq!(call!(subi_ui64(16990600415051759616, 2)), 16990600415051759614);
-assert_eq!(call!(subi_ui64(16990600415051759616, 1)), 16990600415051759615);
-assert_eq!(call!(subi_ui64(16990600415051759616, 0)), 16990600415051759616);
-assert_eq!(call!(subi_ui64(18446744073709551614, 191084152064409600)), 18255659921645142014);
-assert_eq!(call!(subi_ui64(18446744073709551615, 191084152064409600)), 18255659921645142015);
-assert_eq!(call!(subi_ui64(18446744073709551614, 4)), 18446744073709551610);
-assert_eq!(call!(subi_ui64(18446744073709551614, 3)), 18446744073709551611);
-assert_eq!(call!(subi_ui64(18446744073709551615, 4)), 18446744073709551611);
-assert_eq!(call!(subi_ui64(18446744073709551614, 2)), 18446744073709551612);
-assert_eq!(call!(subi_ui64(18446744073709551615, 3)), 18446744073709551612);
-assert_eq!(call!(subi_ui64(18446744073709551614, 1)), 18446744073709551613);
-assert_eq!(call!(subi_ui64(18446744073709551615, 2)), 18446744073709551613);
-assert_eq!(call!(subi_ui64(18446744073709551614, 0)), 18446744073709551614);
-assert_eq!(call!(subi_ui64(18446744073709551615, 1)), 18446744073709551614);
-assert_eq!(call!(subi_ui64(18446744073709551615, 0)), 18446744073709551615);
-assert_eq!(call!(subi_ui8(0, 0)), 0);
-assert_eq!(call!(subi_ui8(1, 1)), 0);
-assert_eq!(call!(subi_ui8(2, 2)), 0);
-assert_eq!(call!(subi_ui8(3, 3)), 0);
-assert_eq!(call!(subi_ui8(4, 4)), 0);
-assert_eq!(call!(subi_ui8(72, 72)), 0);
-assert_eq!(call!(subi_ui8(100, 100)), 0);
-assert_eq!(call!(subi_ui8(162, 162)), 0);
-assert_eq!(call!(subi_ui8(254, 254)), 0);
-assert_eq!(call!(subi_ui8(255, 255)), 0);
-assert_eq!(call!(subi_ui8(1, 0)), 1);
-assert_eq!(call!(subi_ui8(2, 1)), 1);
-assert_eq!(call!(subi_ui8(3, 2)), 1);
-assert_eq!(call!(subi_ui8(4, 3)), 1);
-assert_eq!(call!(subi_ui8(255, 254)), 1);
-assert_eq!(call!(subi_ui8(2, 0)), 2);
-assert_eq!(call!(subi_ui8(3, 1)), 2);
-assert_eq!(call!(subi_ui8(4, 2)), 2);
-assert_eq!(call!(subi_ui8(3, 0)), 3);
-assert_eq!(call!(subi_ui8(4, 1)), 3);
-assert_eq!(call!(subi_ui8(4, 0)), 4);
-assert_eq!(call!(subi_ui8(100, 72)), 28);
-assert_eq!(call!(subi_ui8(162, 100)), 62);
-assert_eq!(call!(subi_ui8(72, 4)), 68);
-assert_eq!(call!(subi_ui8(72, 3)), 69);
-assert_eq!(call!(subi_ui8(72, 2)), 70);
-assert_eq!(call!(subi_ui8(72, 1)), 71);
-assert_eq!(call!(subi_ui8(72, 0)), 72);
-assert_eq!(call!(subi_ui8(162, 72)), 90);
-assert_eq!(call!(subi_ui8(254, 162)), 92);
-assert_eq!(call!(subi_ui8(255, 162)), 93);
-assert_eq!(call!(subi_ui8(100, 4)), 96);
-assert_eq!(call!(subi_ui8(100, 3)), 97);
-assert_eq!(call!(subi_ui8(100, 2)), 98);
-assert_eq!(call!(subi_ui8(100, 1)), 99);
-assert_eq!(call!(subi_ui8(100, 0)), 100);
-assert_eq!(call!(subi_ui8(254, 100)), 154);
-assert_eq!(call!(subi_ui8(255, 100)), 155);
-assert_eq!(call!(subi_ui8(162, 4)), 158);
-assert_eq!(call!(subi_ui8(162, 3)), 159);
-assert_eq!(call!(subi_ui8(162, 2)), 160);
-assert_eq!(call!(subi_ui8(162, 1)), 161);
-assert_eq!(call!(subi_ui8(162, 0)), 162);
-assert_eq!(call!(subi_ui8(254, 72)), 182);
-assert_eq!(call!(subi_ui8(255, 72)), 183);
-assert_eq!(call!(subi_ui8(254, 4)), 250);
-assert_eq!(call!(subi_ui8(254, 3)), 251);
-assert_eq!(call!(subi_ui8(255, 4)), 251);
-assert_eq!(call!(subi_ui8(254, 2)), 252);
-assert_eq!(call!(subi_ui8(255, 3)), 252);
-assert_eq!(call!(subi_ui8(254, 1)), 253);
-assert_eq!(call!(subi_ui8(255, 2)), 253);
-assert_eq!(call!(subi_ui8(254, 0)), 254);
-assert_eq!(call!(subi_ui8(255, 1)), 254);
-assert_eq!(call!(subi_ui8(255, 0)), 255);
-}
+    use crate::arctorustintarith::*;
+    #[test]
+    fn it_works() {
+        assert_eq!(addi_si16(-32768, 0), -32768);
+        assert_eq!(addi_si16(0, -32768), -32768);
+        assert_eq!(addi_si16(-32768, 1), -32767);
+        assert_eq!(addi_si16(-32767, 0), -32767);
+        assert_eq!(addi_si16(0, -32767), -32767);
+        assert_eq!(addi_si16(1, -32768), -32767);
+        assert_eq!(addi_si16(-32768, 2), -32766);
+        assert_eq!(addi_si16(-32767, 1), -32766);
+        assert_eq!(addi_si16(1, -32767), -32766);
+        assert_eq!(addi_si16(2, -32768), -32766);
+        assert_eq!(addi_si16(-32768, 3), -32765);
+        assert_eq!(addi_si16(-32767, 2), -32765);
+        assert_eq!(addi_si16(2, -32767), -32765);
+        assert_eq!(addi_si16(3, -32768), -32765);
+        assert_eq!(addi_si16(-32768, 4), -32764);
+        assert_eq!(addi_si16(-32767, 3), -32764);
+        assert_eq!(addi_si16(3, -32767), -32764);
+        assert_eq!(addi_si16(4, -32768), -32764);
+        assert_eq!(addi_si16(-32767, 4), -32763);
+        assert_eq!(addi_si16(4, -32767), -32763);
+        assert_eq!(addi_si16(-32547, 0), -32547);
+        assert_eq!(addi_si16(0, -32547), -32547);
+        assert_eq!(addi_si16(-32547, 1), -32546);
+        assert_eq!(addi_si16(1, -32547), -32546);
+        assert_eq!(addi_si16(-32547, 2), -32545);
+        assert_eq!(addi_si16(2, -32547), -32545);
+        assert_eq!(addi_si16(-32547, 3), -32544);
+        assert_eq!(addi_si16(3, -32547), -32544);
+        assert_eq!(addi_si16(-32547, 4), -32543);
+        assert_eq!(addi_si16(4, -32547), -32543);
+        assert_eq!(addi_si16(-32768, 10486), -22282);
+        assert_eq!(addi_si16(10486, -32768), -22282);
+        assert_eq!(addi_si16(-32767, 10486), -22281);
+        assert_eq!(addi_si16(10486, -32767), -22281);
+        assert_eq!(addi_si16(-32547, 10486), -22061);
+        assert_eq!(addi_si16(10486, -32547), -22061);
+        assert_eq!(addi_si16(-32768, 16514), -16254);
+        assert_eq!(addi_si16(16514, -32768), -16254);
+        assert_eq!(addi_si16(-32767, 16514), -16253);
+        assert_eq!(addi_si16(16514, -32767), -16253);
+        assert_eq!(addi_si16(-32547, 16514), -16033);
+        assert_eq!(addi_si16(16514, -32547), -16033);
+        assert_eq!(addi_si16(-32768, 32766), -2);
+        assert_eq!(addi_si16(32766, -32768), -2);
+        assert_eq!(addi_si16(-32768, 32767), -1);
+        assert_eq!(addi_si16(-32767, 32766), -1);
+        assert_eq!(addi_si16(32766, -32767), -1);
+        assert_eq!(addi_si16(32767, -32768), -1);
+        assert_eq!(addi_si16(-32767, 32767), 0);
+        assert_eq!(addi_si16(0, 0), 0);
+        assert_eq!(addi_si16(32767, -32767), 0);
+        assert_eq!(addi_si16(0, 1), 1);
+        assert_eq!(addi_si16(1, 0), 1);
+        assert_eq!(addi_si16(0, 2), 2);
+        assert_eq!(addi_si16(1, 1), 2);
+        assert_eq!(addi_si16(2, 0), 2);
+        assert_eq!(addi_si16(0, 3), 3);
+        assert_eq!(addi_si16(1, 2), 3);
+        assert_eq!(addi_si16(2, 1), 3);
+        assert_eq!(addi_si16(3, 0), 3);
+        assert_eq!(addi_si16(0, 4), 4);
+        assert_eq!(addi_si16(1, 3), 4);
+        assert_eq!(addi_si16(2, 2), 4);
+        assert_eq!(addi_si16(3, 1), 4);
+        assert_eq!(addi_si16(4, 0), 4);
+        assert_eq!(addi_si16(1, 4), 5);
+        assert_eq!(addi_si16(2, 3), 5);
+        assert_eq!(addi_si16(3, 2), 5);
+        assert_eq!(addi_si16(4, 1), 5);
+        assert_eq!(addi_si16(2, 4), 6);
+        assert_eq!(addi_si16(3, 3), 6);
+        assert_eq!(addi_si16(4, 2), 6);
+        assert_eq!(addi_si16(3, 4), 7);
+        assert_eq!(addi_si16(4, 3), 7);
+        assert_eq!(addi_si16(4, 4), 8);
+        assert_eq!(addi_si16(-32547, 32766), 219);
+        assert_eq!(addi_si16(32766, -32547), 219);
+        assert_eq!(addi_si16(-32547, 32767), 220);
+        assert_eq!(addi_si16(32767, -32547), 220);
+        assert_eq!(addi_si16(0, 10486), 10486);
+        assert_eq!(addi_si16(10486, 0), 10486);
+        assert_eq!(addi_si16(1, 10486), 10487);
+        assert_eq!(addi_si16(10486, 1), 10487);
+        assert_eq!(addi_si16(2, 10486), 10488);
+        assert_eq!(addi_si16(10486, 2), 10488);
+        assert_eq!(addi_si16(3, 10486), 10489);
+        assert_eq!(addi_si16(10486, 3), 10489);
+        assert_eq!(addi_si16(4, 10486), 10490);
+        assert_eq!(addi_si16(10486, 4), 10490);
+        assert_eq!(addi_si16(0, 16514), 16514);
+        assert_eq!(addi_si16(16514, 0), 16514);
+        assert_eq!(addi_si16(1, 16514), 16515);
+        assert_eq!(addi_si16(16514, 1), 16515);
+        assert_eq!(addi_si16(2, 16514), 16516);
+        assert_eq!(addi_si16(16514, 2), 16516);
+        assert_eq!(addi_si16(3, 16514), 16517);
+        assert_eq!(addi_si16(16514, 3), 16517);
+        assert_eq!(addi_si16(4, 16514), 16518);
+        assert_eq!(addi_si16(16514, 4), 16518);
+        assert_eq!(addi_si16(10486, 10486), 20972);
+        assert_eq!(addi_si16(10486, 16514), 27000);
+        assert_eq!(addi_si16(16514, 10486), 27000);
+        assert_eq!(addi_si16(0, 32766), 32766);
+        assert_eq!(addi_si16(32766, 0), 32766);
+        assert_eq!(addi_si16(0, 32767), 32767);
+        assert_eq!(addi_si16(1, 32766), 32767);
+        assert_eq!(addi_si16(32766, 1), 32767);
+        assert_eq!(addi_si16(32767, 0), 32767);
+        assert_eq!(addi_si32(-2147483648, 0), -2147483648);
+        assert_eq!(addi_si32(0, -2147483648), -2147483648);
+        assert_eq!(addi_si32(-2147483648, 1), -2147483647);
+        assert_eq!(addi_si32(-2147483647, 0), -2147483647);
+        assert_eq!(addi_si32(0, -2147483647), -2147483647);
+        assert_eq!(addi_si32(1, -2147483648), -2147483647);
+        assert_eq!(addi_si32(-2147483648, 2), -2147483646);
+        assert_eq!(addi_si32(-2147483647, 1), -2147483646);
+        assert_eq!(addi_si32(1, -2147483647), -2147483646);
+        assert_eq!(addi_si32(2, -2147483648), -2147483646);
+        assert_eq!(addi_si32(-2147483648, 3), -2147483645);
+        assert_eq!(addi_si32(-2147483647, 2), -2147483645);
+        assert_eq!(addi_si32(2, -2147483647), -2147483645);
+        assert_eq!(addi_si32(3, -2147483648), -2147483645);
+        assert_eq!(addi_si32(-2147483648, 4), -2147483644);
+        assert_eq!(addi_si32(-2147483647, 3), -2147483644);
+        assert_eq!(addi_si32(3, -2147483647), -2147483644);
+        assert_eq!(addi_si32(4, -2147483648), -2147483644);
+        assert_eq!(addi_si32(-2147483647, 4), -2147483643);
+        assert_eq!(addi_si32(4, -2147483647), -2147483643);
+        assert_eq!(addi_si32(-1035405763, -1035405763), -2070811526);
+        assert_eq!(addi_si32(-1713183800, 0), -1713183800);
+        assert_eq!(addi_si32(0, -1713183800), -1713183800);
+        assert_eq!(addi_si32(-1713183800, 1), -1713183799);
+        assert_eq!(addi_si32(1, -1713183800), -1713183799);
+        assert_eq!(addi_si32(-1713183800, 2), -1713183798);
+        assert_eq!(addi_si32(2, -1713183800), -1713183798);
+        assert_eq!(addi_si32(-1713183800, 3), -1713183797);
+        assert_eq!(addi_si32(3, -1713183800), -1713183797);
+        assert_eq!(addi_si32(-1713183800, 4), -1713183796);
+        assert_eq!(addi_si32(4, -1713183800), -1713183796);
+        assert_eq!(addi_si32(-1252582164, 0), -1252582164);
+        assert_eq!(addi_si32(0, -1252582164), -1252582164);
+        assert_eq!(addi_si32(-1252582164, 1), -1252582163);
+        assert_eq!(addi_si32(1, -1252582164), -1252582163);
+        assert_eq!(addi_si32(-1252582164, 2), -1252582162);
+        assert_eq!(addi_si32(2, -1252582164), -1252582162);
+        assert_eq!(addi_si32(-1252582164, 3), -1252582161);
+        assert_eq!(addi_si32(3, -1252582164), -1252582161);
+        assert_eq!(addi_si32(-1252582164, 4), -1252582160);
+        assert_eq!(addi_si32(4, -1252582164), -1252582160);
+        assert_eq!(addi_si32(-1035405763, 0), -1035405763);
+        assert_eq!(addi_si32(0, -1035405763), -1035405763);
+        assert_eq!(addi_si32(-1035405763, 1), -1035405762);
+        assert_eq!(addi_si32(1, -1035405763), -1035405762);
+        assert_eq!(addi_si32(-1035405763, 2), -1035405761);
+        assert_eq!(addi_si32(2, -1035405763), -1035405761);
+        assert_eq!(addi_si32(-1035405763, 3), -1035405760);
+        assert_eq!(addi_si32(3, -1035405763), -1035405760);
+        assert_eq!(addi_si32(-1035405763, 4), -1035405759);
+        assert_eq!(addi_si32(4, -1035405763), -1035405759);
+        assert_eq!(addi_si32(-2147483648, 2147483646), -2);
+        assert_eq!(addi_si32(2147483646, -2147483648), -2);
+        assert_eq!(addi_si32(-2147483648, 2147483647), -1);
+        assert_eq!(addi_si32(-2147483647, 2147483646), -1);
+        assert_eq!(addi_si32(2147483646, -2147483647), -1);
+        assert_eq!(addi_si32(2147483647, -2147483648), -1);
+        assert_eq!(addi_si32(-2147483647, 2147483647), 0);
+        assert_eq!(addi_si32(0, 0), 0);
+        assert_eq!(addi_si32(2147483647, -2147483647), 0);
+        assert_eq!(addi_si32(0, 1), 1);
+        assert_eq!(addi_si32(1, 0), 1);
+        assert_eq!(addi_si32(0, 2), 2);
+        assert_eq!(addi_si32(1, 1), 2);
+        assert_eq!(addi_si32(2, 0), 2);
+        assert_eq!(addi_si32(0, 3), 3);
+        assert_eq!(addi_si32(1, 2), 3);
+        assert_eq!(addi_si32(2, 1), 3);
+        assert_eq!(addi_si32(3, 0), 3);
+        assert_eq!(addi_si32(0, 4), 4);
+        assert_eq!(addi_si32(1, 3), 4);
+        assert_eq!(addi_si32(2, 2), 4);
+        assert_eq!(addi_si32(3, 1), 4);
+        assert_eq!(addi_si32(4, 0), 4);
+        assert_eq!(addi_si32(1, 4), 5);
+        assert_eq!(addi_si32(2, 3), 5);
+        assert_eq!(addi_si32(3, 2), 5);
+        assert_eq!(addi_si32(4, 1), 5);
+        assert_eq!(addi_si32(2, 4), 6);
+        assert_eq!(addi_si32(3, 3), 6);
+        assert_eq!(addi_si32(4, 2), 6);
+        assert_eq!(addi_si32(3, 4), 7);
+        assert_eq!(addi_si32(4, 3), 7);
+        assert_eq!(addi_si32(4, 4), 8);
+        assert_eq!(addi_si32(-1713183800, 2147483646), 434299846);
+        assert_eq!(addi_si32(2147483646, -1713183800), 434299846);
+        assert_eq!(addi_si32(-1713183800, 2147483647), 434299847);
+        assert_eq!(addi_si32(2147483647, -1713183800), 434299847);
+        assert_eq!(addi_si32(-1252582164, 2147483646), 894901482);
+        assert_eq!(addi_si32(2147483646, -1252582164), 894901482);
+        assert_eq!(addi_si32(-1252582164, 2147483647), 894901483);
+        assert_eq!(addi_si32(2147483647, -1252582164), 894901483);
+        assert_eq!(addi_si32(-1035405763, 2147483646), 1112077883);
+        assert_eq!(addi_si32(2147483646, -1035405763), 1112077883);
+        assert_eq!(addi_si32(-1035405763, 2147483647), 1112077884);
+        assert_eq!(addi_si32(2147483647, -1035405763), 1112077884);
+        assert_eq!(addi_si32(0, 2147483646), 2147483646);
+        assert_eq!(addi_si32(2147483646, 0), 2147483646);
+        assert_eq!(addi_si32(0, 2147483647), 2147483647);
+        assert_eq!(addi_si32(1, 2147483646), 2147483647);
+        assert_eq!(addi_si32(2147483646, 1), 2147483647);
+        assert_eq!(addi_si32(2147483647, 0), 2147483647);
+        assert_eq!(addi_si64(-9223372036854775808, 0), -9223372036854775808);
+        assert_eq!(addi_si64(0, -9223372036854775808), -9223372036854775808);
+        assert_eq!(addi_si64(-9223372036854775808, 1), -9223372036854775807);
+        assert_eq!(addi_si64(-9223372036854775807, 0), -9223372036854775807);
+        assert_eq!(addi_si64(0, -9223372036854775807), -9223372036854775807);
+        assert_eq!(addi_si64(1, -9223372036854775808), -9223372036854775807);
+        assert_eq!(addi_si64(-9223372036854775808, 2), -9223372036854775806);
+        assert_eq!(addi_si64(-9223372036854775807, 1), -9223372036854775806);
+        assert_eq!(addi_si64(1, -9223372036854775807), -9223372036854775806);
+        assert_eq!(addi_si64(2, -9223372036854775808), -9223372036854775806);
+        assert_eq!(addi_si64(-9223372036854775808, 3), -9223372036854775805);
+        assert_eq!(addi_si64(-9223372036854775807, 2), -9223372036854775805);
+        assert_eq!(addi_si64(2, -9223372036854775807), -9223372036854775805);
+        assert_eq!(addi_si64(3, -9223372036854775808), -9223372036854775805);
+        assert_eq!(addi_si64(-9223372036854775808, 4), -9223372036854775804);
+        assert_eq!(addi_si64(-9223372036854775807, 3), -9223372036854775804);
+        assert_eq!(addi_si64(3, -9223372036854775807), -9223372036854775804);
+        assert_eq!(addi_si64(4, -9223372036854775808), -9223372036854775804);
+        assert_eq!(addi_si64(-9223372036854775807, 4), -9223372036854775803);
+        assert_eq!(addi_si64(4, -9223372036854775807), -9223372036854775803);
+        assert_eq!(
+            addi_si64(-9223372036854775808, 5577148965131116544),
+            -3646223071723659264
+        );
+        assert_eq!(
+            addi_si64(5577148965131116544, -9223372036854775808),
+            -3646223071723659264
+        );
+        assert_eq!(
+            addi_si64(-9223372036854775807, 5577148965131116544),
+            -3646223071723659263
+        );
+        assert_eq!(
+            addi_si64(5577148965131116544, -9223372036854775807),
+            -3646223071723659263
+        );
+        assert_eq!(
+            addi_si64(-1741927215160008704, -1741927215160008704),
+            -3483854430320017408
+        );
+        assert_eq!(
+            addi_si64(-1741927215160008704, -1328271339354574848),
+            -3070198554514583552
+        );
+        assert_eq!(
+            addi_si64(-1328271339354574848, -1741927215160008704),
+            -3070198554514583552
+        );
+        assert_eq!(
+            addi_si64(-1328271339354574848, -1328271339354574848),
+            -2656542678709149696
+        );
+        assert_eq!(addi_si64(-1741927215160008704, 0), -1741927215160008704);
+        assert_eq!(addi_si64(0, -1741927215160008704), -1741927215160008704);
+        assert_eq!(addi_si64(-1741927215160008704, 1), -1741927215160008703);
+        assert_eq!(addi_si64(1, -1741927215160008704), -1741927215160008703);
+        assert_eq!(addi_si64(-1741927215160008704, 2), -1741927215160008702);
+        assert_eq!(addi_si64(2, -1741927215160008704), -1741927215160008702);
+        assert_eq!(addi_si64(-1741927215160008704, 3), -1741927215160008701);
+        assert_eq!(addi_si64(3, -1741927215160008704), -1741927215160008701);
+        assert_eq!(addi_si64(-1741927215160008704, 4), -1741927215160008700);
+        assert_eq!(addi_si64(4, -1741927215160008704), -1741927215160008700);
+        assert_eq!(addi_si64(-1328271339354574848, 0), -1328271339354574848);
+        assert_eq!(addi_si64(0, -1328271339354574848), -1328271339354574848);
+        assert_eq!(addi_si64(-1328271339354574848, 1), -1328271339354574847);
+        assert_eq!(addi_si64(1, -1328271339354574848), -1328271339354574847);
+        assert_eq!(addi_si64(-1328271339354574848, 2), -1328271339354574846);
+        assert_eq!(addi_si64(2, -1328271339354574848), -1328271339354574846);
+        assert_eq!(addi_si64(-1328271339354574848, 3), -1328271339354574845);
+        assert_eq!(addi_si64(3, -1328271339354574848), -1328271339354574845);
+        assert_eq!(addi_si64(-1328271339354574848, 4), -1328271339354574844);
+        assert_eq!(addi_si64(4, -1328271339354574848), -1328271339354574844);
+        assert_eq!(addi_si64(-9223372036854775808, 9223372036854775806), -2);
+        assert_eq!(addi_si64(9223372036854775806, -9223372036854775808), -2);
+        assert_eq!(addi_si64(-9223372036854775808, 9223372036854775807), -1);
+        assert_eq!(addi_si64(-9223372036854775807, 9223372036854775806), -1);
+        assert_eq!(addi_si64(9223372036854775806, -9223372036854775807), -1);
+        assert_eq!(addi_si64(9223372036854775807, -9223372036854775808), -1);
+        assert_eq!(addi_si64(-9223372036854775807, 9223372036854775807), 0);
+        assert_eq!(addi_si64(0, 0), 0);
+        assert_eq!(addi_si64(9223372036854775807, -9223372036854775807), 0);
+        assert_eq!(addi_si64(0, 1), 1);
+        assert_eq!(addi_si64(1, 0), 1);
+        assert_eq!(addi_si64(0, 2), 2);
+        assert_eq!(addi_si64(1, 1), 2);
+        assert_eq!(addi_si64(2, 0), 2);
+        assert_eq!(addi_si64(0, 3), 3);
+        assert_eq!(addi_si64(1, 2), 3);
+        assert_eq!(addi_si64(2, 1), 3);
+        assert_eq!(addi_si64(3, 0), 3);
+        assert_eq!(addi_si64(0, 4), 4);
+        assert_eq!(addi_si64(1, 3), 4);
+        assert_eq!(addi_si64(2, 2), 4);
+        assert_eq!(addi_si64(3, 1), 4);
+        assert_eq!(addi_si64(4, 0), 4);
+        assert_eq!(addi_si64(1, 4), 5);
+        assert_eq!(addi_si64(2, 3), 5);
+        assert_eq!(addi_si64(3, 2), 5);
+        assert_eq!(addi_si64(4, 1), 5);
+        assert_eq!(addi_si64(2, 4), 6);
+        assert_eq!(addi_si64(3, 3), 6);
+        assert_eq!(addi_si64(4, 2), 6);
+        assert_eq!(addi_si64(3, 4), 7);
+        assert_eq!(addi_si64(4, 3), 7);
+        assert_eq!(addi_si64(4, 4), 8);
+        assert_eq!(
+            addi_si64(-1741927215160008704, 5577148965131116544),
+            3835221749971107840
+        );
+        assert_eq!(
+            addi_si64(5577148965131116544, -1741927215160008704),
+            3835221749971107840
+        );
+        assert_eq!(
+            addi_si64(-1328271339354574848, 5577148965131116544),
+            4248877625776541696
+        );
+        assert_eq!(
+            addi_si64(5577148965131116544, -1328271339354574848),
+            4248877625776541696
+        );
+        assert_eq!(addi_si64(0, 5577148965131116544), 5577148965131116544);
+        assert_eq!(addi_si64(5577148965131116544, 0), 5577148965131116544);
+        assert_eq!(addi_si64(1, 5577148965131116544), 5577148965131116545);
+        assert_eq!(addi_si64(5577148965131116544, 1), 5577148965131116545);
+        assert_eq!(addi_si64(2, 5577148965131116544), 5577148965131116546);
+        assert_eq!(addi_si64(5577148965131116544, 2), 5577148965131116546);
+        assert_eq!(addi_si64(3, 5577148965131116544), 5577148965131116547);
+        assert_eq!(addi_si64(5577148965131116544, 3), 5577148965131116547);
+        assert_eq!(addi_si64(4, 5577148965131116544), 5577148965131116548);
+        assert_eq!(addi_si64(5577148965131116544, 4), 5577148965131116548);
+        assert_eq!(
+            addi_si64(-1741927215160008704, 9223372036854775806),
+            7481444821694767102
+        );
+        assert_eq!(
+            addi_si64(9223372036854775806, -1741927215160008704),
+            7481444821694767102
+        );
+        assert_eq!(
+            addi_si64(-1741927215160008704, 9223372036854775807),
+            7481444821694767103
+        );
+        assert_eq!(
+            addi_si64(9223372036854775807, -1741927215160008704),
+            7481444821694767103
+        );
+        assert_eq!(
+            addi_si64(-1328271339354574848, 9223372036854775806),
+            7895100697500200958
+        );
+        assert_eq!(
+            addi_si64(9223372036854775806, -1328271339354574848),
+            7895100697500200958
+        );
+        assert_eq!(
+            addi_si64(-1328271339354574848, 9223372036854775807),
+            7895100697500200959
+        );
+        assert_eq!(
+            addi_si64(9223372036854775807, -1328271339354574848),
+            7895100697500200959
+        );
+        assert_eq!(addi_si64(0, 9223372036854775806), 9223372036854775806);
+        assert_eq!(addi_si64(9223372036854775806, 0), 9223372036854775806);
+        assert_eq!(addi_si64(0, 9223372036854775807), 9223372036854775807);
+        assert_eq!(addi_si64(1, 9223372036854775806), 9223372036854775807);
+        assert_eq!(addi_si64(9223372036854775806, 1), 9223372036854775807);
+        assert_eq!(addi_si64(9223372036854775807, 0), 9223372036854775807);
+        assert_eq!(addi_si8(-128, 0), -128);
+        assert_eq!(addi_si8(0, -128), -128);
+        assert_eq!(addi_si8(-128, 1), -127);
+        assert_eq!(addi_si8(-127, 0), -127);
+        assert_eq!(addi_si8(0, -127), -127);
+        assert_eq!(addi_si8(1, -128), -127);
+        assert_eq!(addi_si8(-128, 2), -126);
+        assert_eq!(addi_si8(-127, 1), -126);
+        assert_eq!(addi_si8(1, -127), -126);
+        assert_eq!(addi_si8(2, -128), -126);
+        assert_eq!(addi_si8(-128, 3), -125);
+        assert_eq!(addi_si8(-127, 2), -125);
+        assert_eq!(addi_si8(2, -127), -125);
+        assert_eq!(addi_si8(3, -128), -125);
+        assert_eq!(addi_si8(-128, 4), -124);
+        assert_eq!(addi_si8(-127, 3), -124);
+        assert_eq!(addi_si8(3, -127), -124);
+        assert_eq!(addi_si8(4, -128), -124);
+        assert_eq!(addi_si8(-127, 4), -123);
+        assert_eq!(addi_si8(4, -127), -123);
+        assert_eq!(addi_si8(-128, 16), -112);
+        assert_eq!(addi_si8(16, -128), -112);
+        assert_eq!(addi_si8(-127, 16), -111);
+        assert_eq!(addi_si8(16, -127), -111);
+        assert_eq!(addi_si8(-128, 126), -2);
+        assert_eq!(addi_si8(126, -128), -2);
+        assert_eq!(addi_si8(-128, 127), -1);
+        assert_eq!(addi_si8(-127, 126), -1);
+        assert_eq!(addi_si8(126, -127), -1);
+        assert_eq!(addi_si8(127, -128), -1);
+        assert_eq!(addi_si8(-127, 127), 0);
+        assert_eq!(addi_si8(0, 0), 0);
+        assert_eq!(addi_si8(127, -127), 0);
+        assert_eq!(addi_si8(0, 1), 1);
+        assert_eq!(addi_si8(1, 0), 1);
+        assert_eq!(addi_si8(0, 2), 2);
+        assert_eq!(addi_si8(1, 1), 2);
+        assert_eq!(addi_si8(2, 0), 2);
+        assert_eq!(addi_si8(0, 3), 3);
+        assert_eq!(addi_si8(1, 2), 3);
+        assert_eq!(addi_si8(2, 1), 3);
+        assert_eq!(addi_si8(3, 0), 3);
+        assert_eq!(addi_si8(0, 4), 4);
+        assert_eq!(addi_si8(1, 3), 4);
+        assert_eq!(addi_si8(2, 2), 4);
+        assert_eq!(addi_si8(3, 1), 4);
+        assert_eq!(addi_si8(4, 0), 4);
+        assert_eq!(addi_si8(1, 4), 5);
+        assert_eq!(addi_si8(2, 3), 5);
+        assert_eq!(addi_si8(3, 2), 5);
+        assert_eq!(addi_si8(4, 1), 5);
+        assert_eq!(addi_si8(2, 4), 6);
+        assert_eq!(addi_si8(3, 3), 6);
+        assert_eq!(addi_si8(4, 2), 6);
+        assert_eq!(addi_si8(3, 4), 7);
+        assert_eq!(addi_si8(4, 3), 7);
+        assert_eq!(addi_si8(4, 4), 8);
+        assert_eq!(addi_si8(0, 16), 16);
+        assert_eq!(addi_si8(16, 0), 16);
+        assert_eq!(addi_si8(1, 16), 17);
+        assert_eq!(addi_si8(16, 1), 17);
+        assert_eq!(addi_si8(2, 16), 18);
+        assert_eq!(addi_si8(16, 2), 18);
+        assert_eq!(addi_si8(3, 16), 19);
+        assert_eq!(addi_si8(16, 3), 19);
+        assert_eq!(addi_si8(4, 16), 20);
+        assert_eq!(addi_si8(16, 4), 20);
+        assert_eq!(addi_si8(16, 16), 32);
+        assert_eq!(addi_si8(0, 126), 126);
+        assert_eq!(addi_si8(126, 0), 126);
+        assert_eq!(addi_si8(0, 127), 127);
+        assert_eq!(addi_si8(1, 126), 127);
+        assert_eq!(addi_si8(126, 1), 127);
+        assert_eq!(addi_si8(127, 0), 127);
+        assert_eq!(addi_ui16(0, 0), 0);
+        assert_eq!(addi_ui16(0, 1), 1);
+        assert_eq!(addi_ui16(1, 0), 1);
+        assert_eq!(addi_ui16(0, 2), 2);
+        assert_eq!(addi_ui16(1, 1), 2);
+        assert_eq!(addi_ui16(2, 0), 2);
+        assert_eq!(addi_ui16(0, 3), 3);
+        assert_eq!(addi_ui16(1, 2), 3);
+        assert_eq!(addi_ui16(2, 1), 3);
+        assert_eq!(addi_ui16(3, 0), 3);
+        assert_eq!(addi_ui16(0, 4), 4);
+        assert_eq!(addi_ui16(1, 3), 4);
+        assert_eq!(addi_ui16(2, 2), 4);
+        assert_eq!(addi_ui16(3, 1), 4);
+        assert_eq!(addi_ui16(4, 0), 4);
+        assert_eq!(addi_ui16(1, 4), 5);
+        assert_eq!(addi_ui16(2, 3), 5);
+        assert_eq!(addi_ui16(3, 2), 5);
+        assert_eq!(addi_ui16(4, 1), 5);
+        assert_eq!(addi_ui16(2, 4), 6);
+        assert_eq!(addi_ui16(3, 3), 6);
+        assert_eq!(addi_ui16(4, 2), 6);
+        assert_eq!(addi_ui16(3, 4), 7);
+        assert_eq!(addi_ui16(4, 3), 7);
+        assert_eq!(addi_ui16(4, 4), 8);
+        assert_eq!(addi_ui16(0, 1717), 1717);
+        assert_eq!(addi_ui16(1717, 0), 1717);
+        assert_eq!(addi_ui16(1, 1717), 1718);
+        assert_eq!(addi_ui16(1717, 1), 1718);
+        assert_eq!(addi_ui16(2, 1717), 1719);
+        assert_eq!(addi_ui16(1717, 2), 1719);
+        assert_eq!(addi_ui16(3, 1717), 1720);
+        assert_eq!(addi_ui16(1717, 3), 1720);
+        assert_eq!(addi_ui16(4, 1717), 1721);
+        assert_eq!(addi_ui16(1717, 4), 1721);
+        assert_eq!(addi_ui16(1717, 1717), 3434);
+        assert_eq!(addi_ui16(0, 17988), 17988);
+        assert_eq!(addi_ui16(17988, 0), 17988);
+        assert_eq!(addi_ui16(1, 17988), 17989);
+        assert_eq!(addi_ui16(17988, 1), 17989);
+        assert_eq!(addi_ui16(2, 17988), 17990);
+        assert_eq!(addi_ui16(17988, 2), 17990);
+        assert_eq!(addi_ui16(3, 17988), 17991);
+        assert_eq!(addi_ui16(17988, 3), 17991);
+        assert_eq!(addi_ui16(4, 17988), 17992);
+        assert_eq!(addi_ui16(17988, 4), 17992);
+        assert_eq!(addi_ui16(1717, 17988), 19705);
+        assert_eq!(addi_ui16(17988, 1717), 19705);
+        assert_eq!(addi_ui16(17988, 17988), 35976);
+        assert_eq!(addi_ui16(0, 65096), 65096);
+        assert_eq!(addi_ui16(65096, 0), 65096);
+        assert_eq!(addi_ui16(1, 65096), 65097);
+        assert_eq!(addi_ui16(65096, 1), 65097);
+        assert_eq!(addi_ui16(2, 65096), 65098);
+        assert_eq!(addi_ui16(65096, 2), 65098);
+        assert_eq!(addi_ui16(3, 65096), 65099);
+        assert_eq!(addi_ui16(65096, 3), 65099);
+        assert_eq!(addi_ui16(4, 65096), 65100);
+        assert_eq!(addi_ui16(65096, 4), 65100);
+        assert_eq!(addi_ui16(0, 65534), 65534);
+        assert_eq!(addi_ui16(65534, 0), 65534);
+        assert_eq!(addi_ui16(0, 65535), 65535);
+        assert_eq!(addi_ui16(1, 65534), 65535);
+        assert_eq!(addi_ui16(65534, 1), 65535);
+        assert_eq!(addi_ui16(65535, 0), 65535);
+        assert_eq!(addi_ui32(0, 0), 0);
+        assert_eq!(addi_ui32(0, 1), 1);
+        assert_eq!(addi_ui32(1, 0), 1);
+        assert_eq!(addi_ui32(0, 2), 2);
+        assert_eq!(addi_ui32(1, 1), 2);
+        assert_eq!(addi_ui32(2, 0), 2);
+        assert_eq!(addi_ui32(0, 3), 3);
+        assert_eq!(addi_ui32(1, 2), 3);
+        assert_eq!(addi_ui32(2, 1), 3);
+        assert_eq!(addi_ui32(3, 0), 3);
+        assert_eq!(addi_ui32(0, 4), 4);
+        assert_eq!(addi_ui32(1, 3), 4);
+        assert_eq!(addi_ui32(2, 2), 4);
+        assert_eq!(addi_ui32(3, 1), 4);
+        assert_eq!(addi_ui32(4, 0), 4);
+        assert_eq!(addi_ui32(1, 4), 5);
+        assert_eq!(addi_ui32(2, 3), 5);
+        assert_eq!(addi_ui32(3, 2), 5);
+        assert_eq!(addi_ui32(4, 1), 5);
+        assert_eq!(addi_ui32(2, 4), 6);
+        assert_eq!(addi_ui32(3, 3), 6);
+        assert_eq!(addi_ui32(4, 2), 6);
+        assert_eq!(addi_ui32(3, 4), 7);
+        assert_eq!(addi_ui32(4, 3), 7);
+        assert_eq!(addi_ui32(4, 4), 8);
+        assert_eq!(addi_ui32(0, 2119154652), 2119154652);
+        assert_eq!(addi_ui32(2119154652, 0), 2119154652);
+        assert_eq!(addi_ui32(1, 2119154652), 2119154653);
+        assert_eq!(addi_ui32(2119154652, 1), 2119154653);
+        assert_eq!(addi_ui32(2, 2119154652), 2119154654);
+        assert_eq!(addi_ui32(2119154652, 2), 2119154654);
+        assert_eq!(addi_ui32(3, 2119154652), 2119154655);
+        assert_eq!(addi_ui32(2119154652, 3), 2119154655);
+        assert_eq!(addi_ui32(4, 2119154652), 2119154656);
+        assert_eq!(addi_ui32(2119154652, 4), 2119154656);
+        assert_eq!(addi_ui32(0, 3002788344), 3002788344);
+        assert_eq!(addi_ui32(3002788344, 0), 3002788344);
+        assert_eq!(addi_ui32(1, 3002788344), 3002788345);
+        assert_eq!(addi_ui32(3002788344, 1), 3002788345);
+        assert_eq!(addi_ui32(2, 3002788344), 3002788346);
+        assert_eq!(addi_ui32(3002788344, 2), 3002788346);
+        assert_eq!(addi_ui32(3, 3002788344), 3002788347);
+        assert_eq!(addi_ui32(3002788344, 3), 3002788347);
+        assert_eq!(addi_ui32(4, 3002788344), 3002788348);
+        assert_eq!(addi_ui32(3002788344, 4), 3002788348);
+        assert_eq!(addi_ui32(0, 3482297128), 3482297128);
+        assert_eq!(addi_ui32(3482297128, 0), 3482297128);
+        assert_eq!(addi_ui32(1, 3482297128), 3482297129);
+        assert_eq!(addi_ui32(3482297128, 1), 3482297129);
+        assert_eq!(addi_ui32(2, 3482297128), 3482297130);
+        assert_eq!(addi_ui32(3482297128, 2), 3482297130);
+        assert_eq!(addi_ui32(3, 3482297128), 3482297131);
+        assert_eq!(addi_ui32(3482297128, 3), 3482297131);
+        assert_eq!(addi_ui32(4, 3482297128), 3482297132);
+        assert_eq!(addi_ui32(3482297128, 4), 3482297132);
+        assert_eq!(addi_ui32(2119154652, 2119154652), 4238309304);
+        assert_eq!(addi_ui32(0, 4294967294), 4294967294);
+        assert_eq!(addi_ui32(4294967294, 0), 4294967294);
+        assert_eq!(addi_ui32(0, 4294967295), 4294967295);
+        assert_eq!(addi_ui32(1, 4294967294), 4294967295);
+        assert_eq!(addi_ui32(4294967294, 1), 4294967295);
+        assert_eq!(addi_ui32(4294967295, 0), 4294967295);
+        assert_eq!(addi_ui64(0, 0), 0);
+        assert_eq!(addi_ui64(0, 1), 1);
+        assert_eq!(addi_ui64(1, 0), 1);
+        assert_eq!(addi_ui64(0, 2), 2);
+        assert_eq!(addi_ui64(1, 1), 2);
+        assert_eq!(addi_ui64(2, 0), 2);
+        assert_eq!(addi_ui64(0, 3), 3);
+        assert_eq!(addi_ui64(1, 2), 3);
+        assert_eq!(addi_ui64(2, 1), 3);
+        assert_eq!(addi_ui64(3, 0), 3);
+        assert_eq!(addi_ui64(0, 4), 4);
+        assert_eq!(addi_ui64(1, 3), 4);
+        assert_eq!(addi_ui64(2, 2), 4);
+        assert_eq!(addi_ui64(3, 1), 4);
+        assert_eq!(addi_ui64(4, 0), 4);
+        assert_eq!(addi_ui64(1, 4), 5);
+        assert_eq!(addi_ui64(2, 3), 5);
+        assert_eq!(addi_ui64(3, 2), 5);
+        assert_eq!(addi_ui64(4, 1), 5);
+        assert_eq!(addi_ui64(2, 4), 6);
+        assert_eq!(addi_ui64(3, 3), 6);
+        assert_eq!(addi_ui64(4, 2), 6);
+        assert_eq!(addi_ui64(3, 4), 7);
+        assert_eq!(addi_ui64(4, 3), 7);
+        assert_eq!(addi_ui64(4, 4), 8);
+        assert_eq!(addi_ui64(0, 191084152064409600), 191084152064409600);
+        assert_eq!(addi_ui64(191084152064409600, 0), 191084152064409600);
+        assert_eq!(addi_ui64(1, 191084152064409600), 191084152064409601);
+        assert_eq!(addi_ui64(191084152064409600, 1), 191084152064409601);
+        assert_eq!(addi_ui64(2, 191084152064409600), 191084152064409602);
+        assert_eq!(addi_ui64(191084152064409600, 2), 191084152064409602);
+        assert_eq!(addi_ui64(3, 191084152064409600), 191084152064409603);
+        assert_eq!(addi_ui64(191084152064409600, 3), 191084152064409603);
+        assert_eq!(addi_ui64(4, 191084152064409600), 191084152064409604);
+        assert_eq!(addi_ui64(191084152064409600, 4), 191084152064409604);
+        assert_eq!(
+            addi_ui64(191084152064409600, 191084152064409600),
+            382168304128819200
+        );
+        assert_eq!(addi_ui64(0, 11015955194427482112), 11015955194427482112);
+        assert_eq!(addi_ui64(11015955194427482112, 0), 11015955194427482112);
+        assert_eq!(addi_ui64(1, 11015955194427482112), 11015955194427482113);
+        assert_eq!(addi_ui64(11015955194427482112, 1), 11015955194427482113);
+        assert_eq!(addi_ui64(2, 11015955194427482112), 11015955194427482114);
+        assert_eq!(addi_ui64(11015955194427482112, 2), 11015955194427482114);
+        assert_eq!(addi_ui64(3, 11015955194427482112), 11015955194427482115);
+        assert_eq!(addi_ui64(11015955194427482112, 3), 11015955194427482115);
+        assert_eq!(addi_ui64(4, 11015955194427482112), 11015955194427482116);
+        assert_eq!(addi_ui64(11015955194427482112, 4), 11015955194427482116);
+        assert_eq!(
+            addi_ui64(191084152064409600, 11015955194427482112),
+            11207039346491891712
+        );
+        assert_eq!(
+            addi_ui64(11015955194427482112, 191084152064409600),
+            11207039346491891712
+        );
+        assert_eq!(addi_ui64(0, 16990600415051759616), 16990600415051759616);
+        assert_eq!(addi_ui64(16990600415051759616, 0), 16990600415051759616);
+        assert_eq!(addi_ui64(1, 16990600415051759616), 16990600415051759617);
+        assert_eq!(addi_ui64(16990600415051759616, 1), 16990600415051759617);
+        assert_eq!(addi_ui64(2, 16990600415051759616), 16990600415051759618);
+        assert_eq!(addi_ui64(16990600415051759616, 2), 16990600415051759618);
+        assert_eq!(addi_ui64(3, 16990600415051759616), 16990600415051759619);
+        assert_eq!(addi_ui64(16990600415051759616, 3), 16990600415051759619);
+        assert_eq!(addi_ui64(4, 16990600415051759616), 16990600415051759620);
+        assert_eq!(addi_ui64(16990600415051759616, 4), 16990600415051759620);
+        assert_eq!(
+            addi_ui64(191084152064409600, 16990600415051759616),
+            17181684567116169216
+        );
+        assert_eq!(
+            addi_ui64(16990600415051759616, 191084152064409600),
+            17181684567116169216
+        );
+        assert_eq!(addi_ui64(0, 18446744073709551614), 18446744073709551614);
+        assert_eq!(addi_ui64(18446744073709551614, 0), 18446744073709551614);
+        assert_eq!(addi_ui64(0, 18446744073709551615), 18446744073709551615);
+        assert_eq!(addi_ui64(1, 18446744073709551614), 18446744073709551615);
+        assert_eq!(addi_ui64(18446744073709551614, 1), 18446744073709551615);
+        assert_eq!(addi_ui64(18446744073709551615, 0), 18446744073709551615);
+        assert_eq!(addi_ui8(0, 0), 0);
+        assert_eq!(addi_ui8(0, 1), 1);
+        assert_eq!(addi_ui8(1, 0), 1);
+        assert_eq!(addi_ui8(0, 2), 2);
+        assert_eq!(addi_ui8(1, 1), 2);
+        assert_eq!(addi_ui8(2, 0), 2);
+        assert_eq!(addi_ui8(0, 3), 3);
+        assert_eq!(addi_ui8(1, 2), 3);
+        assert_eq!(addi_ui8(2, 1), 3);
+        assert_eq!(addi_ui8(3, 0), 3);
+        assert_eq!(addi_ui8(0, 4), 4);
+        assert_eq!(addi_ui8(1, 3), 4);
+        assert_eq!(addi_ui8(2, 2), 4);
+        assert_eq!(addi_ui8(3, 1), 4);
+        assert_eq!(addi_ui8(4, 0), 4);
+        assert_eq!(addi_ui8(1, 4), 5);
+        assert_eq!(addi_ui8(2, 3), 5);
+        assert_eq!(addi_ui8(3, 2), 5);
+        assert_eq!(addi_ui8(4, 1), 5);
+        assert_eq!(addi_ui8(2, 4), 6);
+        assert_eq!(addi_ui8(3, 3), 6);
+        assert_eq!(addi_ui8(4, 2), 6);
+        assert_eq!(addi_ui8(3, 4), 7);
+        assert_eq!(addi_ui8(4, 3), 7);
+        assert_eq!(addi_ui8(4, 4), 8);
+        assert_eq!(addi_ui8(0, 72), 72);
+        assert_eq!(addi_ui8(72, 0), 72);
+        assert_eq!(addi_ui8(1, 72), 73);
+        assert_eq!(addi_ui8(72, 1), 73);
+        assert_eq!(addi_ui8(2, 72), 74);
+        assert_eq!(addi_ui8(72, 2), 74);
+        assert_eq!(addi_ui8(3, 72), 75);
+        assert_eq!(addi_ui8(72, 3), 75);
+        assert_eq!(addi_ui8(4, 72), 76);
+        assert_eq!(addi_ui8(72, 4), 76);
+        assert_eq!(addi_ui8(0, 100), 100);
+        assert_eq!(addi_ui8(100, 0), 100);
+        assert_eq!(addi_ui8(1, 100), 101);
+        assert_eq!(addi_ui8(100, 1), 101);
+        assert_eq!(addi_ui8(2, 100), 102);
+        assert_eq!(addi_ui8(100, 2), 102);
+        assert_eq!(addi_ui8(3, 100), 103);
+        assert_eq!(addi_ui8(100, 3), 103);
+        assert_eq!(addi_ui8(4, 100), 104);
+        assert_eq!(addi_ui8(100, 4), 104);
+        assert_eq!(addi_ui8(72, 72), 144);
+        assert_eq!(addi_ui8(0, 162), 162);
+        assert_eq!(addi_ui8(162, 0), 162);
+        assert_eq!(addi_ui8(1, 162), 163);
+        assert_eq!(addi_ui8(162, 1), 163);
+        assert_eq!(addi_ui8(2, 162), 164);
+        assert_eq!(addi_ui8(162, 2), 164);
+        assert_eq!(addi_ui8(3, 162), 165);
+        assert_eq!(addi_ui8(162, 3), 165);
+        assert_eq!(addi_ui8(4, 162), 166);
+        assert_eq!(addi_ui8(162, 4), 166);
+        assert_eq!(addi_ui8(72, 100), 172);
+        assert_eq!(addi_ui8(100, 72), 172);
+        assert_eq!(addi_ui8(100, 100), 200);
+        assert_eq!(addi_ui8(72, 162), 234);
+        assert_eq!(addi_ui8(162, 72), 234);
+        assert_eq!(addi_ui8(0, 254), 254);
+        assert_eq!(addi_ui8(254, 0), 254);
+        assert_eq!(addi_ui8(0, 255), 255);
+        assert_eq!(addi_ui8(1, 254), 255);
+        assert_eq!(addi_ui8(254, 1), 255);
+        assert_eq!(addi_ui8(255, 0), 255);
+        assert_eq!(divi_si16(-32768, 1), -32768);
+        assert_eq!(divi_si16(-32767, 1), -32767);
+        assert_eq!(divi_si16(-32547, 1), -32547);
+        assert_eq!(divi_si16(-32768, 2), -16384);
+        assert_eq!(divi_si16(-32767, 2), -16383);
+        assert_eq!(divi_si16(-32547, 2), -16273);
+        assert_eq!(divi_si16(-32768, 3), -10922);
+        assert_eq!(divi_si16(-32767, 3), -10922);
+        assert_eq!(divi_si16(-32547, 3), -10849);
+        assert_eq!(divi_si16(-32768, 4), -8192);
+        assert_eq!(divi_si16(-32767, 4), -8191);
+        assert_eq!(divi_si16(-32547, 4), -8136);
+        assert_eq!(divi_si16(-32768, 10486), -3);
+        assert_eq!(divi_si16(-32767, 10486), -3);
+        assert_eq!(divi_si16(-32547, 10486), -3);
+        assert_eq!(divi_si16(-32768, 16514), -1);
+        assert_eq!(divi_si16(-32768, 32766), -1);
+        assert_eq!(divi_si16(-32768, 32767), -1);
+        assert_eq!(divi_si16(-32767, 16514), -1);
+        assert_eq!(divi_si16(-32767, 32766), -1);
+        assert_eq!(divi_si16(-32767, 32767), -1);
+        assert_eq!(divi_si16(-32547, 16514), -1);
+        assert_eq!(divi_si16(32766, -32547), -1);
+        assert_eq!(divi_si16(32767, -32767), -1);
+        assert_eq!(divi_si16(32767, -32547), -1);
+        assert_eq!(divi_si16(-32767, -32768), 0);
+        assert_eq!(divi_si16(-32547, -32768), 0);
+        assert_eq!(divi_si16(-32547, -32767), 0);
+        assert_eq!(divi_si16(-32547, 32766), 0);
+        assert_eq!(divi_si16(-32547, 32767), 0);
+        assert_eq!(divi_si16(0, -32768), 0);
+        assert_eq!(divi_si16(0, -32767), 0);
+        assert_eq!(divi_si16(0, -32547), 0);
+        assert_eq!(divi_si16(0, 1), 0);
+        assert_eq!(divi_si16(0, 2), 0);
+        assert_eq!(divi_si16(0, 3), 0);
+        assert_eq!(divi_si16(0, 4), 0);
+        assert_eq!(divi_si16(0, 10486), 0);
+        assert_eq!(divi_si16(0, 16514), 0);
+        assert_eq!(divi_si16(0, 32766), 0);
+        assert_eq!(divi_si16(0, 32767), 0);
+        assert_eq!(divi_si16(1, -32768), 0);
+        assert_eq!(divi_si16(1, -32767), 0);
+        assert_eq!(divi_si16(1, -32547), 0);
+        assert_eq!(divi_si16(1, 2), 0);
+        assert_eq!(divi_si16(1, 3), 0);
+        assert_eq!(divi_si16(1, 4), 0);
+        assert_eq!(divi_si16(1, 10486), 0);
+        assert_eq!(divi_si16(1, 16514), 0);
+        assert_eq!(divi_si16(1, 32766), 0);
+        assert_eq!(divi_si16(1, 32767), 0);
+        assert_eq!(divi_si16(2, -32768), 0);
+        assert_eq!(divi_si16(2, -32767), 0);
+        assert_eq!(divi_si16(2, -32547), 0);
+        assert_eq!(divi_si16(2, 3), 0);
+        assert_eq!(divi_si16(2, 4), 0);
+        assert_eq!(divi_si16(2, 10486), 0);
+        assert_eq!(divi_si16(2, 16514), 0);
+        assert_eq!(divi_si16(2, 32766), 0);
+        assert_eq!(divi_si16(2, 32767), 0);
+        assert_eq!(divi_si16(3, -32768), 0);
+        assert_eq!(divi_si16(3, -32767), 0);
+        assert_eq!(divi_si16(3, -32547), 0);
+        assert_eq!(divi_si16(3, 4), 0);
+        assert_eq!(divi_si16(3, 10486), 0);
+        assert_eq!(divi_si16(3, 16514), 0);
+        assert_eq!(divi_si16(3, 32766), 0);
+        assert_eq!(divi_si16(3, 32767), 0);
+        assert_eq!(divi_si16(4, -32768), 0);
+        assert_eq!(divi_si16(4, -32767), 0);
+        assert_eq!(divi_si16(4, -32547), 0);
+        assert_eq!(divi_si16(4, 10486), 0);
+        assert_eq!(divi_si16(4, 16514), 0);
+        assert_eq!(divi_si16(4, 32766), 0);
+        assert_eq!(divi_si16(4, 32767), 0);
+        assert_eq!(divi_si16(10486, -32768), 0);
+        assert_eq!(divi_si16(10486, -32767), 0);
+        assert_eq!(divi_si16(10486, -32547), 0);
+        assert_eq!(divi_si16(10486, 16514), 0);
+        assert_eq!(divi_si16(10486, 32766), 0);
+        assert_eq!(divi_si16(10486, 32767), 0);
+        assert_eq!(divi_si16(16514, -32768), 0);
+        assert_eq!(divi_si16(16514, -32767), 0);
+        assert_eq!(divi_si16(16514, -32547), 0);
+        assert_eq!(divi_si16(16514, 32766), 0);
+        assert_eq!(divi_si16(16514, 32767), 0);
+        assert_eq!(divi_si16(32766, -32768), 0);
+        assert_eq!(divi_si16(32766, -32767), 0);
+        assert_eq!(divi_si16(32766, 32767), 0);
+        assert_eq!(divi_si16(32767, -32768), 0);
+        assert_eq!(divi_si16(-32768, -32768), 1);
+        assert_eq!(divi_si16(-32768, -32767), 1);
+        assert_eq!(divi_si16(-32768, -32547), 1);
+        assert_eq!(divi_si16(-32767, -32767), 1);
+        assert_eq!(divi_si16(-32767, -32547), 1);
+        assert_eq!(divi_si16(-32547, -32547), 1);
+        assert_eq!(divi_si16(1, 1), 1);
+        assert_eq!(divi_si16(2, 2), 1);
+        assert_eq!(divi_si16(3, 2), 1);
+        assert_eq!(divi_si16(3, 3), 1);
+        assert_eq!(divi_si16(4, 3), 1);
+        assert_eq!(divi_si16(4, 4), 1);
+        assert_eq!(divi_si16(10486, 10486), 1);
+        assert_eq!(divi_si16(16514, 10486), 1);
+        assert_eq!(divi_si16(16514, 16514), 1);
+        assert_eq!(divi_si16(32766, 16514), 1);
+        assert_eq!(divi_si16(32766, 32766), 1);
+        assert_eq!(divi_si16(32767, 16514), 1);
+        assert_eq!(divi_si16(32767, 32766), 1);
+        assert_eq!(divi_si16(32767, 32767), 1);
+        assert_eq!(divi_si16(2, 1), 2);
+        assert_eq!(divi_si16(4, 2), 2);
+        assert_eq!(divi_si16(3, 1), 3);
+        assert_eq!(divi_si16(32766, 10486), 3);
+        assert_eq!(divi_si16(32767, 10486), 3);
+        assert_eq!(divi_si16(4, 1), 4);
+        assert_eq!(divi_si16(10486, 4), 2621);
+        assert_eq!(divi_si16(10486, 3), 3495);
+        assert_eq!(divi_si16(16514, 4), 4128);
+        assert_eq!(divi_si16(10486, 2), 5243);
+        assert_eq!(divi_si16(16514, 3), 5504);
+        assert_eq!(divi_si16(32766, 4), 8191);
+        assert_eq!(divi_si16(32767, 4), 8191);
+        assert_eq!(divi_si16(16514, 2), 8257);
+        assert_eq!(divi_si16(10486, 1), 10486);
+        assert_eq!(divi_si16(32766, 3), 10922);
+        assert_eq!(divi_si16(32767, 3), 10922);
+        assert_eq!(divi_si16(32766, 2), 16383);
+        assert_eq!(divi_si16(32767, 2), 16383);
+        assert_eq!(divi_si16(16514, 1), 16514);
+        assert_eq!(divi_si16(32766, 1), 32766);
+        assert_eq!(divi_si16(32767, 1), 32767);
+        assert_eq!(divi_si32(-2147483648, 1), -2147483648);
+        assert_eq!(divi_si32(-2147483647, 1), -2147483647);
+        assert_eq!(divi_si32(-1713183800, 1), -1713183800);
+        assert_eq!(divi_si32(-1252582164, 1), -1252582164);
+        assert_eq!(divi_si32(-2147483648, 2), -1073741824);
+        assert_eq!(divi_si32(-2147483647, 2), -1073741823);
+        assert_eq!(divi_si32(-1035405763, 1), -1035405763);
+        assert_eq!(divi_si32(-1713183800, 2), -856591900);
+        assert_eq!(divi_si32(-2147483648, 3), -715827882);
+        assert_eq!(divi_si32(-2147483647, 3), -715827882);
+        assert_eq!(divi_si32(-1252582164, 2), -626291082);
+        assert_eq!(divi_si32(-1713183800, 3), -571061266);
+        assert_eq!(divi_si32(-2147483648, 4), -536870912);
+        assert_eq!(divi_si32(-2147483647, 4), -536870911);
+        assert_eq!(divi_si32(-1035405763, 2), -517702881);
+        assert_eq!(divi_si32(-1713183800, 4), -428295950);
+        assert_eq!(divi_si32(-1252582164, 3), -417527388);
+        assert_eq!(divi_si32(-1035405763, 3), -345135254);
+        assert_eq!(divi_si32(-1252582164, 4), -313145541);
+        assert_eq!(divi_si32(-1035405763, 4), -258851440);
+        assert_eq!(divi_si32(2147483646, -1035405763), -2);
+        assert_eq!(divi_si32(2147483647, -1035405763), -2);
+        assert_eq!(divi_si32(-2147483648, 2147483646), -1);
+        assert_eq!(divi_si32(-2147483648, 2147483647), -1);
+        assert_eq!(divi_si32(-2147483647, 2147483646), -1);
+        assert_eq!(divi_si32(-2147483647, 2147483647), -1);
+        assert_eq!(divi_si32(2147483646, -1713183800), -1);
+        assert_eq!(divi_si32(2147483646, -1252582164), -1);
+        assert_eq!(divi_si32(2147483647, -2147483647), -1);
+        assert_eq!(divi_si32(2147483647, -1713183800), -1);
+        assert_eq!(divi_si32(2147483647, -1252582164), -1);
+        assert_eq!(divi_si32(-2147483647, -2147483648), 0);
+        assert_eq!(divi_si32(-1713183800, -2147483648), 0);
+        assert_eq!(divi_si32(-1713183800, -2147483647), 0);
+        assert_eq!(divi_si32(-1713183800, 2147483646), 0);
+        assert_eq!(divi_si32(-1713183800, 2147483647), 0);
+        assert_eq!(divi_si32(-1252582164, -2147483648), 0);
+        assert_eq!(divi_si32(-1252582164, -2147483647), 0);
+        assert_eq!(divi_si32(-1252582164, -1713183800), 0);
+        assert_eq!(divi_si32(-1252582164, 2147483646), 0);
+        assert_eq!(divi_si32(-1252582164, 2147483647), 0);
+        assert_eq!(divi_si32(-1035405763, -2147483648), 0);
+        assert_eq!(divi_si32(-1035405763, -2147483647), 0);
+        assert_eq!(divi_si32(-1035405763, -1713183800), 0);
+        assert_eq!(divi_si32(-1035405763, -1252582164), 0);
+        assert_eq!(divi_si32(-1035405763, 2147483646), 0);
+        assert_eq!(divi_si32(-1035405763, 2147483647), 0);
+        assert_eq!(divi_si32(0, -2147483648), 0);
+        assert_eq!(divi_si32(0, -2147483647), 0);
+        assert_eq!(divi_si32(0, -1713183800), 0);
+        assert_eq!(divi_si32(0, -1252582164), 0);
+        assert_eq!(divi_si32(0, -1035405763), 0);
+        assert_eq!(divi_si32(0, 1), 0);
+        assert_eq!(divi_si32(0, 2), 0);
+        assert_eq!(divi_si32(0, 3), 0);
+        assert_eq!(divi_si32(0, 4), 0);
+        assert_eq!(divi_si32(0, 2147483646), 0);
+        assert_eq!(divi_si32(0, 2147483647), 0);
+        assert_eq!(divi_si32(1, -2147483648), 0);
+        assert_eq!(divi_si32(1, -2147483647), 0);
+        assert_eq!(divi_si32(1, -1713183800), 0);
+        assert_eq!(divi_si32(1, -1252582164), 0);
+        assert_eq!(divi_si32(1, -1035405763), 0);
+        assert_eq!(divi_si32(1, 2), 0);
+        assert_eq!(divi_si32(1, 3), 0);
+        assert_eq!(divi_si32(1, 4), 0);
+        assert_eq!(divi_si32(1, 2147483646), 0);
+        assert_eq!(divi_si32(1, 2147483647), 0);
+        assert_eq!(divi_si32(2, -2147483648), 0);
+        assert_eq!(divi_si32(2, -2147483647), 0);
+        assert_eq!(divi_si32(2, -1713183800), 0);
+        assert_eq!(divi_si32(2, -1252582164), 0);
+        assert_eq!(divi_si32(2, -1035405763), 0);
+        assert_eq!(divi_si32(2, 3), 0);
+        assert_eq!(divi_si32(2, 4), 0);
+        assert_eq!(divi_si32(2, 2147483646), 0);
+        assert_eq!(divi_si32(2, 2147483647), 0);
+        assert_eq!(divi_si32(3, -2147483648), 0);
+        assert_eq!(divi_si32(3, -2147483647), 0);
+        assert_eq!(divi_si32(3, -1713183800), 0);
+        assert_eq!(divi_si32(3, -1252582164), 0);
+        assert_eq!(divi_si32(3, -1035405763), 0);
+        assert_eq!(divi_si32(3, 4), 0);
+        assert_eq!(divi_si32(3, 2147483646), 0);
+        assert_eq!(divi_si32(3, 2147483647), 0);
+        assert_eq!(divi_si32(4, -2147483648), 0);
+        assert_eq!(divi_si32(4, -2147483647), 0);
+        assert_eq!(divi_si32(4, -1713183800), 0);
+        assert_eq!(divi_si32(4, -1252582164), 0);
+        assert_eq!(divi_si32(4, -1035405763), 0);
+        assert_eq!(divi_si32(4, 2147483646), 0);
+        assert_eq!(divi_si32(4, 2147483647), 0);
+        assert_eq!(divi_si32(2147483646, -2147483648), 0);
+        assert_eq!(divi_si32(2147483646, -2147483647), 0);
+        assert_eq!(divi_si32(2147483646, 2147483647), 0);
+        assert_eq!(divi_si32(2147483647, -2147483648), 0);
+        assert_eq!(divi_si32(-2147483648, -2147483648), 1);
+        assert_eq!(divi_si32(-2147483648, -2147483647), 1);
+        assert_eq!(divi_si32(-2147483648, -1713183800), 1);
+        assert_eq!(divi_si32(-2147483648, -1252582164), 1);
+        assert_eq!(divi_si32(-2147483647, -2147483647), 1);
+        assert_eq!(divi_si32(-2147483647, -1713183800), 1);
+        assert_eq!(divi_si32(-2147483647, -1252582164), 1);
+        assert_eq!(divi_si32(-1713183800, -1713183800), 1);
+        assert_eq!(divi_si32(-1713183800, -1252582164), 1);
+        assert_eq!(divi_si32(-1713183800, -1035405763), 1);
+        assert_eq!(divi_si32(-1252582164, -1252582164), 1);
+        assert_eq!(divi_si32(-1252582164, -1035405763), 1);
+        assert_eq!(divi_si32(-1035405763, -1035405763), 1);
+        assert_eq!(divi_si32(1, 1), 1);
+        assert_eq!(divi_si32(2, 2), 1);
+        assert_eq!(divi_si32(3, 2), 1);
+        assert_eq!(divi_si32(3, 3), 1);
+        assert_eq!(divi_si32(4, 3), 1);
+        assert_eq!(divi_si32(4, 4), 1);
+        assert_eq!(divi_si32(2147483646, 2147483646), 1);
+        assert_eq!(divi_si32(2147483647, 2147483646), 1);
+        assert_eq!(divi_si32(2147483647, 2147483647), 1);
+        assert_eq!(divi_si32(-2147483648, -1035405763), 2);
+        assert_eq!(divi_si32(-2147483647, -1035405763), 2);
+        assert_eq!(divi_si32(2, 1), 2);
+        assert_eq!(divi_si32(4, 2), 2);
+        assert_eq!(divi_si32(3, 1), 3);
+        assert_eq!(divi_si32(4, 1), 4);
+        assert_eq!(divi_si32(2147483646, 4), 536870911);
+        assert_eq!(divi_si32(2147483647, 4), 536870911);
+        assert_eq!(divi_si32(2147483646, 3), 715827882);
+        assert_eq!(divi_si32(2147483647, 3), 715827882);
+        assert_eq!(divi_si32(2147483646, 2), 1073741823);
+        assert_eq!(divi_si32(2147483647, 2), 1073741823);
+        assert_eq!(divi_si32(2147483646, 1), 2147483646);
+        assert_eq!(divi_si32(2147483647, 1), 2147483647);
+        assert_eq!(divi_si64(-9223372036854775808, 1), -9223372036854775808);
+        assert_eq!(divi_si64(-9223372036854775807, 1), -9223372036854775807);
+        assert_eq!(divi_si64(-9223372036854775808, 2), -4611686018427387904);
+        assert_eq!(divi_si64(-9223372036854775807, 2), -4611686018427387903);
+        assert_eq!(divi_si64(-9223372036854775808, 3), -3074457345618258602);
+        assert_eq!(divi_si64(-9223372036854775807, 3), -3074457345618258602);
+        assert_eq!(divi_si64(-9223372036854775808, 4), -2305843009213693952);
+        assert_eq!(divi_si64(-9223372036854775807, 4), -2305843009213693951);
+        assert_eq!(divi_si64(-1741927215160008704, 1), -1741927215160008704);
+        assert_eq!(divi_si64(-1328271339354574848, 1), -1328271339354574848);
+        assert_eq!(divi_si64(-1741927215160008704, 2), -870963607580004352);
+        assert_eq!(divi_si64(-1328271339354574848, 2), -664135669677287424);
+        assert_eq!(divi_si64(-1741927215160008704, 3), -580642405053336234);
+        assert_eq!(divi_si64(-1328271339354574848, 3), -442757113118191616);
+        assert_eq!(divi_si64(-1741927215160008704, 4), -435481803790002176);
+        assert_eq!(divi_si64(-1328271339354574848, 4), -332067834838643712);
+        assert_eq!(divi_si64(9223372036854775806, -1328271339354574848), -6);
+        assert_eq!(divi_si64(9223372036854775807, -1328271339354574848), -6);
+        assert_eq!(divi_si64(9223372036854775806, -1741927215160008704), -5);
+        assert_eq!(divi_si64(9223372036854775807, -1741927215160008704), -5);
+        assert_eq!(divi_si64(5577148965131116544, -1328271339354574848), -4);
+        assert_eq!(divi_si64(5577148965131116544, -1741927215160008704), -3);
+        assert_eq!(divi_si64(-9223372036854775808, 5577148965131116544), -1);
+        assert_eq!(divi_si64(-9223372036854775808, 9223372036854775806), -1);
+        assert_eq!(divi_si64(-9223372036854775808, 9223372036854775807), -1);
+        assert_eq!(divi_si64(-9223372036854775807, 5577148965131116544), -1);
+        assert_eq!(divi_si64(-9223372036854775807, 9223372036854775806), -1);
+        assert_eq!(divi_si64(-9223372036854775807, 9223372036854775807), -1);
+        assert_eq!(divi_si64(9223372036854775807, -9223372036854775807), -1);
+        assert_eq!(divi_si64(-9223372036854775807, -9223372036854775808), 0);
+        assert_eq!(divi_si64(-1741927215160008704, -9223372036854775808), 0);
+        assert_eq!(divi_si64(-1741927215160008704, -9223372036854775807), 0);
+        assert_eq!(divi_si64(-1741927215160008704, 5577148965131116544), 0);
+        assert_eq!(divi_si64(-1741927215160008704, 9223372036854775806), 0);
+        assert_eq!(divi_si64(-1741927215160008704, 9223372036854775807), 0);
+        assert_eq!(divi_si64(-1328271339354574848, -9223372036854775808), 0);
+        assert_eq!(divi_si64(-1328271339354574848, -9223372036854775807), 0);
+        assert_eq!(divi_si64(-1328271339354574848, -1741927215160008704), 0);
+        assert_eq!(divi_si64(-1328271339354574848, 5577148965131116544), 0);
+        assert_eq!(divi_si64(-1328271339354574848, 9223372036854775806), 0);
+        assert_eq!(divi_si64(-1328271339354574848, 9223372036854775807), 0);
+        assert_eq!(divi_si64(0, -9223372036854775808), 0);
+        assert_eq!(divi_si64(0, -9223372036854775807), 0);
+        assert_eq!(divi_si64(0, -1741927215160008704), 0);
+        assert_eq!(divi_si64(0, -1328271339354574848), 0);
+        assert_eq!(divi_si64(0, 1), 0);
+        assert_eq!(divi_si64(0, 2), 0);
+        assert_eq!(divi_si64(0, 3), 0);
+        assert_eq!(divi_si64(0, 4), 0);
+        assert_eq!(divi_si64(0, 5577148965131116544), 0);
+        assert_eq!(divi_si64(0, 9223372036854775806), 0);
+        assert_eq!(divi_si64(0, 9223372036854775807), 0);
+        assert_eq!(divi_si64(1, -9223372036854775808), 0);
+        assert_eq!(divi_si64(1, -9223372036854775807), 0);
+        assert_eq!(divi_si64(1, -1741927215160008704), 0);
+        assert_eq!(divi_si64(1, -1328271339354574848), 0);
+        assert_eq!(divi_si64(1, 2), 0);
+        assert_eq!(divi_si64(1, 3), 0);
+        assert_eq!(divi_si64(1, 4), 0);
+        assert_eq!(divi_si64(1, 5577148965131116544), 0);
+        assert_eq!(divi_si64(1, 9223372036854775806), 0);
+        assert_eq!(divi_si64(1, 9223372036854775807), 0);
+        assert_eq!(divi_si64(2, -9223372036854775808), 0);
+        assert_eq!(divi_si64(2, -9223372036854775807), 0);
+        assert_eq!(divi_si64(2, -1741927215160008704), 0);
+        assert_eq!(divi_si64(2, -1328271339354574848), 0);
+        assert_eq!(divi_si64(2, 3), 0);
+        assert_eq!(divi_si64(2, 4), 0);
+        assert_eq!(divi_si64(2, 5577148965131116544), 0);
+        assert_eq!(divi_si64(2, 9223372036854775806), 0);
+        assert_eq!(divi_si64(2, 9223372036854775807), 0);
+        assert_eq!(divi_si64(3, -9223372036854775808), 0);
+        assert_eq!(divi_si64(3, -9223372036854775807), 0);
+        assert_eq!(divi_si64(3, -1741927215160008704), 0);
+        assert_eq!(divi_si64(3, -1328271339354574848), 0);
+        assert_eq!(divi_si64(3, 4), 0);
+        assert_eq!(divi_si64(3, 5577148965131116544), 0);
+        assert_eq!(divi_si64(3, 9223372036854775806), 0);
+        assert_eq!(divi_si64(3, 9223372036854775807), 0);
+        assert_eq!(divi_si64(4, -9223372036854775808), 0);
+        assert_eq!(divi_si64(4, -9223372036854775807), 0);
+        assert_eq!(divi_si64(4, -1741927215160008704), 0);
+        assert_eq!(divi_si64(4, -1328271339354574848), 0);
+        assert_eq!(divi_si64(4, 5577148965131116544), 0);
+        assert_eq!(divi_si64(4, 9223372036854775806), 0);
+        assert_eq!(divi_si64(4, 9223372036854775807), 0);
+        assert_eq!(divi_si64(5577148965131116544, -9223372036854775808), 0);
+        assert_eq!(divi_si64(5577148965131116544, -9223372036854775807), 0);
+        assert_eq!(divi_si64(5577148965131116544, 9223372036854775806), 0);
+        assert_eq!(divi_si64(5577148965131116544, 9223372036854775807), 0);
+        assert_eq!(divi_si64(9223372036854775806, -9223372036854775808), 0);
+        assert_eq!(divi_si64(9223372036854775806, -9223372036854775807), 0);
+        assert_eq!(divi_si64(9223372036854775806, 9223372036854775807), 0);
+        assert_eq!(divi_si64(9223372036854775807, -9223372036854775808), 0);
+        assert_eq!(divi_si64(-9223372036854775808, -9223372036854775808), 1);
+        assert_eq!(divi_si64(-9223372036854775808, -9223372036854775807), 1);
+        assert_eq!(divi_si64(-9223372036854775807, -9223372036854775807), 1);
+        assert_eq!(divi_si64(-1741927215160008704, -1741927215160008704), 1);
+        assert_eq!(divi_si64(-1741927215160008704, -1328271339354574848), 1);
+        assert_eq!(divi_si64(-1328271339354574848, -1328271339354574848), 1);
+        assert_eq!(divi_si64(1, 1), 1);
+        assert_eq!(divi_si64(2, 2), 1);
+        assert_eq!(divi_si64(3, 2), 1);
+        assert_eq!(divi_si64(3, 3), 1);
+        assert_eq!(divi_si64(4, 3), 1);
+        assert_eq!(divi_si64(4, 4), 1);
+        assert_eq!(divi_si64(5577148965131116544, 5577148965131116544), 1);
+        assert_eq!(divi_si64(9223372036854775806, 5577148965131116544), 1);
+        assert_eq!(divi_si64(9223372036854775806, 9223372036854775806), 1);
+        assert_eq!(divi_si64(9223372036854775807, 5577148965131116544), 1);
+        assert_eq!(divi_si64(9223372036854775807, 9223372036854775806), 1);
+        assert_eq!(divi_si64(9223372036854775807, 9223372036854775807), 1);
+        assert_eq!(divi_si64(2, 1), 2);
+        assert_eq!(divi_si64(4, 2), 2);
+        assert_eq!(divi_si64(3, 1), 3);
+        assert_eq!(divi_si64(4, 1), 4);
+        assert_eq!(divi_si64(-9223372036854775808, -1741927215160008704), 5);
+        assert_eq!(divi_si64(-9223372036854775807, -1741927215160008704), 5);
+        assert_eq!(divi_si64(-9223372036854775808, -1328271339354574848), 6);
+        assert_eq!(divi_si64(-9223372036854775807, -1328271339354574848), 6);
+        assert_eq!(divi_si64(5577148965131116544, 4), 1394287241282779136);
+        assert_eq!(divi_si64(5577148965131116544, 3), 1859049655043705514);
+        assert_eq!(divi_si64(9223372036854775806, 4), 2305843009213693951);
+        assert_eq!(divi_si64(9223372036854775807, 4), 2305843009213693951);
+        assert_eq!(divi_si64(5577148965131116544, 2), 2788574482565558272);
+        assert_eq!(divi_si64(9223372036854775806, 3), 3074457345618258602);
+        assert_eq!(divi_si64(9223372036854775807, 3), 3074457345618258602);
+        assert_eq!(divi_si64(9223372036854775806, 2), 4611686018427387903);
+        assert_eq!(divi_si64(9223372036854775807, 2), 4611686018427387903);
+        assert_eq!(divi_si64(5577148965131116544, 1), 5577148965131116544);
+        assert_eq!(divi_si64(9223372036854775806, 1), 9223372036854775806);
+        assert_eq!(divi_si64(9223372036854775807, 1), 9223372036854775807);
+        assert_eq!(divi_si8(-128, 1), -128);
+        assert_eq!(divi_si8(-127, 1), -127);
+        assert_eq!(divi_si8(-128, 2), -64);
+        assert_eq!(divi_si8(-127, 2), -63);
+        assert_eq!(divi_si8(-128, 3), -42);
+        assert_eq!(divi_si8(-127, 3), -42);
+        assert_eq!(divi_si8(-128, 4), -32);
+        assert_eq!(divi_si8(-127, 4), -31);
+        assert_eq!(divi_si8(-128, 16), -8);
+        assert_eq!(divi_si8(-127, 16), -7);
+        assert_eq!(divi_si8(-128, 126), -1);
+        assert_eq!(divi_si8(-128, 127), -1);
+        assert_eq!(divi_si8(-127, 126), -1);
+        assert_eq!(divi_si8(-127, 127), -1);
+        assert_eq!(divi_si8(127, -127), -1);
+        assert_eq!(divi_si8(-127, -128), 0);
+        assert_eq!(divi_si8(0, -128), 0);
+        assert_eq!(divi_si8(0, -127), 0);
+        assert_eq!(divi_si8(0, 1), 0);
+        assert_eq!(divi_si8(0, 2), 0);
+        assert_eq!(divi_si8(0, 3), 0);
+        assert_eq!(divi_si8(0, 4), 0);
+        assert_eq!(divi_si8(0, 16), 0);
+        assert_eq!(divi_si8(0, 126), 0);
+        assert_eq!(divi_si8(0, 127), 0);
+        assert_eq!(divi_si8(1, -128), 0);
+        assert_eq!(divi_si8(1, -127), 0);
+        assert_eq!(divi_si8(1, 2), 0);
+        assert_eq!(divi_si8(1, 3), 0);
+        assert_eq!(divi_si8(1, 4), 0);
+        assert_eq!(divi_si8(1, 16), 0);
+        assert_eq!(divi_si8(1, 126), 0);
+        assert_eq!(divi_si8(1, 127), 0);
+        assert_eq!(divi_si8(2, -128), 0);
+        assert_eq!(divi_si8(2, -127), 0);
+        assert_eq!(divi_si8(2, 3), 0);
+        assert_eq!(divi_si8(2, 4), 0);
+        assert_eq!(divi_si8(2, 16), 0);
+        assert_eq!(divi_si8(2, 126), 0);
+        assert_eq!(divi_si8(2, 127), 0);
+        assert_eq!(divi_si8(3, -128), 0);
+        assert_eq!(divi_si8(3, -127), 0);
+        assert_eq!(divi_si8(3, 4), 0);
+        assert_eq!(divi_si8(3, 16), 0);
+        assert_eq!(divi_si8(3, 126), 0);
+        assert_eq!(divi_si8(3, 127), 0);
+        assert_eq!(divi_si8(4, -128), 0);
+        assert_eq!(divi_si8(4, -127), 0);
+        assert_eq!(divi_si8(4, 16), 0);
+        assert_eq!(divi_si8(4, 126), 0);
+        assert_eq!(divi_si8(4, 127), 0);
+        assert_eq!(divi_si8(16, -128), 0);
+        assert_eq!(divi_si8(16, -127), 0);
+        assert_eq!(divi_si8(16, 126), 0);
+        assert_eq!(divi_si8(16, 127), 0);
+        assert_eq!(divi_si8(126, -128), 0);
+        assert_eq!(divi_si8(126, -127), 0);
+        assert_eq!(divi_si8(126, 127), 0);
+        assert_eq!(divi_si8(127, -128), 0);
+        assert_eq!(divi_si8(-128, -128), 1);
+        assert_eq!(divi_si8(-128, -127), 1);
+        assert_eq!(divi_si8(-127, -127), 1);
+        assert_eq!(divi_si8(1, 1), 1);
+        assert_eq!(divi_si8(2, 2), 1);
+        assert_eq!(divi_si8(3, 2), 1);
+        assert_eq!(divi_si8(3, 3), 1);
+        assert_eq!(divi_si8(4, 3), 1);
+        assert_eq!(divi_si8(4, 4), 1);
+        assert_eq!(divi_si8(16, 16), 1);
+        assert_eq!(divi_si8(126, 126), 1);
+        assert_eq!(divi_si8(127, 126), 1);
+        assert_eq!(divi_si8(127, 127), 1);
+        assert_eq!(divi_si8(2, 1), 2);
+        assert_eq!(divi_si8(4, 2), 2);
+        assert_eq!(divi_si8(3, 1), 3);
+        assert_eq!(divi_si8(4, 1), 4);
+        assert_eq!(divi_si8(16, 4), 4);
+        assert_eq!(divi_si8(16, 3), 5);
+        assert_eq!(divi_si8(126, 16), 7);
+        assert_eq!(divi_si8(127, 16), 7);
+        assert_eq!(divi_si8(16, 2), 8);
+        assert_eq!(divi_si8(16, 1), 16);
+        assert_eq!(divi_si8(126, 4), 31);
+        assert_eq!(divi_si8(127, 4), 31);
+        assert_eq!(divi_si8(126, 3), 42);
+        assert_eq!(divi_si8(127, 3), 42);
+        assert_eq!(divi_si8(126, 2), 63);
+        assert_eq!(divi_si8(127, 2), 63);
+        assert_eq!(divi_si8(126, 1), 126);
+        assert_eq!(divi_si8(127, 1), 127);
+        assert_eq!(divi_ui16(0, 1), 0);
+        assert_eq!(divi_ui16(0, 2), 0);
+        assert_eq!(divi_ui16(0, 3), 0);
+        assert_eq!(divi_ui16(0, 4), 0);
+        assert_eq!(divi_ui16(0, 1717), 0);
+        assert_eq!(divi_ui16(0, 17988), 0);
+        assert_eq!(divi_ui16(0, 65096), 0);
+        assert_eq!(divi_ui16(0, 65534), 0);
+        assert_eq!(divi_ui16(0, 65535), 0);
+        assert_eq!(divi_ui16(1, 2), 0);
+        assert_eq!(divi_ui16(1, 3), 0);
+        assert_eq!(divi_ui16(1, 4), 0);
+        assert_eq!(divi_ui16(1, 1717), 0);
+        assert_eq!(divi_ui16(1, 17988), 0);
+        assert_eq!(divi_ui16(1, 65096), 0);
+        assert_eq!(divi_ui16(1, 65534), 0);
+        assert_eq!(divi_ui16(1, 65535), 0);
+        assert_eq!(divi_ui16(2, 3), 0);
+        assert_eq!(divi_ui16(2, 4), 0);
+        assert_eq!(divi_ui16(2, 1717), 0);
+        assert_eq!(divi_ui16(2, 17988), 0);
+        assert_eq!(divi_ui16(2, 65096), 0);
+        assert_eq!(divi_ui16(2, 65534), 0);
+        assert_eq!(divi_ui16(2, 65535), 0);
+        assert_eq!(divi_ui16(3, 4), 0);
+        assert_eq!(divi_ui16(3, 1717), 0);
+        assert_eq!(divi_ui16(3, 17988), 0);
+        assert_eq!(divi_ui16(3, 65096), 0);
+        assert_eq!(divi_ui16(3, 65534), 0);
+        assert_eq!(divi_ui16(3, 65535), 0);
+        assert_eq!(divi_ui16(4, 1717), 0);
+        assert_eq!(divi_ui16(4, 17988), 0);
+        assert_eq!(divi_ui16(4, 65096), 0);
+        assert_eq!(divi_ui16(4, 65534), 0);
+        assert_eq!(divi_ui16(4, 65535), 0);
+        assert_eq!(divi_ui16(1717, 17988), 0);
+        assert_eq!(divi_ui16(1717, 65096), 0);
+        assert_eq!(divi_ui16(1717, 65534), 0);
+        assert_eq!(divi_ui16(1717, 65535), 0);
+        assert_eq!(divi_ui16(17988, 65096), 0);
+        assert_eq!(divi_ui16(17988, 65534), 0);
+        assert_eq!(divi_ui16(17988, 65535), 0);
+        assert_eq!(divi_ui16(65096, 65534), 0);
+        assert_eq!(divi_ui16(65096, 65535), 0);
+        assert_eq!(divi_ui16(65534, 65535), 0);
+        assert_eq!(divi_ui16(1, 1), 1);
+        assert_eq!(divi_ui16(2, 2), 1);
+        assert_eq!(divi_ui16(3, 2), 1);
+        assert_eq!(divi_ui16(3, 3), 1);
+        assert_eq!(divi_ui16(4, 3), 1);
+        assert_eq!(divi_ui16(4, 4), 1);
+        assert_eq!(divi_ui16(1717, 1717), 1);
+        assert_eq!(divi_ui16(17988, 17988), 1);
+        assert_eq!(divi_ui16(65096, 65096), 1);
+        assert_eq!(divi_ui16(65534, 65096), 1);
+        assert_eq!(divi_ui16(65534, 65534), 1);
+        assert_eq!(divi_ui16(65535, 65096), 1);
+        assert_eq!(divi_ui16(65535, 65534), 1);
+        assert_eq!(divi_ui16(65535, 65535), 1);
+        assert_eq!(divi_ui16(2, 1), 2);
+        assert_eq!(divi_ui16(4, 2), 2);
+        assert_eq!(divi_ui16(3, 1), 3);
+        assert_eq!(divi_ui16(65096, 17988), 3);
+        assert_eq!(divi_ui16(65534, 17988), 3);
+        assert_eq!(divi_ui16(65535, 17988), 3);
+        assert_eq!(divi_ui16(4, 1), 4);
+        assert_eq!(divi_ui16(17988, 1717), 10);
+        assert_eq!(divi_ui16(65096, 1717), 37);
+        assert_eq!(divi_ui16(65534, 1717), 38);
+        assert_eq!(divi_ui16(65535, 1717), 38);
+        assert_eq!(divi_ui16(1717, 4), 429);
+        assert_eq!(divi_ui16(1717, 3), 572);
+        assert_eq!(divi_ui16(1717, 2), 858);
+        assert_eq!(divi_ui16(1717, 1), 1717);
+        assert_eq!(divi_ui16(17988, 4), 4497);
+        assert_eq!(divi_ui16(17988, 3), 5996);
+        assert_eq!(divi_ui16(17988, 2), 8994);
+        assert_eq!(divi_ui16(65096, 4), 16274);
+        assert_eq!(divi_ui16(65534, 4), 16383);
+        assert_eq!(divi_ui16(65535, 4), 16383);
+        assert_eq!(divi_ui16(17988, 1), 17988);
+        assert_eq!(divi_ui16(65096, 3), 21698);
+        assert_eq!(divi_ui16(65534, 3), 21844);
+        assert_eq!(divi_ui16(65535, 3), 21845);
+        assert_eq!(divi_ui16(65096, 2), 32548);
+        assert_eq!(divi_ui16(65534, 2), 32767);
+        assert_eq!(divi_ui16(65535, 2), 32767);
+        assert_eq!(divi_ui16(65096, 1), 65096);
+        assert_eq!(divi_ui16(65534, 1), 65534);
+        assert_eq!(divi_ui16(65535, 1), 65535);
+        assert_eq!(divi_ui32(0, 1), 0);
+        assert_eq!(divi_ui32(0, 2), 0);
+        assert_eq!(divi_ui32(0, 3), 0);
+        assert_eq!(divi_ui32(0, 4), 0);
+        assert_eq!(divi_ui32(0, 2119154652), 0);
+        assert_eq!(divi_ui32(0, 3002788344), 0);
+        assert_eq!(divi_ui32(0, 3482297128), 0);
+        assert_eq!(divi_ui32(0, 4294967294), 0);
+        assert_eq!(divi_ui32(0, 4294967295), 0);
+        assert_eq!(divi_ui32(1, 2), 0);
+        assert_eq!(divi_ui32(1, 3), 0);
+        assert_eq!(divi_ui32(1, 4), 0);
+        assert_eq!(divi_ui32(1, 2119154652), 0);
+        assert_eq!(divi_ui32(1, 3002788344), 0);
+        assert_eq!(divi_ui32(1, 3482297128), 0);
+        assert_eq!(divi_ui32(1, 4294967294), 0);
+        assert_eq!(divi_ui32(1, 4294967295), 0);
+        assert_eq!(divi_ui32(2, 3), 0);
+        assert_eq!(divi_ui32(2, 4), 0);
+        assert_eq!(divi_ui32(2, 2119154652), 0);
+        assert_eq!(divi_ui32(2, 3002788344), 0);
+        assert_eq!(divi_ui32(2, 3482297128), 0);
+        assert_eq!(divi_ui32(2, 4294967294), 0);
+        assert_eq!(divi_ui32(2, 4294967295), 0);
+        assert_eq!(divi_ui32(3, 4), 0);
+        assert_eq!(divi_ui32(3, 2119154652), 0);
+        assert_eq!(divi_ui32(3, 3002788344), 0);
+        assert_eq!(divi_ui32(3, 3482297128), 0);
+        assert_eq!(divi_ui32(3, 4294967294), 0);
+        assert_eq!(divi_ui32(3, 4294967295), 0);
+        assert_eq!(divi_ui32(4, 2119154652), 0);
+        assert_eq!(divi_ui32(4, 3002788344), 0);
+        assert_eq!(divi_ui32(4, 3482297128), 0);
+        assert_eq!(divi_ui32(4, 4294967294), 0);
+        assert_eq!(divi_ui32(4, 4294967295), 0);
+        assert_eq!(divi_ui32(2119154652, 3002788344), 0);
+        assert_eq!(divi_ui32(2119154652, 3482297128), 0);
+        assert_eq!(divi_ui32(2119154652, 4294967294), 0);
+        assert_eq!(divi_ui32(2119154652, 4294967295), 0);
+        assert_eq!(divi_ui32(3002788344, 3482297128), 0);
+        assert_eq!(divi_ui32(3002788344, 4294967294), 0);
+        assert_eq!(divi_ui32(3002788344, 4294967295), 0);
+        assert_eq!(divi_ui32(3482297128, 4294967294), 0);
+        assert_eq!(divi_ui32(3482297128, 4294967295), 0);
+        assert_eq!(divi_ui32(4294967294, 4294967295), 0);
+        assert_eq!(divi_ui32(1, 1), 1);
+        assert_eq!(divi_ui32(2, 2), 1);
+        assert_eq!(divi_ui32(3, 2), 1);
+        assert_eq!(divi_ui32(3, 3), 1);
+        assert_eq!(divi_ui32(4, 3), 1);
+        assert_eq!(divi_ui32(4, 4), 1);
+        assert_eq!(divi_ui32(2119154652, 2119154652), 1);
+        assert_eq!(divi_ui32(3002788344, 2119154652), 1);
+        assert_eq!(divi_ui32(3002788344, 3002788344), 1);
+        assert_eq!(divi_ui32(3482297128, 2119154652), 1);
+        assert_eq!(divi_ui32(3482297128, 3002788344), 1);
+        assert_eq!(divi_ui32(3482297128, 3482297128), 1);
+        assert_eq!(divi_ui32(4294967294, 3002788344), 1);
+        assert_eq!(divi_ui32(4294967294, 3482297128), 1);
+        assert_eq!(divi_ui32(4294967294, 4294967294), 1);
+        assert_eq!(divi_ui32(4294967295, 3002788344), 1);
+        assert_eq!(divi_ui32(4294967295, 3482297128), 1);
+        assert_eq!(divi_ui32(4294967295, 4294967294), 1);
+        assert_eq!(divi_ui32(4294967295, 4294967295), 1);
+        assert_eq!(divi_ui32(2, 1), 2);
+        assert_eq!(divi_ui32(4, 2), 2);
+        assert_eq!(divi_ui32(4294967294, 2119154652), 2);
+        assert_eq!(divi_ui32(4294967295, 2119154652), 2);
+        assert_eq!(divi_ui32(3, 1), 3);
+        assert_eq!(divi_ui32(4, 1), 4);
+        assert_eq!(divi_ui32(2119154652, 4), 529788663);
+        assert_eq!(divi_ui32(2119154652, 3), 706384884);
+        assert_eq!(divi_ui32(3002788344, 4), 750697086);
+        assert_eq!(divi_ui32(3482297128, 4), 870574282);
+        assert_eq!(divi_ui32(3002788344, 3), 1000929448);
+        assert_eq!(divi_ui32(2119154652, 2), 1059577326);
+        assert_eq!(divi_ui32(4294967294, 4), 1073741823);
+        assert_eq!(divi_ui32(4294967295, 4), 1073741823);
+        assert_eq!(divi_ui32(3482297128, 3), 1160765709);
+        assert_eq!(divi_ui32(4294967294, 3), 1431655764);
+        assert_eq!(divi_ui32(4294967295, 3), 1431655765);
+        assert_eq!(divi_ui32(3002788344, 2), 1501394172);
+        assert_eq!(divi_ui32(3482297128, 2), 1741148564);
+        assert_eq!(divi_ui32(2119154652, 1), 2119154652);
+        assert_eq!(divi_ui32(4294967294, 2), 2147483647);
+        assert_eq!(divi_ui32(4294967295, 2), 2147483647);
+        assert_eq!(divi_ui32(3002788344, 1), 3002788344);
+        assert_eq!(divi_ui32(3482297128, 1), 3482297128);
+        assert_eq!(divi_ui32(4294967294, 1), 4294967294);
+        assert_eq!(divi_ui32(4294967295, 1), 4294967295);
+        assert_eq!(divi_ui64(0, 1), 0);
+        assert_eq!(divi_ui64(0, 2), 0);
+        assert_eq!(divi_ui64(0, 3), 0);
+        assert_eq!(divi_ui64(0, 4), 0);
+        assert_eq!(divi_ui64(0, 191084152064409600), 0);
+        assert_eq!(divi_ui64(0, 11015955194427482112), 0);
+        assert_eq!(divi_ui64(0, 16990600415051759616), 0);
+        assert_eq!(divi_ui64(0, 18446744073709551614), 0);
+        assert_eq!(divi_ui64(0, 18446744073709551615), 0);
+        assert_eq!(divi_ui64(1, 2), 0);
+        assert_eq!(divi_ui64(1, 3), 0);
+        assert_eq!(divi_ui64(1, 4), 0);
+        assert_eq!(divi_ui64(1, 191084152064409600), 0);
+        assert_eq!(divi_ui64(1, 11015955194427482112), 0);
+        assert_eq!(divi_ui64(1, 16990600415051759616), 0);
+        assert_eq!(divi_ui64(1, 18446744073709551614), 0);
+        assert_eq!(divi_ui64(1, 18446744073709551615), 0);
+        assert_eq!(divi_ui64(2, 3), 0);
+        assert_eq!(divi_ui64(2, 4), 0);
+        assert_eq!(divi_ui64(2, 191084152064409600), 0);
+        assert_eq!(divi_ui64(2, 11015955194427482112), 0);
+        assert_eq!(divi_ui64(2, 16990600415051759616), 0);
+        assert_eq!(divi_ui64(2, 18446744073709551614), 0);
+        assert_eq!(divi_ui64(2, 18446744073709551615), 0);
+        assert_eq!(divi_ui64(3, 4), 0);
+        assert_eq!(divi_ui64(3, 191084152064409600), 0);
+        assert_eq!(divi_ui64(3, 11015955194427482112), 0);
+        assert_eq!(divi_ui64(3, 16990600415051759616), 0);
+        assert_eq!(divi_ui64(3, 18446744073709551614), 0);
+        assert_eq!(divi_ui64(3, 18446744073709551615), 0);
+        assert_eq!(divi_ui64(4, 191084152064409600), 0);
+        assert_eq!(divi_ui64(4, 11015955194427482112), 0);
+        assert_eq!(divi_ui64(4, 16990600415051759616), 0);
+        assert_eq!(divi_ui64(4, 18446744073709551614), 0);
+        assert_eq!(divi_ui64(4, 18446744073709551615), 0);
+        assert_eq!(divi_ui64(191084152064409600, 11015955194427482112), 0);
+        assert_eq!(divi_ui64(191084152064409600, 16990600415051759616), 0);
+        assert_eq!(divi_ui64(191084152064409600, 18446744073709551614), 0);
+        assert_eq!(divi_ui64(191084152064409600, 18446744073709551615), 0);
+        assert_eq!(divi_ui64(11015955194427482112, 16990600415051759616), 0);
+        assert_eq!(divi_ui64(11015955194427482112, 18446744073709551614), 0);
+        assert_eq!(divi_ui64(11015955194427482112, 18446744073709551615), 0);
+        assert_eq!(divi_ui64(16990600415051759616, 18446744073709551614), 0);
+        assert_eq!(divi_ui64(16990600415051759616, 18446744073709551615), 0);
+        assert_eq!(divi_ui64(18446744073709551614, 18446744073709551615), 0);
+        assert_eq!(divi_ui64(1, 1), 1);
+        assert_eq!(divi_ui64(2, 2), 1);
+        assert_eq!(divi_ui64(3, 2), 1);
+        assert_eq!(divi_ui64(3, 3), 1);
+        assert_eq!(divi_ui64(4, 3), 1);
+        assert_eq!(divi_ui64(4, 4), 1);
+        assert_eq!(divi_ui64(191084152064409600, 191084152064409600), 1);
+        assert_eq!(divi_ui64(11015955194427482112, 11015955194427482112), 1);
+        assert_eq!(divi_ui64(16990600415051759616, 11015955194427482112), 1);
+        assert_eq!(divi_ui64(16990600415051759616, 16990600415051759616), 1);
+        assert_eq!(divi_ui64(18446744073709551614, 11015955194427482112), 1);
+        assert_eq!(divi_ui64(18446744073709551614, 16990600415051759616), 1);
+        assert_eq!(divi_ui64(18446744073709551614, 18446744073709551614), 1);
+        assert_eq!(divi_ui64(18446744073709551615, 11015955194427482112), 1);
+        assert_eq!(divi_ui64(18446744073709551615, 16990600415051759616), 1);
+        assert_eq!(divi_ui64(18446744073709551615, 18446744073709551614), 1);
+        assert_eq!(divi_ui64(18446744073709551615, 18446744073709551615), 1);
+        assert_eq!(divi_ui64(2, 1), 2);
+        assert_eq!(divi_ui64(4, 2), 2);
+        assert_eq!(divi_ui64(3, 1), 3);
+        assert_eq!(divi_ui64(4, 1), 4);
+        assert_eq!(divi_ui64(11015955194427482112, 191084152064409600), 57);
+        assert_eq!(divi_ui64(16990600415051759616, 191084152064409600), 88);
+        assert_eq!(divi_ui64(18446744073709551614, 191084152064409600), 96);
+        assert_eq!(divi_ui64(18446744073709551615, 191084152064409600), 96);
+        assert_eq!(divi_ui64(191084152064409600, 4), 47771038016102400);
+        assert_eq!(divi_ui64(191084152064409600, 3), 63694717354803200);
+        assert_eq!(divi_ui64(191084152064409600, 2), 95542076032204800);
+        assert_eq!(divi_ui64(191084152064409600, 1), 191084152064409600);
+        assert_eq!(divi_ui64(11015955194427482112, 4), 2753988798606870528);
+        assert_eq!(divi_ui64(11015955194427482112, 3), 3671985064809160704);
+        assert_eq!(divi_ui64(16990600415051759616, 4), 4247650103762939904);
+        assert_eq!(divi_ui64(18446744073709551614, 4), 4611686018427387903);
+        assert_eq!(divi_ui64(18446744073709551615, 4), 4611686018427387903);
+        assert_eq!(divi_ui64(11015955194427482112, 2), 5507977597213741056);
+        assert_eq!(divi_ui64(16990600415051759616, 3), 5663533471683919872);
+        assert_eq!(divi_ui64(18446744073709551614, 3), 6148914691236517204);
+        assert_eq!(divi_ui64(18446744073709551615, 3), 6148914691236517205);
+        assert_eq!(divi_ui64(16990600415051759616, 2), 8495300207525879808);
+        assert_eq!(divi_ui64(18446744073709551614, 2), 9223372036854775807);
+        assert_eq!(divi_ui64(18446744073709551615, 2), 9223372036854775807);
+        assert_eq!(divi_ui64(11015955194427482112, 1), 11015955194427482112);
+        assert_eq!(divi_ui64(16990600415051759616, 1), 16990600415051759616);
+        assert_eq!(divi_ui64(18446744073709551614, 1), 18446744073709551614);
+        assert_eq!(divi_ui64(18446744073709551615, 1), 18446744073709551615);
+        assert_eq!(divi_ui8(0, 1), 0);
+        assert_eq!(divi_ui8(0, 2), 0);
+        assert_eq!(divi_ui8(0, 3), 0);
+        assert_eq!(divi_ui8(0, 4), 0);
+        assert_eq!(divi_ui8(0, 72), 0);
+        assert_eq!(divi_ui8(0, 100), 0);
+        assert_eq!(divi_ui8(0, 162), 0);
+        assert_eq!(divi_ui8(0, 254), 0);
+        assert_eq!(divi_ui8(0, 255), 0);
+        assert_eq!(divi_ui8(1, 2), 0);
+        assert_eq!(divi_ui8(1, 3), 0);
+        assert_eq!(divi_ui8(1, 4), 0);
+        assert_eq!(divi_ui8(1, 72), 0);
+        assert_eq!(divi_ui8(1, 100), 0);
+        assert_eq!(divi_ui8(1, 162), 0);
+        assert_eq!(divi_ui8(1, 254), 0);
+        assert_eq!(divi_ui8(1, 255), 0);
+        assert_eq!(divi_ui8(2, 3), 0);
+        assert_eq!(divi_ui8(2, 4), 0);
+        assert_eq!(divi_ui8(2, 72), 0);
+        assert_eq!(divi_ui8(2, 100), 0);
+        assert_eq!(divi_ui8(2, 162), 0);
+        assert_eq!(divi_ui8(2, 254), 0);
+        assert_eq!(divi_ui8(2, 255), 0);
+        assert_eq!(divi_ui8(3, 4), 0);
+        assert_eq!(divi_ui8(3, 72), 0);
+        assert_eq!(divi_ui8(3, 100), 0);
+        assert_eq!(divi_ui8(3, 162), 0);
+        assert_eq!(divi_ui8(3, 254), 0);
+        assert_eq!(divi_ui8(3, 255), 0);
+        assert_eq!(divi_ui8(4, 72), 0);
+        assert_eq!(divi_ui8(4, 100), 0);
+        assert_eq!(divi_ui8(4, 162), 0);
+        assert_eq!(divi_ui8(4, 254), 0);
+        assert_eq!(divi_ui8(4, 255), 0);
+        assert_eq!(divi_ui8(72, 100), 0);
+        assert_eq!(divi_ui8(72, 162), 0);
+        assert_eq!(divi_ui8(72, 254), 0);
+        assert_eq!(divi_ui8(72, 255), 0);
+        assert_eq!(divi_ui8(100, 162), 0);
+        assert_eq!(divi_ui8(100, 254), 0);
+        assert_eq!(divi_ui8(100, 255), 0);
+        assert_eq!(divi_ui8(162, 254), 0);
+        assert_eq!(divi_ui8(162, 255), 0);
+        assert_eq!(divi_ui8(254, 255), 0);
+        assert_eq!(divi_ui8(1, 1), 1);
+        assert_eq!(divi_ui8(2, 2), 1);
+        assert_eq!(divi_ui8(3, 2), 1);
+        assert_eq!(divi_ui8(3, 3), 1);
+        assert_eq!(divi_ui8(4, 3), 1);
+        assert_eq!(divi_ui8(4, 4), 1);
+        assert_eq!(divi_ui8(72, 72), 1);
+        assert_eq!(divi_ui8(100, 72), 1);
+        assert_eq!(divi_ui8(100, 100), 1);
+        assert_eq!(divi_ui8(162, 100), 1);
+        assert_eq!(divi_ui8(162, 162), 1);
+        assert_eq!(divi_ui8(254, 162), 1);
+        assert_eq!(divi_ui8(254, 254), 1);
+        assert_eq!(divi_ui8(255, 162), 1);
+        assert_eq!(divi_ui8(255, 254), 1);
+        assert_eq!(divi_ui8(255, 255), 1);
+        assert_eq!(divi_ui8(2, 1), 2);
+        assert_eq!(divi_ui8(4, 2), 2);
+        assert_eq!(divi_ui8(162, 72), 2);
+        assert_eq!(divi_ui8(254, 100), 2);
+        assert_eq!(divi_ui8(255, 100), 2);
+        assert_eq!(divi_ui8(3, 1), 3);
+        assert_eq!(divi_ui8(254, 72), 3);
+        assert_eq!(divi_ui8(255, 72), 3);
+        assert_eq!(divi_ui8(4, 1), 4);
+        assert_eq!(divi_ui8(72, 4), 18);
+        assert_eq!(divi_ui8(72, 3), 24);
+        assert_eq!(divi_ui8(100, 4), 25);
+        assert_eq!(divi_ui8(100, 3), 33);
+        assert_eq!(divi_ui8(72, 2), 36);
+        assert_eq!(divi_ui8(162, 4), 40);
+        assert_eq!(divi_ui8(100, 2), 50);
+        assert_eq!(divi_ui8(162, 3), 54);
+        assert_eq!(divi_ui8(254, 4), 63);
+        assert_eq!(divi_ui8(255, 4), 63);
+        assert_eq!(divi_ui8(72, 1), 72);
+        assert_eq!(divi_ui8(162, 2), 81);
+        assert_eq!(divi_ui8(254, 3), 84);
+        assert_eq!(divi_ui8(255, 3), 85);
+        assert_eq!(divi_ui8(100, 1), 100);
+        assert_eq!(divi_ui8(254, 2), 127);
+        assert_eq!(divi_ui8(255, 2), 127);
+        assert_eq!(divi_ui8(162, 1), 162);
+        assert_eq!(divi_ui8(254, 1), 254);
+        assert_eq!(divi_ui8(255, 1), 255);
+        assert_eq!(muli_si16(-32768, 1), -32768);
+        assert_eq!(muli_si16(1, -32768), -32768);
+        assert_eq!(muli_si16(-32767, 1), -32767);
+        assert_eq!(muli_si16(1, -32767), -32767);
+        assert_eq!(muli_si16(-32547, 1), -32547);
+        assert_eq!(muli_si16(1, -32547), -32547);
+        assert_eq!(muli_si16(-32768, 0), 0);
+        assert_eq!(muli_si16(-32767, 0), 0);
+        assert_eq!(muli_si16(-32547, 0), 0);
+        assert_eq!(muli_si16(0, -32768), 0);
+        assert_eq!(muli_si16(0, -32767), 0);
+        assert_eq!(muli_si16(0, -32547), 0);
+        assert_eq!(muli_si16(0, 0), 0);
+        assert_eq!(muli_si16(0, 1), 0);
+        assert_eq!(muli_si16(0, 2), 0);
+        assert_eq!(muli_si16(0, 3), 0);
+        assert_eq!(muli_si16(0, 4), 0);
+        assert_eq!(muli_si16(0, 10486), 0);
+        assert_eq!(muli_si16(0, 16514), 0);
+        assert_eq!(muli_si16(0, 32766), 0);
+        assert_eq!(muli_si16(0, 32767), 0);
+        assert_eq!(muli_si16(1, 0), 0);
+        assert_eq!(muli_si16(2, 0), 0);
+        assert_eq!(muli_si16(3, 0), 0);
+        assert_eq!(muli_si16(4, 0), 0);
+        assert_eq!(muli_si16(10486, 0), 0);
+        assert_eq!(muli_si16(16514, 0), 0);
+        assert_eq!(muli_si16(32766, 0), 0);
+        assert_eq!(muli_si16(32767, 0), 0);
+        assert_eq!(muli_si16(1, 1), 1);
+        assert_eq!(muli_si16(1, 2), 2);
+        assert_eq!(muli_si16(2, 1), 2);
+        assert_eq!(muli_si16(1, 3), 3);
+        assert_eq!(muli_si16(3, 1), 3);
+        assert_eq!(muli_si16(1, 4), 4);
+        assert_eq!(muli_si16(2, 2), 4);
+        assert_eq!(muli_si16(4, 1), 4);
+        assert_eq!(muli_si16(2, 3), 6);
+        assert_eq!(muli_si16(3, 2), 6);
+        assert_eq!(muli_si16(2, 4), 8);
+        assert_eq!(muli_si16(4, 2), 8);
+        assert_eq!(muli_si16(3, 3), 9);
+        assert_eq!(muli_si16(3, 4), 12);
+        assert_eq!(muli_si16(4, 3), 12);
+        assert_eq!(muli_si16(4, 4), 16);
+        assert_eq!(muli_si16(1, 10486), 10486);
+        assert_eq!(muli_si16(10486, 1), 10486);
+        assert_eq!(muli_si16(1, 16514), 16514);
+        assert_eq!(muli_si16(16514, 1), 16514);
+        assert_eq!(muli_si16(2, 10486), 20972);
+        assert_eq!(muli_si16(10486, 2), 20972);
+        assert_eq!(muli_si16(3, 10486), 31458);
+        assert_eq!(muli_si16(10486, 3), 31458);
+        assert_eq!(muli_si16(1, 32766), 32766);
+        assert_eq!(muli_si16(32766, 1), 32766);
+        assert_eq!(muli_si16(1, 32767), 32767);
+        assert_eq!(muli_si16(32767, 1), 32767);
+        assert_eq!(muli_si32(-2147483648, 1), -2147483648);
+        assert_eq!(muli_si32(1, -2147483648), -2147483648);
+        assert_eq!(muli_si32(-2147483647, 1), -2147483647);
+        assert_eq!(muli_si32(1, -2147483647), -2147483647);
+        assert_eq!(muli_si32(-1035405763, 2), -2070811526);
+        assert_eq!(muli_si32(2, -1035405763), -2070811526);
+        assert_eq!(muli_si32(-1713183800, 1), -1713183800);
+        assert_eq!(muli_si32(1, -1713183800), -1713183800);
+        assert_eq!(muli_si32(-1252582164, 1), -1252582164);
+        assert_eq!(muli_si32(1, -1252582164), -1252582164);
+        assert_eq!(muli_si32(-1035405763, 1), -1035405763);
+        assert_eq!(muli_si32(1, -1035405763), -1035405763);
+        assert_eq!(muli_si32(-2147483648, 0), 0);
+        assert_eq!(muli_si32(-2147483647, 0), 0);
+        assert_eq!(muli_si32(-1713183800, 0), 0);
+        assert_eq!(muli_si32(-1252582164, 0), 0);
+        assert_eq!(muli_si32(-1035405763, 0), 0);
+        assert_eq!(muli_si32(0, -2147483648), 0);
+        assert_eq!(muli_si32(0, -2147483647), 0);
+        assert_eq!(muli_si32(0, -1713183800), 0);
+        assert_eq!(muli_si32(0, -1252582164), 0);
+        assert_eq!(muli_si32(0, -1035405763), 0);
+        assert_eq!(muli_si32(0, 0), 0);
+        assert_eq!(muli_si32(0, 1), 0);
+        assert_eq!(muli_si32(0, 2), 0);
+        assert_eq!(muli_si32(0, 3), 0);
+        assert_eq!(muli_si32(0, 4), 0);
+        assert_eq!(muli_si32(0, 2147483646), 0);
+        assert_eq!(muli_si32(0, 2147483647), 0);
+        assert_eq!(muli_si32(1, 0), 0);
+        assert_eq!(muli_si32(2, 0), 0);
+        assert_eq!(muli_si32(3, 0), 0);
+        assert_eq!(muli_si32(4, 0), 0);
+        assert_eq!(muli_si32(2147483646, 0), 0);
+        assert_eq!(muli_si32(2147483647, 0), 0);
+        assert_eq!(muli_si32(1, 1), 1);
+        assert_eq!(muli_si32(1, 2), 2);
+        assert_eq!(muli_si32(2, 1), 2);
+        assert_eq!(muli_si32(1, 3), 3);
+        assert_eq!(muli_si32(3, 1), 3);
+        assert_eq!(muli_si32(1, 4), 4);
+        assert_eq!(muli_si32(2, 2), 4);
+        assert_eq!(muli_si32(4, 1), 4);
+        assert_eq!(muli_si32(2, 3), 6);
+        assert_eq!(muli_si32(3, 2), 6);
+        assert_eq!(muli_si32(2, 4), 8);
+        assert_eq!(muli_si32(4, 2), 8);
+        assert_eq!(muli_si32(3, 3), 9);
+        assert_eq!(muli_si32(3, 4), 12);
+        assert_eq!(muli_si32(4, 3), 12);
+        assert_eq!(muli_si32(4, 4), 16);
+        assert_eq!(muli_si32(1, 2147483646), 2147483646);
+        assert_eq!(muli_si32(2147483646, 1), 2147483646);
+        assert_eq!(muli_si32(1, 2147483647), 2147483647);
+        assert_eq!(muli_si32(2147483647, 1), 2147483647);
+        assert_eq!(muli_si64(-9223372036854775808, 1), -9223372036854775808);
+        assert_eq!(muli_si64(1, -9223372036854775808), -9223372036854775808);
+        assert_eq!(muli_si64(-9223372036854775807, 1), -9223372036854775807);
+        assert_eq!(muli_si64(1, -9223372036854775807), -9223372036854775807);
+        assert_eq!(muli_si64(-1741927215160008704, 4), -6967708860640034816);
+        assert_eq!(muli_si64(4, -1741927215160008704), -6967708860640034816);
+        assert_eq!(muli_si64(-1328271339354574848, 4), -5313085357418299392);
+        assert_eq!(muli_si64(4, -1328271339354574848), -5313085357418299392);
+        assert_eq!(muli_si64(-1741927215160008704, 3), -5225781645480026112);
+        assert_eq!(muli_si64(3, -1741927215160008704), -5225781645480026112);
+        assert_eq!(muli_si64(-1328271339354574848, 3), -3984814018063724544);
+        assert_eq!(muli_si64(3, -1328271339354574848), -3984814018063724544);
+        assert_eq!(muli_si64(-1741927215160008704, 2), -3483854430320017408);
+        assert_eq!(muli_si64(2, -1741927215160008704), -3483854430320017408);
+        assert_eq!(muli_si64(-1328271339354574848, 2), -2656542678709149696);
+        assert_eq!(muli_si64(2, -1328271339354574848), -2656542678709149696);
+        assert_eq!(muli_si64(-1741927215160008704, 1), -1741927215160008704);
+        assert_eq!(muli_si64(1, -1741927215160008704), -1741927215160008704);
+        assert_eq!(muli_si64(-1328271339354574848, 1), -1328271339354574848);
+        assert_eq!(muli_si64(1, -1328271339354574848), -1328271339354574848);
+        assert_eq!(muli_si64(-9223372036854775808, 0), 0);
+        assert_eq!(muli_si64(-9223372036854775807, 0), 0);
+        assert_eq!(muli_si64(-1741927215160008704, 0), 0);
+        assert_eq!(muli_si64(-1328271339354574848, 0), 0);
+        assert_eq!(muli_si64(0, -9223372036854775808), 0);
+        assert_eq!(muli_si64(0, -9223372036854775807), 0);
+        assert_eq!(muli_si64(0, -1741927215160008704), 0);
+        assert_eq!(muli_si64(0, -1328271339354574848), 0);
+        assert_eq!(muli_si64(0, 0), 0);
+        assert_eq!(muli_si64(0, 1), 0);
+        assert_eq!(muli_si64(0, 2), 0);
+        assert_eq!(muli_si64(0, 3), 0);
+        assert_eq!(muli_si64(0, 4), 0);
+        assert_eq!(muli_si64(0, 5577148965131116544), 0);
+        assert_eq!(muli_si64(0, 9223372036854775806), 0);
+        assert_eq!(muli_si64(0, 9223372036854775807), 0);
+        assert_eq!(muli_si64(1, 0), 0);
+        assert_eq!(muli_si64(2, 0), 0);
+        assert_eq!(muli_si64(3, 0), 0);
+        assert_eq!(muli_si64(4, 0), 0);
+        assert_eq!(muli_si64(5577148965131116544, 0), 0);
+        assert_eq!(muli_si64(9223372036854775806, 0), 0);
+        assert_eq!(muli_si64(9223372036854775807, 0), 0);
+        assert_eq!(muli_si64(1, 1), 1);
+        assert_eq!(muli_si64(1, 2), 2);
+        assert_eq!(muli_si64(2, 1), 2);
+        assert_eq!(muli_si64(1, 3), 3);
+        assert_eq!(muli_si64(3, 1), 3);
+        assert_eq!(muli_si64(1, 4), 4);
+        assert_eq!(muli_si64(2, 2), 4);
+        assert_eq!(muli_si64(4, 1), 4);
+        assert_eq!(muli_si64(2, 3), 6);
+        assert_eq!(muli_si64(3, 2), 6);
+        assert_eq!(muli_si64(2, 4), 8);
+        assert_eq!(muli_si64(4, 2), 8);
+        assert_eq!(muli_si64(3, 3), 9);
+        assert_eq!(muli_si64(3, 4), 12);
+        assert_eq!(muli_si64(4, 3), 12);
+        assert_eq!(muli_si64(4, 4), 16);
+        assert_eq!(muli_si64(1, 5577148965131116544), 5577148965131116544);
+        assert_eq!(muli_si64(5577148965131116544, 1), 5577148965131116544);
+        assert_eq!(muli_si64(1, 9223372036854775806), 9223372036854775806);
+        assert_eq!(muli_si64(9223372036854775806, 1), 9223372036854775806);
+        assert_eq!(muli_si64(1, 9223372036854775807), 9223372036854775807);
+        assert_eq!(muli_si64(9223372036854775807, 1), 9223372036854775807);
+        assert_eq!(muli_si8(-128, 1), -128);
+        assert_eq!(muli_si8(1, -128), -128);
+        assert_eq!(muli_si8(-127, 1), -127);
+        assert_eq!(muli_si8(1, -127), -127);
+        assert_eq!(muli_si8(-128, 0), 0);
+        assert_eq!(muli_si8(-127, 0), 0);
+        assert_eq!(muli_si8(0, -128), 0);
+        assert_eq!(muli_si8(0, -127), 0);
+        assert_eq!(muli_si8(0, 0), 0);
+        assert_eq!(muli_si8(0, 1), 0);
+        assert_eq!(muli_si8(0, 2), 0);
+        assert_eq!(muli_si8(0, 3), 0);
+        assert_eq!(muli_si8(0, 4), 0);
+        assert_eq!(muli_si8(0, 16), 0);
+        assert_eq!(muli_si8(0, 126), 0);
+        assert_eq!(muli_si8(0, 127), 0);
+        assert_eq!(muli_si8(1, 0), 0);
+        assert_eq!(muli_si8(2, 0), 0);
+        assert_eq!(muli_si8(3, 0), 0);
+        assert_eq!(muli_si8(4, 0), 0);
+        assert_eq!(muli_si8(16, 0), 0);
+        assert_eq!(muli_si8(126, 0), 0);
+        assert_eq!(muli_si8(127, 0), 0);
+        assert_eq!(muli_si8(1, 1), 1);
+        assert_eq!(muli_si8(1, 2), 2);
+        assert_eq!(muli_si8(2, 1), 2);
+        assert_eq!(muli_si8(1, 3), 3);
+        assert_eq!(muli_si8(3, 1), 3);
+        assert_eq!(muli_si8(1, 4), 4);
+        assert_eq!(muli_si8(2, 2), 4);
+        assert_eq!(muli_si8(4, 1), 4);
+        assert_eq!(muli_si8(2, 3), 6);
+        assert_eq!(muli_si8(3, 2), 6);
+        assert_eq!(muli_si8(2, 4), 8);
+        assert_eq!(muli_si8(4, 2), 8);
+        assert_eq!(muli_si8(3, 3), 9);
+        assert_eq!(muli_si8(3, 4), 12);
+        assert_eq!(muli_si8(4, 3), 12);
+        assert_eq!(muli_si8(1, 16), 16);
+        assert_eq!(muli_si8(4, 4), 16);
+        assert_eq!(muli_si8(16, 1), 16);
+        assert_eq!(muli_si8(2, 16), 32);
+        assert_eq!(muli_si8(16, 2), 32);
+        assert_eq!(muli_si8(3, 16), 48);
+        assert_eq!(muli_si8(16, 3), 48);
+        assert_eq!(muli_si8(4, 16), 64);
+        assert_eq!(muli_si8(16, 4), 64);
+        assert_eq!(muli_si8(1, 126), 126);
+        assert_eq!(muli_si8(126, 1), 126);
+        assert_eq!(muli_si8(1, 127), 127);
+        assert_eq!(muli_si8(127, 1), 127);
+        assert_eq!(muli_ui16(0, 0), 0);
+        assert_eq!(muli_ui16(0, 1), 0);
+        assert_eq!(muli_ui16(0, 2), 0);
+        assert_eq!(muli_ui16(0, 3), 0);
+        assert_eq!(muli_ui16(0, 4), 0);
+        assert_eq!(muli_ui16(0, 1717), 0);
+        assert_eq!(muli_ui16(0, 17988), 0);
+        assert_eq!(muli_ui16(0, 65096), 0);
+        assert_eq!(muli_ui16(0, 65534), 0);
+        assert_eq!(muli_ui16(0, 65535), 0);
+        assert_eq!(muli_ui16(1, 0), 0);
+        assert_eq!(muli_ui16(2, 0), 0);
+        assert_eq!(muli_ui16(3, 0), 0);
+        assert_eq!(muli_ui16(4, 0), 0);
+        assert_eq!(muli_ui16(1717, 0), 0);
+        assert_eq!(muli_ui16(17988, 0), 0);
+        assert_eq!(muli_ui16(65096, 0), 0);
+        assert_eq!(muli_ui16(65534, 0), 0);
+        assert_eq!(muli_ui16(65535, 0), 0);
+        assert_eq!(muli_ui16(1, 1), 1);
+        assert_eq!(muli_ui16(1, 2), 2);
+        assert_eq!(muli_ui16(2, 1), 2);
+        assert_eq!(muli_ui16(1, 3), 3);
+        assert_eq!(muli_ui16(3, 1), 3);
+        assert_eq!(muli_ui16(1, 4), 4);
+        assert_eq!(muli_ui16(2, 2), 4);
+        assert_eq!(muli_ui16(4, 1), 4);
+        assert_eq!(muli_ui16(2, 3), 6);
+        assert_eq!(muli_ui16(3, 2), 6);
+        assert_eq!(muli_ui16(2, 4), 8);
+        assert_eq!(muli_ui16(4, 2), 8);
+        assert_eq!(muli_ui16(3, 3), 9);
+        assert_eq!(muli_ui16(3, 4), 12);
+        assert_eq!(muli_ui16(4, 3), 12);
+        assert_eq!(muli_ui16(4, 4), 16);
+        assert_eq!(muli_ui16(1, 1717), 1717);
+        assert_eq!(muli_ui16(1717, 1), 1717);
+        assert_eq!(muli_ui16(2, 1717), 3434);
+        assert_eq!(muli_ui16(1717, 2), 3434);
+        assert_eq!(muli_ui16(3, 1717), 5151);
+        assert_eq!(muli_ui16(1717, 3), 5151);
+        assert_eq!(muli_ui16(4, 1717), 6868);
+        assert_eq!(muli_ui16(1717, 4), 6868);
+        assert_eq!(muli_ui16(1, 17988), 17988);
+        assert_eq!(muli_ui16(17988, 1), 17988);
+        assert_eq!(muli_ui16(2, 17988), 35976);
+        assert_eq!(muli_ui16(17988, 2), 35976);
+        assert_eq!(muli_ui16(3, 17988), 53964);
+        assert_eq!(muli_ui16(17988, 3), 53964);
+        assert_eq!(muli_ui16(1, 65096), 65096);
+        assert_eq!(muli_ui16(65096, 1), 65096);
+        assert_eq!(muli_ui16(1, 65534), 65534);
+        assert_eq!(muli_ui16(65534, 1), 65534);
+        assert_eq!(muli_ui16(1, 65535), 65535);
+        assert_eq!(muli_ui16(65535, 1), 65535);
+        assert_eq!(muli_ui32(0, 0), 0);
+        assert_eq!(muli_ui32(0, 1), 0);
+        assert_eq!(muli_ui32(0, 2), 0);
+        assert_eq!(muli_ui32(0, 3), 0);
+        assert_eq!(muli_ui32(0, 4), 0);
+        assert_eq!(muli_ui32(0, 2119154652), 0);
+        assert_eq!(muli_ui32(0, 3002788344), 0);
+        assert_eq!(muli_ui32(0, 3482297128), 0);
+        assert_eq!(muli_ui32(0, 4294967294), 0);
+        assert_eq!(muli_ui32(0, 4294967295), 0);
+        assert_eq!(muli_ui32(1, 0), 0);
+        assert_eq!(muli_ui32(2, 0), 0);
+        assert_eq!(muli_ui32(3, 0), 0);
+        assert_eq!(muli_ui32(4, 0), 0);
+        assert_eq!(muli_ui32(2119154652, 0), 0);
+        assert_eq!(muli_ui32(3002788344, 0), 0);
+        assert_eq!(muli_ui32(3482297128, 0), 0);
+        assert_eq!(muli_ui32(4294967294, 0), 0);
+        assert_eq!(muli_ui32(4294967295, 0), 0);
+        assert_eq!(muli_ui32(1, 1), 1);
+        assert_eq!(muli_ui32(1, 2), 2);
+        assert_eq!(muli_ui32(2, 1), 2);
+        assert_eq!(muli_ui32(1, 3), 3);
+        assert_eq!(muli_ui32(3, 1), 3);
+        assert_eq!(muli_ui32(1, 4), 4);
+        assert_eq!(muli_ui32(2, 2), 4);
+        assert_eq!(muli_ui32(4, 1), 4);
+        assert_eq!(muli_ui32(2, 3), 6);
+        assert_eq!(muli_ui32(3, 2), 6);
+        assert_eq!(muli_ui32(2, 4), 8);
+        assert_eq!(muli_ui32(4, 2), 8);
+        assert_eq!(muli_ui32(3, 3), 9);
+        assert_eq!(muli_ui32(3, 4), 12);
+        assert_eq!(muli_ui32(4, 3), 12);
+        assert_eq!(muli_ui32(4, 4), 16);
+        assert_eq!(muli_ui32(1, 2119154652), 2119154652);
+        assert_eq!(muli_ui32(2119154652, 1), 2119154652);
+        assert_eq!(muli_ui32(1, 3002788344), 3002788344);
+        assert_eq!(muli_ui32(3002788344, 1), 3002788344);
+        assert_eq!(muli_ui32(1, 3482297128), 3482297128);
+        assert_eq!(muli_ui32(3482297128, 1), 3482297128);
+        assert_eq!(muli_ui32(2, 2119154652), 4238309304);
+        assert_eq!(muli_ui32(2119154652, 2), 4238309304);
+        assert_eq!(muli_ui32(1, 4294967294), 4294967294);
+        assert_eq!(muli_ui32(4294967294, 1), 4294967294);
+        assert_eq!(muli_ui32(1, 4294967295), 4294967295);
+        assert_eq!(muli_ui32(4294967295, 1), 4294967295);
+        assert_eq!(muli_ui64(0, 0), 0);
+        assert_eq!(muli_ui64(0, 1), 0);
+        assert_eq!(muli_ui64(0, 2), 0);
+        assert_eq!(muli_ui64(0, 3), 0);
+        assert_eq!(muli_ui64(0, 4), 0);
+        assert_eq!(muli_ui64(0, 191084152064409600), 0);
+        assert_eq!(muli_ui64(0, 11015955194427482112), 0);
+        assert_eq!(muli_ui64(0, 16990600415051759616), 0);
+        assert_eq!(muli_ui64(0, 18446744073709551614), 0);
+        assert_eq!(muli_ui64(0, 18446744073709551615), 0);
+        assert_eq!(muli_ui64(1, 0), 0);
+        assert_eq!(muli_ui64(2, 0), 0);
+        assert_eq!(muli_ui64(3, 0), 0);
+        assert_eq!(muli_ui64(4, 0), 0);
+        assert_eq!(muli_ui64(191084152064409600, 0), 0);
+        assert_eq!(muli_ui64(11015955194427482112, 0), 0);
+        assert_eq!(muli_ui64(16990600415051759616, 0), 0);
+        assert_eq!(muli_ui64(18446744073709551614, 0), 0);
+        assert_eq!(muli_ui64(18446744073709551615, 0), 0);
+        assert_eq!(muli_ui64(1, 1), 1);
+        assert_eq!(muli_ui64(1, 2), 2);
+        assert_eq!(muli_ui64(2, 1), 2);
+        assert_eq!(muli_ui64(1, 3), 3);
+        assert_eq!(muli_ui64(3, 1), 3);
+        assert_eq!(muli_ui64(1, 4), 4);
+        assert_eq!(muli_ui64(2, 2), 4);
+        assert_eq!(muli_ui64(4, 1), 4);
+        assert_eq!(muli_ui64(2, 3), 6);
+        assert_eq!(muli_ui64(3, 2), 6);
+        assert_eq!(muli_ui64(2, 4), 8);
+        assert_eq!(muli_ui64(4, 2), 8);
+        assert_eq!(muli_ui64(3, 3), 9);
+        assert_eq!(muli_ui64(3, 4), 12);
+        assert_eq!(muli_ui64(4, 3), 12);
+        assert_eq!(muli_ui64(4, 4), 16);
+        assert_eq!(muli_ui64(1, 191084152064409600), 191084152064409600);
+        assert_eq!(muli_ui64(191084152064409600, 1), 191084152064409600);
+        assert_eq!(muli_ui64(2, 191084152064409600), 382168304128819200);
+        assert_eq!(muli_ui64(191084152064409600, 2), 382168304128819200);
+        assert_eq!(muli_ui64(3, 191084152064409600), 573252456193228800);
+        assert_eq!(muli_ui64(191084152064409600, 3), 573252456193228800);
+        assert_eq!(muli_ui64(4, 191084152064409600), 764336608257638400);
+        assert_eq!(muli_ui64(191084152064409600, 4), 764336608257638400);
+        assert_eq!(muli_ui64(1, 11015955194427482112), 11015955194427482112);
+        assert_eq!(muli_ui64(11015955194427482112, 1), 11015955194427482112);
+        assert_eq!(muli_ui64(1, 16990600415051759616), 16990600415051759616);
+        assert_eq!(muli_ui64(16990600415051759616, 1), 16990600415051759616);
+        assert_eq!(muli_ui64(1, 18446744073709551614), 18446744073709551614);
+        assert_eq!(muli_ui64(18446744073709551614, 1), 18446744073709551614);
+        assert_eq!(muli_ui64(1, 18446744073709551615), 18446744073709551615);
+        assert_eq!(muli_ui64(18446744073709551615, 1), 18446744073709551615);
+        assert_eq!(muli_ui8(0, 0), 0);
+        assert_eq!(muli_ui8(0, 1), 0);
+        assert_eq!(muli_ui8(0, 2), 0);
+        assert_eq!(muli_ui8(0, 3), 0);
+        assert_eq!(muli_ui8(0, 4), 0);
+        assert_eq!(muli_ui8(0, 72), 0);
+        assert_eq!(muli_ui8(0, 100), 0);
+        assert_eq!(muli_ui8(0, 162), 0);
+        assert_eq!(muli_ui8(0, 254), 0);
+        assert_eq!(muli_ui8(0, 255), 0);
+        assert_eq!(muli_ui8(1, 0), 0);
+        assert_eq!(muli_ui8(2, 0), 0);
+        assert_eq!(muli_ui8(3, 0), 0);
+        assert_eq!(muli_ui8(4, 0), 0);
+        assert_eq!(muli_ui8(72, 0), 0);
+        assert_eq!(muli_ui8(100, 0), 0);
+        assert_eq!(muli_ui8(162, 0), 0);
+        assert_eq!(muli_ui8(254, 0), 0);
+        assert_eq!(muli_ui8(255, 0), 0);
+        assert_eq!(muli_ui8(1, 1), 1);
+        assert_eq!(muli_ui8(1, 2), 2);
+        assert_eq!(muli_ui8(2, 1), 2);
+        assert_eq!(muli_ui8(1, 3), 3);
+        assert_eq!(muli_ui8(3, 1), 3);
+        assert_eq!(muli_ui8(1, 4), 4);
+        assert_eq!(muli_ui8(2, 2), 4);
+        assert_eq!(muli_ui8(4, 1), 4);
+        assert_eq!(muli_ui8(2, 3), 6);
+        assert_eq!(muli_ui8(3, 2), 6);
+        assert_eq!(muli_ui8(2, 4), 8);
+        assert_eq!(muli_ui8(4, 2), 8);
+        assert_eq!(muli_ui8(3, 3), 9);
+        assert_eq!(muli_ui8(3, 4), 12);
+        assert_eq!(muli_ui8(4, 3), 12);
+        assert_eq!(muli_ui8(4, 4), 16);
+        assert_eq!(muli_ui8(1, 72), 72);
+        assert_eq!(muli_ui8(72, 1), 72);
+        assert_eq!(muli_ui8(1, 100), 100);
+        assert_eq!(muli_ui8(100, 1), 100);
+        assert_eq!(muli_ui8(2, 72), 144);
+        assert_eq!(muli_ui8(72, 2), 144);
+        assert_eq!(muli_ui8(1, 162), 162);
+        assert_eq!(muli_ui8(162, 1), 162);
+        assert_eq!(muli_ui8(2, 100), 200);
+        assert_eq!(muli_ui8(100, 2), 200);
+        assert_eq!(muli_ui8(3, 72), 216);
+        assert_eq!(muli_ui8(72, 3), 216);
+        assert_eq!(muli_ui8(1, 254), 254);
+        assert_eq!(muli_ui8(254, 1), 254);
+        assert_eq!(muli_ui8(1, 255), 255);
+        assert_eq!(muli_ui8(255, 1), 255);
+        assert_eq!(remi_si16(-32767, -32768), -32767);
+        assert_eq!(remi_si16(-32547, -32768), -32547);
+        assert_eq!(remi_si16(-32547, -32767), -32547);
+        assert_eq!(remi_si16(-32547, 32766), -32547);
+        assert_eq!(remi_si16(-32547, 32767), -32547);
+        assert_eq!(remi_si16(-32768, 16514), -16254);
+        assert_eq!(remi_si16(-32767, 16514), -16253);
+        assert_eq!(remi_si16(-32547, 16514), -16033);
+        assert_eq!(remi_si16(-32768, 10486), -1310);
+        assert_eq!(remi_si16(-32767, 10486), -1309);
+        assert_eq!(remi_si16(-32547, 10486), -1089);
+        assert_eq!(remi_si16(-32768, -32547), -221);
+        assert_eq!(remi_si16(-32767, -32547), -220);
+        assert_eq!(remi_si16(-32767, 4), -3);
+        assert_eq!(remi_si16(-32547, 4), -3);
+        assert_eq!(remi_si16(-32768, 3), -2);
+        assert_eq!(remi_si16(-32768, 32766), -2);
+        assert_eq!(remi_si16(-32768, -32767), -1);
+        assert_eq!(remi_si16(-32768, 32767), -1);
+        assert_eq!(remi_si16(-32767, 2), -1);
+        assert_eq!(remi_si16(-32767, 3), -1);
+        assert_eq!(remi_si16(-32767, 32766), -1);
+        assert_eq!(remi_si16(-32547, 2), -1);
+        assert_eq!(remi_si16(-32768, -32768), 0);
+        assert_eq!(remi_si16(-32768, 1), 0);
+        assert_eq!(remi_si16(-32768, 2), 0);
+        assert_eq!(remi_si16(-32768, 4), 0);
+        assert_eq!(remi_si16(-32767, -32767), 0);
+        assert_eq!(remi_si16(-32767, 1), 0);
+        assert_eq!(remi_si16(-32767, 32767), 0);
+        assert_eq!(remi_si16(-32547, -32547), 0);
+        assert_eq!(remi_si16(-32547, 1), 0);
+        assert_eq!(remi_si16(-32547, 3), 0);
+        assert_eq!(remi_si16(0, -32768), 0);
+        assert_eq!(remi_si16(0, -32767), 0);
+        assert_eq!(remi_si16(0, -32547), 0);
+        assert_eq!(remi_si16(0, 1), 0);
+        assert_eq!(remi_si16(0, 2), 0);
+        assert_eq!(remi_si16(0, 3), 0);
+        assert_eq!(remi_si16(0, 4), 0);
+        assert_eq!(remi_si16(0, 10486), 0);
+        assert_eq!(remi_si16(0, 16514), 0);
+        assert_eq!(remi_si16(0, 32766), 0);
+        assert_eq!(remi_si16(0, 32767), 0);
+        assert_eq!(remi_si16(1, 1), 0);
+        assert_eq!(remi_si16(2, 1), 0);
+        assert_eq!(remi_si16(2, 2), 0);
+        assert_eq!(remi_si16(3, 1), 0);
+        assert_eq!(remi_si16(3, 3), 0);
+        assert_eq!(remi_si16(4, 1), 0);
+        assert_eq!(remi_si16(4, 2), 0);
+        assert_eq!(remi_si16(4, 4), 0);
+        assert_eq!(remi_si16(10486, 1), 0);
+        assert_eq!(remi_si16(10486, 2), 0);
+        assert_eq!(remi_si16(10486, 10486), 0);
+        assert_eq!(remi_si16(16514, 1), 0);
+        assert_eq!(remi_si16(16514, 2), 0);
+        assert_eq!(remi_si16(16514, 16514), 0);
+        assert_eq!(remi_si16(32766, 1), 0);
+        assert_eq!(remi_si16(32766, 2), 0);
+        assert_eq!(remi_si16(32766, 3), 0);
+        assert_eq!(remi_si16(32766, 32766), 0);
+        assert_eq!(remi_si16(32767, -32767), 0);
+        assert_eq!(remi_si16(32767, 1), 0);
+        assert_eq!(remi_si16(32767, 32767), 0);
+        assert_eq!(remi_si16(1, -32768), 1);
+        assert_eq!(remi_si16(1, -32767), 1);
+        assert_eq!(remi_si16(1, -32547), 1);
+        assert_eq!(remi_si16(1, 2), 1);
+        assert_eq!(remi_si16(1, 3), 1);
+        assert_eq!(remi_si16(1, 4), 1);
+        assert_eq!(remi_si16(1, 10486), 1);
+        assert_eq!(remi_si16(1, 16514), 1);
+        assert_eq!(remi_si16(1, 32766), 1);
+        assert_eq!(remi_si16(1, 32767), 1);
+        assert_eq!(remi_si16(3, 2), 1);
+        assert_eq!(remi_si16(4, 3), 1);
+        assert_eq!(remi_si16(10486, 3), 1);
+        assert_eq!(remi_si16(32767, 2), 1);
+        assert_eq!(remi_si16(32767, 3), 1);
+        assert_eq!(remi_si16(32767, 32766), 1);
+        assert_eq!(remi_si16(2, -32768), 2);
+        assert_eq!(remi_si16(2, -32767), 2);
+        assert_eq!(remi_si16(2, -32547), 2);
+        assert_eq!(remi_si16(2, 3), 2);
+        assert_eq!(remi_si16(2, 4), 2);
+        assert_eq!(remi_si16(2, 10486), 2);
+        assert_eq!(remi_si16(2, 16514), 2);
+        assert_eq!(remi_si16(2, 32766), 2);
+        assert_eq!(remi_si16(2, 32767), 2);
+        assert_eq!(remi_si16(10486, 4), 2);
+        assert_eq!(remi_si16(16514, 3), 2);
+        assert_eq!(remi_si16(16514, 4), 2);
+        assert_eq!(remi_si16(32766, 4), 2);
+        assert_eq!(remi_si16(3, -32768), 3);
+        assert_eq!(remi_si16(3, -32767), 3);
+        assert_eq!(remi_si16(3, -32547), 3);
+        assert_eq!(remi_si16(3, 4), 3);
+        assert_eq!(remi_si16(3, 10486), 3);
+        assert_eq!(remi_si16(3, 16514), 3);
+        assert_eq!(remi_si16(3, 32766), 3);
+        assert_eq!(remi_si16(3, 32767), 3);
+        assert_eq!(remi_si16(32767, 4), 3);
+        assert_eq!(remi_si16(4, -32768), 4);
+        assert_eq!(remi_si16(4, -32767), 4);
+        assert_eq!(remi_si16(4, -32547), 4);
+        assert_eq!(remi_si16(4, 10486), 4);
+        assert_eq!(remi_si16(4, 16514), 4);
+        assert_eq!(remi_si16(4, 32766), 4);
+        assert_eq!(remi_si16(4, 32767), 4);
+        assert_eq!(remi_si16(32766, -32547), 219);
+        assert_eq!(remi_si16(32767, -32547), 220);
+        assert_eq!(remi_si16(32766, 10486), 1308);
+        assert_eq!(remi_si16(32767, 10486), 1309);
+        assert_eq!(remi_si16(16514, 10486), 6028);
+        assert_eq!(remi_si16(10486, -32768), 10486);
+        assert_eq!(remi_si16(10486, -32767), 10486);
+        assert_eq!(remi_si16(10486, -32547), 10486);
+        assert_eq!(remi_si16(10486, 16514), 10486);
+        assert_eq!(remi_si16(10486, 32766), 10486);
+        assert_eq!(remi_si16(10486, 32767), 10486);
+        assert_eq!(remi_si16(32766, 16514), 16252);
+        assert_eq!(remi_si16(32767, 16514), 16253);
+        assert_eq!(remi_si16(16514, -32768), 16514);
+        assert_eq!(remi_si16(16514, -32767), 16514);
+        assert_eq!(remi_si16(16514, -32547), 16514);
+        assert_eq!(remi_si16(16514, 32766), 16514);
+        assert_eq!(remi_si16(16514, 32767), 16514);
+        assert_eq!(remi_si16(32766, -32768), 32766);
+        assert_eq!(remi_si16(32766, -32767), 32766);
+        assert_eq!(remi_si16(32766, 32767), 32766);
+        assert_eq!(remi_si16(32767, -32768), 32767);
+        assert_eq!(remi_si32(-2147483647, -2147483648), -2147483647);
+        assert_eq!(remi_si32(-1713183800, -2147483648), -1713183800);
+        assert_eq!(remi_si32(-1713183800, -2147483647), -1713183800);
+        assert_eq!(remi_si32(-1713183800, 2147483646), -1713183800);
+        assert_eq!(remi_si32(-1713183800, 2147483647), -1713183800);
+        assert_eq!(remi_si32(-1252582164, -2147483648), -1252582164);
+        assert_eq!(remi_si32(-1252582164, -2147483647), -1252582164);
+        assert_eq!(remi_si32(-1252582164, -1713183800), -1252582164);
+        assert_eq!(remi_si32(-1252582164, 2147483646), -1252582164);
+        assert_eq!(remi_si32(-1252582164, 2147483647), -1252582164);
+        assert_eq!(remi_si32(-1035405763, -2147483648), -1035405763);
+        assert_eq!(remi_si32(-1035405763, -2147483647), -1035405763);
+        assert_eq!(remi_si32(-1035405763, -1713183800), -1035405763);
+        assert_eq!(remi_si32(-1035405763, -1252582164), -1035405763);
+        assert_eq!(remi_si32(-1035405763, 2147483646), -1035405763);
+        assert_eq!(remi_si32(-1035405763, 2147483647), -1035405763);
+        assert_eq!(remi_si32(-2147483648, -1252582164), -894901484);
+        assert_eq!(remi_si32(-2147483647, -1252582164), -894901483);
+        assert_eq!(remi_si32(-1713183800, -1035405763), -677778037);
+        assert_eq!(remi_si32(-1713183800, -1252582164), -460601636);
+        assert_eq!(remi_si32(-2147483648, -1713183800), -434299848);
+        assert_eq!(remi_si32(-2147483647, -1713183800), -434299847);
+        assert_eq!(remi_si32(-1252582164, -1035405763), -217176401);
+        assert_eq!(remi_si32(-2147483648, -1035405763), -76672122);
+        assert_eq!(remi_si32(-2147483647, -1035405763), -76672121);
+        assert_eq!(remi_si32(-2147483647, 4), -3);
+        assert_eq!(remi_si32(-1035405763, 4), -3);
+        assert_eq!(remi_si32(-2147483648, 3), -2);
+        assert_eq!(remi_si32(-2147483648, 2147483646), -2);
+        assert_eq!(remi_si32(-1713183800, 3), -2);
+        assert_eq!(remi_si32(-2147483648, -2147483647), -1);
+        assert_eq!(remi_si32(-2147483648, 2147483647), -1);
+        assert_eq!(remi_si32(-2147483647, 2), -1);
+        assert_eq!(remi_si32(-2147483647, 3), -1);
+        assert_eq!(remi_si32(-2147483647, 2147483646), -1);
+        assert_eq!(remi_si32(-1035405763, 2), -1);
+        assert_eq!(remi_si32(-1035405763, 3), -1);
+        assert_eq!(remi_si32(-2147483648, -2147483648), 0);
+        assert_eq!(remi_si32(-2147483648, 1), 0);
+        assert_eq!(remi_si32(-2147483648, 2), 0);
+        assert_eq!(remi_si32(-2147483648, 4), 0);
+        assert_eq!(remi_si32(-2147483647, -2147483647), 0);
+        assert_eq!(remi_si32(-2147483647, 1), 0);
+        assert_eq!(remi_si32(-2147483647, 2147483647), 0);
+        assert_eq!(remi_si32(-1713183800, -1713183800), 0);
+        assert_eq!(remi_si32(-1713183800, 1), 0);
+        assert_eq!(remi_si32(-1713183800, 2), 0);
+        assert_eq!(remi_si32(-1713183800, 4), 0);
+        assert_eq!(remi_si32(-1252582164, -1252582164), 0);
+        assert_eq!(remi_si32(-1252582164, 1), 0);
+        assert_eq!(remi_si32(-1252582164, 2), 0);
+        assert_eq!(remi_si32(-1252582164, 3), 0);
+        assert_eq!(remi_si32(-1252582164, 4), 0);
+        assert_eq!(remi_si32(-1035405763, -1035405763), 0);
+        assert_eq!(remi_si32(-1035405763, 1), 0);
+        assert_eq!(remi_si32(0, -2147483648), 0);
+        assert_eq!(remi_si32(0, -2147483647), 0);
+        assert_eq!(remi_si32(0, -1713183800), 0);
+        assert_eq!(remi_si32(0, -1252582164), 0);
+        assert_eq!(remi_si32(0, -1035405763), 0);
+        assert_eq!(remi_si32(0, 1), 0);
+        assert_eq!(remi_si32(0, 2), 0);
+        assert_eq!(remi_si32(0, 3), 0);
+        assert_eq!(remi_si32(0, 4), 0);
+        assert_eq!(remi_si32(0, 2147483646), 0);
+        assert_eq!(remi_si32(0, 2147483647), 0);
+        assert_eq!(remi_si32(1, 1), 0);
+        assert_eq!(remi_si32(2, 1), 0);
+        assert_eq!(remi_si32(2, 2), 0);
+        assert_eq!(remi_si32(3, 1), 0);
+        assert_eq!(remi_si32(3, 3), 0);
+        assert_eq!(remi_si32(4, 1), 0);
+        assert_eq!(remi_si32(4, 2), 0);
+        assert_eq!(remi_si32(4, 4), 0);
+        assert_eq!(remi_si32(2147483646, 1), 0);
+        assert_eq!(remi_si32(2147483646, 2), 0);
+        assert_eq!(remi_si32(2147483646, 3), 0);
+        assert_eq!(remi_si32(2147483646, 2147483646), 0);
+        assert_eq!(remi_si32(2147483647, -2147483647), 0);
+        assert_eq!(remi_si32(2147483647, 1), 0);
+        assert_eq!(remi_si32(2147483647, 2147483647), 0);
+        assert_eq!(remi_si32(1, -2147483648), 1);
+        assert_eq!(remi_si32(1, -2147483647), 1);
+        assert_eq!(remi_si32(1, -1713183800), 1);
+        assert_eq!(remi_si32(1, -1252582164), 1);
+        assert_eq!(remi_si32(1, -1035405763), 1);
+        assert_eq!(remi_si32(1, 2), 1);
+        assert_eq!(remi_si32(1, 3), 1);
+        assert_eq!(remi_si32(1, 4), 1);
+        assert_eq!(remi_si32(1, 2147483646), 1);
+        assert_eq!(remi_si32(1, 2147483647), 1);
+        assert_eq!(remi_si32(3, 2), 1);
+        assert_eq!(remi_si32(4, 3), 1);
+        assert_eq!(remi_si32(2147483647, 2), 1);
+        assert_eq!(remi_si32(2147483647, 3), 1);
+        assert_eq!(remi_si32(2147483647, 2147483646), 1);
+        assert_eq!(remi_si32(2, -2147483648), 2);
+        assert_eq!(remi_si32(2, -2147483647), 2);
+        assert_eq!(remi_si32(2, -1713183800), 2);
+        assert_eq!(remi_si32(2, -1252582164), 2);
+        assert_eq!(remi_si32(2, -1035405763), 2);
+        assert_eq!(remi_si32(2, 3), 2);
+        assert_eq!(remi_si32(2, 4), 2);
+        assert_eq!(remi_si32(2, 2147483646), 2);
+        assert_eq!(remi_si32(2, 2147483647), 2);
+        assert_eq!(remi_si32(2147483646, 4), 2);
+        assert_eq!(remi_si32(3, -2147483648), 3);
+        assert_eq!(remi_si32(3, -2147483647), 3);
+        assert_eq!(remi_si32(3, -1713183800), 3);
+        assert_eq!(remi_si32(3, -1252582164), 3);
+        assert_eq!(remi_si32(3, -1035405763), 3);
+        assert_eq!(remi_si32(3, 4), 3);
+        assert_eq!(remi_si32(3, 2147483646), 3);
+        assert_eq!(remi_si32(3, 2147483647), 3);
+        assert_eq!(remi_si32(2147483647, 4), 3);
+        assert_eq!(remi_si32(4, -2147483648), 4);
+        assert_eq!(remi_si32(4, -2147483647), 4);
+        assert_eq!(remi_si32(4, -1713183800), 4);
+        assert_eq!(remi_si32(4, -1252582164), 4);
+        assert_eq!(remi_si32(4, -1035405763), 4);
+        assert_eq!(remi_si32(4, 2147483646), 4);
+        assert_eq!(remi_si32(4, 2147483647), 4);
+        assert_eq!(remi_si32(2147483646, -1035405763), 76672120);
+        assert_eq!(remi_si32(2147483647, -1035405763), 76672121);
+        assert_eq!(remi_si32(2147483646, -1713183800), 434299846);
+        assert_eq!(remi_si32(2147483647, -1713183800), 434299847);
+        assert_eq!(remi_si32(2147483646, -1252582164), 894901482);
+        assert_eq!(remi_si32(2147483647, -1252582164), 894901483);
+        assert_eq!(remi_si32(2147483646, -2147483648), 2147483646);
+        assert_eq!(remi_si32(2147483646, -2147483647), 2147483646);
+        assert_eq!(remi_si32(2147483646, 2147483647), 2147483646);
+        assert_eq!(remi_si32(2147483647, -2147483648), 2147483647);
+        assert_eq!(
+            remi_si64(-9223372036854775807, -9223372036854775808),
+            -9223372036854775807
+        );
+        assert_eq!(
+            remi_si64(-9223372036854775808, 5577148965131116544),
+            -3646223071723659264
+        );
+        assert_eq!(
+            remi_si64(-9223372036854775807, 5577148965131116544),
+            -3646223071723659263
+        );
+        assert_eq!(
+            remi_si64(-1741927215160008704, -9223372036854775808),
+            -1741927215160008704
+        );
+        assert_eq!(
+            remi_si64(-1741927215160008704, -9223372036854775807),
+            -1741927215160008704
+        );
+        assert_eq!(
+            remi_si64(-1741927215160008704, 5577148965131116544),
+            -1741927215160008704
+        );
+        assert_eq!(
+            remi_si64(-1741927215160008704, 9223372036854775806),
+            -1741927215160008704
+        );
+        assert_eq!(
+            remi_si64(-1741927215160008704, 9223372036854775807),
+            -1741927215160008704
+        );
+        assert_eq!(
+            remi_si64(-1328271339354574848, -9223372036854775808),
+            -1328271339354574848
+        );
+        assert_eq!(
+            remi_si64(-1328271339354574848, -9223372036854775807),
+            -1328271339354574848
+        );
+        assert_eq!(
+            remi_si64(-1328271339354574848, -1741927215160008704),
+            -1328271339354574848
+        );
+        assert_eq!(
+            remi_si64(-1328271339354574848, 5577148965131116544),
+            -1328271339354574848
+        );
+        assert_eq!(
+            remi_si64(-1328271339354574848, 9223372036854775806),
+            -1328271339354574848
+        );
+        assert_eq!(
+            remi_si64(-1328271339354574848, 9223372036854775807),
+            -1328271339354574848
+        );
+        assert_eq!(
+            remi_si64(-9223372036854775808, -1328271339354574848),
+            -1253744000727326720
+        );
+        assert_eq!(
+            remi_si64(-9223372036854775807, -1328271339354574848),
+            -1253744000727326719
+        );
+        assert_eq!(
+            remi_si64(-9223372036854775808, -1741927215160008704),
+            -513735961054732288
+        );
+        assert_eq!(
+            remi_si64(-9223372036854775807, -1741927215160008704),
+            -513735961054732287
+        );
+        assert_eq!(
+            remi_si64(-1741927215160008704, -1328271339354574848),
+            -413655875805433856
+        );
+        assert_eq!(remi_si64(-9223372036854775807, 4), -3);
+        assert_eq!(remi_si64(-9223372036854775808, 3), -2);
+        assert_eq!(remi_si64(-9223372036854775808, 9223372036854775806), -2);
+        assert_eq!(remi_si64(-1741927215160008704, 3), -2);
+        assert_eq!(remi_si64(-9223372036854775808, -9223372036854775807), -1);
+        assert_eq!(remi_si64(-9223372036854775808, 9223372036854775807), -1);
+        assert_eq!(remi_si64(-9223372036854775807, 2), -1);
+        assert_eq!(remi_si64(-9223372036854775807, 3), -1);
+        assert_eq!(remi_si64(-9223372036854775807, 9223372036854775806), -1);
+        assert_eq!(remi_si64(-9223372036854775808, -9223372036854775808), 0);
+        assert_eq!(remi_si64(-9223372036854775808, 1), 0);
+        assert_eq!(remi_si64(-9223372036854775808, 2), 0);
+        assert_eq!(remi_si64(-9223372036854775808, 4), 0);
+        assert_eq!(remi_si64(-9223372036854775807, -9223372036854775807), 0);
+        assert_eq!(remi_si64(-9223372036854775807, 1), 0);
+        assert_eq!(remi_si64(-9223372036854775807, 9223372036854775807), 0);
+        assert_eq!(remi_si64(-1741927215160008704, -1741927215160008704), 0);
+        assert_eq!(remi_si64(-1741927215160008704, 1), 0);
+        assert_eq!(remi_si64(-1741927215160008704, 2), 0);
+        assert_eq!(remi_si64(-1741927215160008704, 4), 0);
+        assert_eq!(remi_si64(-1328271339354574848, -1328271339354574848), 0);
+        assert_eq!(remi_si64(-1328271339354574848, 1), 0);
+        assert_eq!(remi_si64(-1328271339354574848, 2), 0);
+        assert_eq!(remi_si64(-1328271339354574848, 3), 0);
+        assert_eq!(remi_si64(-1328271339354574848, 4), 0);
+        assert_eq!(remi_si64(0, -9223372036854775808), 0);
+        assert_eq!(remi_si64(0, -9223372036854775807), 0);
+        assert_eq!(remi_si64(0, -1741927215160008704), 0);
+        assert_eq!(remi_si64(0, -1328271339354574848), 0);
+        assert_eq!(remi_si64(0, 1), 0);
+        assert_eq!(remi_si64(0, 2), 0);
+        assert_eq!(remi_si64(0, 3), 0);
+        assert_eq!(remi_si64(0, 4), 0);
+        assert_eq!(remi_si64(0, 5577148965131116544), 0);
+        assert_eq!(remi_si64(0, 9223372036854775806), 0);
+        assert_eq!(remi_si64(0, 9223372036854775807), 0);
+        assert_eq!(remi_si64(1, 1), 0);
+        assert_eq!(remi_si64(2, 1), 0);
+        assert_eq!(remi_si64(2, 2), 0);
+        assert_eq!(remi_si64(3, 1), 0);
+        assert_eq!(remi_si64(3, 3), 0);
+        assert_eq!(remi_si64(4, 1), 0);
+        assert_eq!(remi_si64(4, 2), 0);
+        assert_eq!(remi_si64(4, 4), 0);
+        assert_eq!(remi_si64(5577148965131116544, 1), 0);
+        assert_eq!(remi_si64(5577148965131116544, 2), 0);
+        assert_eq!(remi_si64(5577148965131116544, 4), 0);
+        assert_eq!(remi_si64(5577148965131116544, 5577148965131116544), 0);
+        assert_eq!(remi_si64(9223372036854775806, 1), 0);
+        assert_eq!(remi_si64(9223372036854775806, 2), 0);
+        assert_eq!(remi_si64(9223372036854775806, 3), 0);
+        assert_eq!(remi_si64(9223372036854775806, 9223372036854775806), 0);
+        assert_eq!(remi_si64(9223372036854775807, -9223372036854775807), 0);
+        assert_eq!(remi_si64(9223372036854775807, 1), 0);
+        assert_eq!(remi_si64(9223372036854775807, 9223372036854775807), 0);
+        assert_eq!(remi_si64(1, -9223372036854775808), 1);
+        assert_eq!(remi_si64(1, -9223372036854775807), 1);
+        assert_eq!(remi_si64(1, -1741927215160008704), 1);
+        assert_eq!(remi_si64(1, -1328271339354574848), 1);
+        assert_eq!(remi_si64(1, 2), 1);
+        assert_eq!(remi_si64(1, 3), 1);
+        assert_eq!(remi_si64(1, 4), 1);
+        assert_eq!(remi_si64(1, 5577148965131116544), 1);
+        assert_eq!(remi_si64(1, 9223372036854775806), 1);
+        assert_eq!(remi_si64(1, 9223372036854775807), 1);
+        assert_eq!(remi_si64(3, 2), 1);
+        assert_eq!(remi_si64(4, 3), 1);
+        assert_eq!(remi_si64(9223372036854775807, 2), 1);
+        assert_eq!(remi_si64(9223372036854775807, 3), 1);
+        assert_eq!(remi_si64(9223372036854775807, 9223372036854775806), 1);
+        assert_eq!(remi_si64(2, -9223372036854775808), 2);
+        assert_eq!(remi_si64(2, -9223372036854775807), 2);
+        assert_eq!(remi_si64(2, -1741927215160008704), 2);
+        assert_eq!(remi_si64(2, -1328271339354574848), 2);
+        assert_eq!(remi_si64(2, 3), 2);
+        assert_eq!(remi_si64(2, 4), 2);
+        assert_eq!(remi_si64(2, 5577148965131116544), 2);
+        assert_eq!(remi_si64(2, 9223372036854775806), 2);
+        assert_eq!(remi_si64(2, 9223372036854775807), 2);
+        assert_eq!(remi_si64(5577148965131116544, 3), 2);
+        assert_eq!(remi_si64(9223372036854775806, 4), 2);
+        assert_eq!(remi_si64(3, -9223372036854775808), 3);
+        assert_eq!(remi_si64(3, -9223372036854775807), 3);
+        assert_eq!(remi_si64(3, -1741927215160008704), 3);
+        assert_eq!(remi_si64(3, -1328271339354574848), 3);
+        assert_eq!(remi_si64(3, 4), 3);
+        assert_eq!(remi_si64(3, 5577148965131116544), 3);
+        assert_eq!(remi_si64(3, 9223372036854775806), 3);
+        assert_eq!(remi_si64(3, 9223372036854775807), 3);
+        assert_eq!(remi_si64(9223372036854775807, 4), 3);
+        assert_eq!(remi_si64(4, -9223372036854775808), 4);
+        assert_eq!(remi_si64(4, -9223372036854775807), 4);
+        assert_eq!(remi_si64(4, -1741927215160008704), 4);
+        assert_eq!(remi_si64(4, -1328271339354574848), 4);
+        assert_eq!(remi_si64(4, 5577148965131116544), 4);
+        assert_eq!(remi_si64(4, 9223372036854775806), 4);
+        assert_eq!(remi_si64(4, 9223372036854775807), 4);
+        assert_eq!(
+            remi_si64(5577148965131116544, -1328271339354574848),
+            264063607712817152
+        );
+        assert_eq!(
+            remi_si64(5577148965131116544, -1741927215160008704),
+            351367319651090432
+        );
+        assert_eq!(
+            remi_si64(9223372036854775806, -1741927215160008704),
+            513735961054732286
+        );
+        assert_eq!(
+            remi_si64(9223372036854775807, -1741927215160008704),
+            513735961054732287
+        );
+        assert_eq!(
+            remi_si64(9223372036854775806, -1328271339354574848),
+            1253744000727326718
+        );
+        assert_eq!(
+            remi_si64(9223372036854775807, -1328271339354574848),
+            1253744000727326719
+        );
+        assert_eq!(
+            remi_si64(9223372036854775806, 5577148965131116544),
+            3646223071723659262
+        );
+        assert_eq!(
+            remi_si64(9223372036854775807, 5577148965131116544),
+            3646223071723659263
+        );
+        assert_eq!(
+            remi_si64(5577148965131116544, -9223372036854775808),
+            5577148965131116544
+        );
+        assert_eq!(
+            remi_si64(5577148965131116544, -9223372036854775807),
+            5577148965131116544
+        );
+        assert_eq!(
+            remi_si64(5577148965131116544, 9223372036854775806),
+            5577148965131116544
+        );
+        assert_eq!(
+            remi_si64(5577148965131116544, 9223372036854775807),
+            5577148965131116544
+        );
+        assert_eq!(
+            remi_si64(9223372036854775806, -9223372036854775808),
+            9223372036854775806
+        );
+        assert_eq!(
+            remi_si64(9223372036854775806, -9223372036854775807),
+            9223372036854775806
+        );
+        assert_eq!(
+            remi_si64(9223372036854775806, 9223372036854775807),
+            9223372036854775806
+        );
+        assert_eq!(
+            remi_si64(9223372036854775807, -9223372036854775808),
+            9223372036854775807
+        );
+        assert_eq!(remi_si8(-127, -128), -127);
+        assert_eq!(remi_si8(-127, 16), -15);
+        assert_eq!(remi_si8(-127, 4), -3);
+        assert_eq!(remi_si8(-128, 3), -2);
+        assert_eq!(remi_si8(-128, 126), -2);
+        assert_eq!(remi_si8(-128, -127), -1);
+        assert_eq!(remi_si8(-128, 127), -1);
+        assert_eq!(remi_si8(-127, 2), -1);
+        assert_eq!(remi_si8(-127, 3), -1);
+        assert_eq!(remi_si8(-127, 126), -1);
+        assert_eq!(remi_si8(-128, -128), 0);
+        assert_eq!(remi_si8(-128, 1), 0);
+        assert_eq!(remi_si8(-128, 2), 0);
+        assert_eq!(remi_si8(-128, 4), 0);
+        assert_eq!(remi_si8(-128, 16), 0);
+        assert_eq!(remi_si8(-127, -127), 0);
+        assert_eq!(remi_si8(-127, 1), 0);
+        assert_eq!(remi_si8(-127, 127), 0);
+        assert_eq!(remi_si8(0, -128), 0);
+        assert_eq!(remi_si8(0, -127), 0);
+        assert_eq!(remi_si8(0, 1), 0);
+        assert_eq!(remi_si8(0, 2), 0);
+        assert_eq!(remi_si8(0, 3), 0);
+        assert_eq!(remi_si8(0, 4), 0);
+        assert_eq!(remi_si8(0, 16), 0);
+        assert_eq!(remi_si8(0, 126), 0);
+        assert_eq!(remi_si8(0, 127), 0);
+        assert_eq!(remi_si8(1, 1), 0);
+        assert_eq!(remi_si8(2, 1), 0);
+        assert_eq!(remi_si8(2, 2), 0);
+        assert_eq!(remi_si8(3, 1), 0);
+        assert_eq!(remi_si8(3, 3), 0);
+        assert_eq!(remi_si8(4, 1), 0);
+        assert_eq!(remi_si8(4, 2), 0);
+        assert_eq!(remi_si8(4, 4), 0);
+        assert_eq!(remi_si8(16, 1), 0);
+        assert_eq!(remi_si8(16, 2), 0);
+        assert_eq!(remi_si8(16, 4), 0);
+        assert_eq!(remi_si8(16, 16), 0);
+        assert_eq!(remi_si8(126, 1), 0);
+        assert_eq!(remi_si8(126, 2), 0);
+        assert_eq!(remi_si8(126, 3), 0);
+        assert_eq!(remi_si8(126, 126), 0);
+        assert_eq!(remi_si8(127, -127), 0);
+        assert_eq!(remi_si8(127, 1), 0);
+        assert_eq!(remi_si8(127, 127), 0);
+        assert_eq!(remi_si8(1, -128), 1);
+        assert_eq!(remi_si8(1, -127), 1);
+        assert_eq!(remi_si8(1, 2), 1);
+        assert_eq!(remi_si8(1, 3), 1);
+        assert_eq!(remi_si8(1, 4), 1);
+        assert_eq!(remi_si8(1, 16), 1);
+        assert_eq!(remi_si8(1, 126), 1);
+        assert_eq!(remi_si8(1, 127), 1);
+        assert_eq!(remi_si8(3, 2), 1);
+        assert_eq!(remi_si8(4, 3), 1);
+        assert_eq!(remi_si8(16, 3), 1);
+        assert_eq!(remi_si8(127, 2), 1);
+        assert_eq!(remi_si8(127, 3), 1);
+        assert_eq!(remi_si8(127, 126), 1);
+        assert_eq!(remi_si8(2, -128), 2);
+        assert_eq!(remi_si8(2, -127), 2);
+        assert_eq!(remi_si8(2, 3), 2);
+        assert_eq!(remi_si8(2, 4), 2);
+        assert_eq!(remi_si8(2, 16), 2);
+        assert_eq!(remi_si8(2, 126), 2);
+        assert_eq!(remi_si8(2, 127), 2);
+        assert_eq!(remi_si8(126, 4), 2);
+        assert_eq!(remi_si8(3, -128), 3);
+        assert_eq!(remi_si8(3, -127), 3);
+        assert_eq!(remi_si8(3, 4), 3);
+        assert_eq!(remi_si8(3, 16), 3);
+        assert_eq!(remi_si8(3, 126), 3);
+        assert_eq!(remi_si8(3, 127), 3);
+        assert_eq!(remi_si8(127, 4), 3);
+        assert_eq!(remi_si8(4, -128), 4);
+        assert_eq!(remi_si8(4, -127), 4);
+        assert_eq!(remi_si8(4, 16), 4);
+        assert_eq!(remi_si8(4, 126), 4);
+        assert_eq!(remi_si8(4, 127), 4);
+        assert_eq!(remi_si8(126, 16), 14);
+        assert_eq!(remi_si8(127, 16), 15);
+        assert_eq!(remi_si8(16, -128), 16);
+        assert_eq!(remi_si8(16, -127), 16);
+        assert_eq!(remi_si8(16, 126), 16);
+        assert_eq!(remi_si8(16, 127), 16);
+        assert_eq!(remi_si8(126, -128), 126);
+        assert_eq!(remi_si8(126, -127), 126);
+        assert_eq!(remi_si8(126, 127), 126);
+        assert_eq!(remi_si8(127, -128), 127);
+        assert_eq!(remi_ui16(0, 1), 0);
+        assert_eq!(remi_ui16(0, 2), 0);
+        assert_eq!(remi_ui16(0, 3), 0);
+        assert_eq!(remi_ui16(0, 4), 0);
+        assert_eq!(remi_ui16(0, 1717), 0);
+        assert_eq!(remi_ui16(0, 17988), 0);
+        assert_eq!(remi_ui16(0, 65096), 0);
+        assert_eq!(remi_ui16(0, 65534), 0);
+        assert_eq!(remi_ui16(0, 65535), 0);
+        assert_eq!(remi_ui16(1, 1), 0);
+        assert_eq!(remi_ui16(2, 1), 0);
+        assert_eq!(remi_ui16(2, 2), 0);
+        assert_eq!(remi_ui16(3, 1), 0);
+        assert_eq!(remi_ui16(3, 3), 0);
+        assert_eq!(remi_ui16(4, 1), 0);
+        assert_eq!(remi_ui16(4, 2), 0);
+        assert_eq!(remi_ui16(4, 4), 0);
+        assert_eq!(remi_ui16(1717, 1), 0);
+        assert_eq!(remi_ui16(1717, 1717), 0);
+        assert_eq!(remi_ui16(17988, 1), 0);
+        assert_eq!(remi_ui16(17988, 2), 0);
+        assert_eq!(remi_ui16(17988, 3), 0);
+        assert_eq!(remi_ui16(17988, 4), 0);
+        assert_eq!(remi_ui16(17988, 17988), 0);
+        assert_eq!(remi_ui16(65096, 1), 0);
+        assert_eq!(remi_ui16(65096, 2), 0);
+        assert_eq!(remi_ui16(65096, 4), 0);
+        assert_eq!(remi_ui16(65096, 65096), 0);
+        assert_eq!(remi_ui16(65534, 1), 0);
+        assert_eq!(remi_ui16(65534, 2), 0);
+        assert_eq!(remi_ui16(65534, 65534), 0);
+        assert_eq!(remi_ui16(65535, 1), 0);
+        assert_eq!(remi_ui16(65535, 3), 0);
+        assert_eq!(remi_ui16(65535, 65535), 0);
+        assert_eq!(remi_ui16(1, 2), 1);
+        assert_eq!(remi_ui16(1, 3), 1);
+        assert_eq!(remi_ui16(1, 4), 1);
+        assert_eq!(remi_ui16(1, 1717), 1);
+        assert_eq!(remi_ui16(1, 17988), 1);
+        assert_eq!(remi_ui16(1, 65096), 1);
+        assert_eq!(remi_ui16(1, 65534), 1);
+        assert_eq!(remi_ui16(1, 65535), 1);
+        assert_eq!(remi_ui16(3, 2), 1);
+        assert_eq!(remi_ui16(4, 3), 1);
+        assert_eq!(remi_ui16(1717, 2), 1);
+        assert_eq!(remi_ui16(1717, 3), 1);
+        assert_eq!(remi_ui16(1717, 4), 1);
+        assert_eq!(remi_ui16(65535, 2), 1);
+        assert_eq!(remi_ui16(65535, 65534), 1);
+        assert_eq!(remi_ui16(2, 3), 2);
+        assert_eq!(remi_ui16(2, 4), 2);
+        assert_eq!(remi_ui16(2, 1717), 2);
+        assert_eq!(remi_ui16(2, 17988), 2);
+        assert_eq!(remi_ui16(2, 65096), 2);
+        assert_eq!(remi_ui16(2, 65534), 2);
+        assert_eq!(remi_ui16(2, 65535), 2);
+        assert_eq!(remi_ui16(65096, 3), 2);
+        assert_eq!(remi_ui16(65534, 3), 2);
+        assert_eq!(remi_ui16(65534, 4), 2);
+        assert_eq!(remi_ui16(3, 4), 3);
+        assert_eq!(remi_ui16(3, 1717), 3);
+        assert_eq!(remi_ui16(3, 17988), 3);
+        assert_eq!(remi_ui16(3, 65096), 3);
+        assert_eq!(remi_ui16(3, 65534), 3);
+        assert_eq!(remi_ui16(3, 65535), 3);
+        assert_eq!(remi_ui16(65535, 4), 3);
+        assert_eq!(remi_ui16(4, 1717), 4);
+        assert_eq!(remi_ui16(4, 17988), 4);
+        assert_eq!(remi_ui16(4, 65096), 4);
+        assert_eq!(remi_ui16(4, 65534), 4);
+        assert_eq!(remi_ui16(4, 65535), 4);
+        assert_eq!(remi_ui16(65534, 1717), 288);
+        assert_eq!(remi_ui16(65535, 1717), 289);
+        assert_eq!(remi_ui16(65534, 65096), 438);
+        assert_eq!(remi_ui16(65535, 65096), 439);
+        assert_eq!(remi_ui16(17988, 1717), 818);
+        assert_eq!(remi_ui16(65096, 1717), 1567);
+        assert_eq!(remi_ui16(1717, 17988), 1717);
+        assert_eq!(remi_ui16(1717, 65096), 1717);
+        assert_eq!(remi_ui16(1717, 65534), 1717);
+        assert_eq!(remi_ui16(1717, 65535), 1717);
+        assert_eq!(remi_ui16(65096, 17988), 11132);
+        assert_eq!(remi_ui16(65534, 17988), 11570);
+        assert_eq!(remi_ui16(65535, 17988), 11571);
+        assert_eq!(remi_ui16(17988, 65096), 17988);
+        assert_eq!(remi_ui16(17988, 65534), 17988);
+        assert_eq!(remi_ui16(17988, 65535), 17988);
+        assert_eq!(remi_ui16(65096, 65534), 65096);
+        assert_eq!(remi_ui16(65096, 65535), 65096);
+        assert_eq!(remi_ui16(65534, 65535), 65534);
+        assert_eq!(remi_ui32(0, 1), 0);
+        assert_eq!(remi_ui32(0, 2), 0);
+        assert_eq!(remi_ui32(0, 3), 0);
+        assert_eq!(remi_ui32(0, 4), 0);
+        assert_eq!(remi_ui32(0, 2119154652), 0);
+        assert_eq!(remi_ui32(0, 3002788344), 0);
+        assert_eq!(remi_ui32(0, 3482297128), 0);
+        assert_eq!(remi_ui32(0, 4294967294), 0);
+        assert_eq!(remi_ui32(0, 4294967295), 0);
+        assert_eq!(remi_ui32(1, 1), 0);
+        assert_eq!(remi_ui32(2, 1), 0);
+        assert_eq!(remi_ui32(2, 2), 0);
+        assert_eq!(remi_ui32(3, 1), 0);
+        assert_eq!(remi_ui32(3, 3), 0);
+        assert_eq!(remi_ui32(4, 1), 0);
+        assert_eq!(remi_ui32(4, 2), 0);
+        assert_eq!(remi_ui32(4, 4), 0);
+        assert_eq!(remi_ui32(2119154652, 1), 0);
+        assert_eq!(remi_ui32(2119154652, 2), 0);
+        assert_eq!(remi_ui32(2119154652, 3), 0);
+        assert_eq!(remi_ui32(2119154652, 4), 0);
+        assert_eq!(remi_ui32(2119154652, 2119154652), 0);
+        assert_eq!(remi_ui32(3002788344, 1), 0);
+        assert_eq!(remi_ui32(3002788344, 2), 0);
+        assert_eq!(remi_ui32(3002788344, 3), 0);
+        assert_eq!(remi_ui32(3002788344, 4), 0);
+        assert_eq!(remi_ui32(3002788344, 3002788344), 0);
+        assert_eq!(remi_ui32(3482297128, 1), 0);
+        assert_eq!(remi_ui32(3482297128, 2), 0);
+        assert_eq!(remi_ui32(3482297128, 4), 0);
+        assert_eq!(remi_ui32(3482297128, 3482297128), 0);
+        assert_eq!(remi_ui32(4294967294, 1), 0);
+        assert_eq!(remi_ui32(4294967294, 2), 0);
+        assert_eq!(remi_ui32(4294967294, 4294967294), 0);
+        assert_eq!(remi_ui32(4294967295, 1), 0);
+        assert_eq!(remi_ui32(4294967295, 3), 0);
+        assert_eq!(remi_ui32(4294967295, 4294967295), 0);
+        assert_eq!(remi_ui32(1, 2), 1);
+        assert_eq!(remi_ui32(1, 3), 1);
+        assert_eq!(remi_ui32(1, 4), 1);
+        assert_eq!(remi_ui32(1, 2119154652), 1);
+        assert_eq!(remi_ui32(1, 3002788344), 1);
+        assert_eq!(remi_ui32(1, 3482297128), 1);
+        assert_eq!(remi_ui32(1, 4294967294), 1);
+        assert_eq!(remi_ui32(1, 4294967295), 1);
+        assert_eq!(remi_ui32(3, 2), 1);
+        assert_eq!(remi_ui32(4, 3), 1);
+        assert_eq!(remi_ui32(3482297128, 3), 1);
+        assert_eq!(remi_ui32(4294967295, 2), 1);
+        assert_eq!(remi_ui32(4294967295, 4294967294), 1);
+        assert_eq!(remi_ui32(2, 3), 2);
+        assert_eq!(remi_ui32(2, 4), 2);
+        assert_eq!(remi_ui32(2, 2119154652), 2);
+        assert_eq!(remi_ui32(2, 3002788344), 2);
+        assert_eq!(remi_ui32(2, 3482297128), 2);
+        assert_eq!(remi_ui32(2, 4294967294), 2);
+        assert_eq!(remi_ui32(2, 4294967295), 2);
+        assert_eq!(remi_ui32(4294967294, 3), 2);
+        assert_eq!(remi_ui32(4294967294, 4), 2);
+        assert_eq!(remi_ui32(3, 4), 3);
+        assert_eq!(remi_ui32(3, 2119154652), 3);
+        assert_eq!(remi_ui32(3, 3002788344), 3);
+        assert_eq!(remi_ui32(3, 3482297128), 3);
+        assert_eq!(remi_ui32(3, 4294967294), 3);
+        assert_eq!(remi_ui32(3, 4294967295), 3);
+        assert_eq!(remi_ui32(4294967295, 4), 3);
+        assert_eq!(remi_ui32(4, 2119154652), 4);
+        assert_eq!(remi_ui32(4, 3002788344), 4);
+        assert_eq!(remi_ui32(4, 3482297128), 4);
+        assert_eq!(remi_ui32(4, 4294967294), 4);
+        assert_eq!(remi_ui32(4, 4294967295), 4);
+        assert_eq!(remi_ui32(4294967294, 2119154652), 56657990);
+        assert_eq!(remi_ui32(4294967295, 2119154652), 56657991);
+        assert_eq!(remi_ui32(3482297128, 3002788344), 479508784);
+        assert_eq!(remi_ui32(4294967294, 3482297128), 812670166);
+        assert_eq!(remi_ui32(4294967295, 3482297128), 812670167);
+        assert_eq!(remi_ui32(3002788344, 2119154652), 883633692);
+        assert_eq!(remi_ui32(4294967294, 3002788344), 1292178950);
+        assert_eq!(remi_ui32(4294967295, 3002788344), 1292178951);
+        assert_eq!(remi_ui32(3482297128, 2119154652), 1363142476);
+        assert_eq!(remi_ui32(2119154652, 3002788344), 2119154652);
+        assert_eq!(remi_ui32(2119154652, 3482297128), 2119154652);
+        assert_eq!(remi_ui32(2119154652, 4294967294), 2119154652);
+        assert_eq!(remi_ui32(2119154652, 4294967295), 2119154652);
+        assert_eq!(remi_ui32(3002788344, 3482297128), 3002788344);
+        assert_eq!(remi_ui32(3002788344, 4294967294), 3002788344);
+        assert_eq!(remi_ui32(3002788344, 4294967295), 3002788344);
+        assert_eq!(remi_ui32(3482297128, 4294967294), 3482297128);
+        assert_eq!(remi_ui32(3482297128, 4294967295), 3482297128);
+        assert_eq!(remi_ui32(4294967294, 4294967295), 4294967294);
+        assert_eq!(remi_ui64(0, 1), 0);
+        assert_eq!(remi_ui64(0, 2), 0);
+        assert_eq!(remi_ui64(0, 3), 0);
+        assert_eq!(remi_ui64(0, 4), 0);
+        assert_eq!(remi_ui64(0, 191084152064409600), 0);
+        assert_eq!(remi_ui64(0, 11015955194427482112), 0);
+        assert_eq!(remi_ui64(0, 16990600415051759616), 0);
+        assert_eq!(remi_ui64(0, 18446744073709551614), 0);
+        assert_eq!(remi_ui64(0, 18446744073709551615), 0);
+        assert_eq!(remi_ui64(1, 1), 0);
+        assert_eq!(remi_ui64(2, 1), 0);
+        assert_eq!(remi_ui64(2, 2), 0);
+        assert_eq!(remi_ui64(3, 1), 0);
+        assert_eq!(remi_ui64(3, 3), 0);
+        assert_eq!(remi_ui64(4, 1), 0);
+        assert_eq!(remi_ui64(4, 2), 0);
+        assert_eq!(remi_ui64(4, 4), 0);
+        assert_eq!(remi_ui64(191084152064409600, 1), 0);
+        assert_eq!(remi_ui64(191084152064409600, 2), 0);
+        assert_eq!(remi_ui64(191084152064409600, 3), 0);
+        assert_eq!(remi_ui64(191084152064409600, 4), 0);
+        assert_eq!(remi_ui64(191084152064409600, 191084152064409600), 0);
+        assert_eq!(remi_ui64(11015955194427482112, 1), 0);
+        assert_eq!(remi_ui64(11015955194427482112, 2), 0);
+        assert_eq!(remi_ui64(11015955194427482112, 3), 0);
+        assert_eq!(remi_ui64(11015955194427482112, 4), 0);
+        assert_eq!(remi_ui64(11015955194427482112, 11015955194427482112), 0);
+        assert_eq!(remi_ui64(16990600415051759616, 1), 0);
+        assert_eq!(remi_ui64(16990600415051759616, 2), 0);
+        assert_eq!(remi_ui64(16990600415051759616, 3), 0);
+        assert_eq!(remi_ui64(16990600415051759616, 4), 0);
+        assert_eq!(remi_ui64(16990600415051759616, 16990600415051759616), 0);
+        assert_eq!(remi_ui64(18446744073709551614, 1), 0);
+        assert_eq!(remi_ui64(18446744073709551614, 2), 0);
+        assert_eq!(remi_ui64(18446744073709551614, 18446744073709551614), 0);
+        assert_eq!(remi_ui64(18446744073709551615, 1), 0);
+        assert_eq!(remi_ui64(18446744073709551615, 3), 0);
+        assert_eq!(remi_ui64(18446744073709551615, 18446744073709551615), 0);
+        assert_eq!(remi_ui64(1, 2), 1);
+        assert_eq!(remi_ui64(1, 3), 1);
+        assert_eq!(remi_ui64(1, 4), 1);
+        assert_eq!(remi_ui64(1, 191084152064409600), 1);
+        assert_eq!(remi_ui64(1, 11015955194427482112), 1);
+        assert_eq!(remi_ui64(1, 16990600415051759616), 1);
+        assert_eq!(remi_ui64(1, 18446744073709551614), 1);
+        assert_eq!(remi_ui64(1, 18446744073709551615), 1);
+        assert_eq!(remi_ui64(3, 2), 1);
+        assert_eq!(remi_ui64(4, 3), 1);
+        assert_eq!(remi_ui64(18446744073709551615, 2), 1);
+        assert_eq!(remi_ui64(18446744073709551615, 18446744073709551614), 1);
+        assert_eq!(remi_ui64(2, 3), 2);
+        assert_eq!(remi_ui64(2, 4), 2);
+        assert_eq!(remi_ui64(2, 191084152064409600), 2);
+        assert_eq!(remi_ui64(2, 11015955194427482112), 2);
+        assert_eq!(remi_ui64(2, 16990600415051759616), 2);
+        assert_eq!(remi_ui64(2, 18446744073709551614), 2);
+        assert_eq!(remi_ui64(2, 18446744073709551615), 2);
+        assert_eq!(remi_ui64(18446744073709551614, 3), 2);
+        assert_eq!(remi_ui64(18446744073709551614, 4), 2);
+        assert_eq!(remi_ui64(3, 4), 3);
+        assert_eq!(remi_ui64(3, 191084152064409600), 3);
+        assert_eq!(remi_ui64(3, 11015955194427482112), 3);
+        assert_eq!(remi_ui64(3, 16990600415051759616), 3);
+        assert_eq!(remi_ui64(3, 18446744073709551614), 3);
+        assert_eq!(remi_ui64(3, 18446744073709551615), 3);
+        assert_eq!(remi_ui64(18446744073709551615, 4), 3);
+        assert_eq!(remi_ui64(4, 191084152064409600), 4);
+        assert_eq!(remi_ui64(4, 11015955194427482112), 4);
+        assert_eq!(remi_ui64(4, 16990600415051759616), 4);
+        assert_eq!(remi_ui64(4, 18446744073709551614), 4);
+        assert_eq!(remi_ui64(4, 18446744073709551615), 4);
+        assert_eq!(
+            remi_ui64(18446744073709551614, 191084152064409600),
+            102665475526230014
+        );
+        assert_eq!(
+            remi_ui64(18446744073709551615, 191084152064409600),
+            102665475526230015
+        );
+        assert_eq!(
+            remi_ui64(11015955194427482112, 191084152064409600),
+            124158526756134912
+        );
+        assert_eq!(
+            remi_ui64(16990600415051759616, 191084152064409600),
+            175195033383714816
+        );
+        assert_eq!(
+            remi_ui64(191084152064409600, 11015955194427482112),
+            191084152064409600
+        );
+        assert_eq!(
+            remi_ui64(191084152064409600, 16990600415051759616),
+            191084152064409600
+        );
+        assert_eq!(
+            remi_ui64(191084152064409600, 18446744073709551614),
+            191084152064409600
+        );
+        assert_eq!(
+            remi_ui64(191084152064409600, 18446744073709551615),
+            191084152064409600
+        );
+        assert_eq!(
+            remi_ui64(18446744073709551614, 16990600415051759616),
+            1456143658657791998
+        );
+        assert_eq!(
+            remi_ui64(18446744073709551615, 16990600415051759616),
+            1456143658657791999
+        );
+        assert_eq!(
+            remi_ui64(16990600415051759616, 11015955194427482112),
+            5974645220624277504
+        );
+        assert_eq!(
+            remi_ui64(18446744073709551614, 11015955194427482112),
+            7430788879282069502
+        );
+        assert_eq!(
+            remi_ui64(18446744073709551615, 11015955194427482112),
+            7430788879282069503
+        );
+        assert_eq!(
+            remi_ui64(11015955194427482112, 16990600415051759616),
+            11015955194427482112
+        );
+        assert_eq!(
+            remi_ui64(11015955194427482112, 18446744073709551614),
+            11015955194427482112
+        );
+        assert_eq!(
+            remi_ui64(11015955194427482112, 18446744073709551615),
+            11015955194427482112
+        );
+        assert_eq!(
+            remi_ui64(16990600415051759616, 18446744073709551614),
+            16990600415051759616
+        );
+        assert_eq!(
+            remi_ui64(16990600415051759616, 18446744073709551615),
+            16990600415051759616
+        );
+        assert_eq!(
+            remi_ui64(18446744073709551614, 18446744073709551615),
+            18446744073709551614
+        );
+        assert_eq!(remi_ui8(0, 1), 0);
+        assert_eq!(remi_ui8(0, 2), 0);
+        assert_eq!(remi_ui8(0, 3), 0);
+        assert_eq!(remi_ui8(0, 4), 0);
+        assert_eq!(remi_ui8(0, 72), 0);
+        assert_eq!(remi_ui8(0, 100), 0);
+        assert_eq!(remi_ui8(0, 162), 0);
+        assert_eq!(remi_ui8(0, 254), 0);
+        assert_eq!(remi_ui8(0, 255), 0);
+        assert_eq!(remi_ui8(1, 1), 0);
+        assert_eq!(remi_ui8(2, 1), 0);
+        assert_eq!(remi_ui8(2, 2), 0);
+        assert_eq!(remi_ui8(3, 1), 0);
+        assert_eq!(remi_ui8(3, 3), 0);
+        assert_eq!(remi_ui8(4, 1), 0);
+        assert_eq!(remi_ui8(4, 2), 0);
+        assert_eq!(remi_ui8(4, 4), 0);
+        assert_eq!(remi_ui8(72, 1), 0);
+        assert_eq!(remi_ui8(72, 2), 0);
+        assert_eq!(remi_ui8(72, 3), 0);
+        assert_eq!(remi_ui8(72, 4), 0);
+        assert_eq!(remi_ui8(72, 72), 0);
+        assert_eq!(remi_ui8(100, 1), 0);
+        assert_eq!(remi_ui8(100, 2), 0);
+        assert_eq!(remi_ui8(100, 4), 0);
+        assert_eq!(remi_ui8(100, 100), 0);
+        assert_eq!(remi_ui8(162, 1), 0);
+        assert_eq!(remi_ui8(162, 2), 0);
+        assert_eq!(remi_ui8(162, 3), 0);
+        assert_eq!(remi_ui8(162, 162), 0);
+        assert_eq!(remi_ui8(254, 1), 0);
+        assert_eq!(remi_ui8(254, 2), 0);
+        assert_eq!(remi_ui8(254, 254), 0);
+        assert_eq!(remi_ui8(255, 1), 0);
+        assert_eq!(remi_ui8(255, 3), 0);
+        assert_eq!(remi_ui8(255, 255), 0);
+        assert_eq!(remi_ui8(1, 2), 1);
+        assert_eq!(remi_ui8(1, 3), 1);
+        assert_eq!(remi_ui8(1, 4), 1);
+        assert_eq!(remi_ui8(1, 72), 1);
+        assert_eq!(remi_ui8(1, 100), 1);
+        assert_eq!(remi_ui8(1, 162), 1);
+        assert_eq!(remi_ui8(1, 254), 1);
+        assert_eq!(remi_ui8(1, 255), 1);
+        assert_eq!(remi_ui8(3, 2), 1);
+        assert_eq!(remi_ui8(4, 3), 1);
+        assert_eq!(remi_ui8(100, 3), 1);
+        assert_eq!(remi_ui8(255, 2), 1);
+        assert_eq!(remi_ui8(255, 254), 1);
+        assert_eq!(remi_ui8(2, 3), 2);
+        assert_eq!(remi_ui8(2, 4), 2);
+        assert_eq!(remi_ui8(2, 72), 2);
+        assert_eq!(remi_ui8(2, 100), 2);
+        assert_eq!(remi_ui8(2, 162), 2);
+        assert_eq!(remi_ui8(2, 254), 2);
+        assert_eq!(remi_ui8(2, 255), 2);
+        assert_eq!(remi_ui8(162, 4), 2);
+        assert_eq!(remi_ui8(254, 3), 2);
+        assert_eq!(remi_ui8(254, 4), 2);
+        assert_eq!(remi_ui8(3, 4), 3);
+        assert_eq!(remi_ui8(3, 72), 3);
+        assert_eq!(remi_ui8(3, 100), 3);
+        assert_eq!(remi_ui8(3, 162), 3);
+        assert_eq!(remi_ui8(3, 254), 3);
+        assert_eq!(remi_ui8(3, 255), 3);
+        assert_eq!(remi_ui8(255, 4), 3);
+        assert_eq!(remi_ui8(4, 72), 4);
+        assert_eq!(remi_ui8(4, 100), 4);
+        assert_eq!(remi_ui8(4, 162), 4);
+        assert_eq!(remi_ui8(4, 254), 4);
+        assert_eq!(remi_ui8(4, 255), 4);
+        assert_eq!(remi_ui8(162, 72), 18);
+        assert_eq!(remi_ui8(100, 72), 28);
+        assert_eq!(remi_ui8(254, 72), 38);
+        assert_eq!(remi_ui8(255, 72), 39);
+        assert_eq!(remi_ui8(254, 100), 54);
+        assert_eq!(remi_ui8(255, 100), 55);
+        assert_eq!(remi_ui8(162, 100), 62);
+        assert_eq!(remi_ui8(72, 100), 72);
+        assert_eq!(remi_ui8(72, 162), 72);
+        assert_eq!(remi_ui8(72, 254), 72);
+        assert_eq!(remi_ui8(72, 255), 72);
+        assert_eq!(remi_ui8(254, 162), 92);
+        assert_eq!(remi_ui8(255, 162), 93);
+        assert_eq!(remi_ui8(100, 162), 100);
+        assert_eq!(remi_ui8(100, 254), 100);
+        assert_eq!(remi_ui8(100, 255), 100);
+        assert_eq!(remi_ui8(162, 254), 162);
+        assert_eq!(remi_ui8(162, 255), 162);
+        assert_eq!(remi_ui8(254, 255), 254);
+        assert_eq!(subi_si16(-32768, 0), -32768);
+        assert_eq!(subi_si16(-32767, 1), -32768);
+        assert_eq!(subi_si16(-32767, 0), -32767);
+        assert_eq!(subi_si16(0, 32767), -32767);
+        assert_eq!(subi_si16(0, 32766), -32766);
+        assert_eq!(subi_si16(1, 32767), -32766);
+        assert_eq!(subi_si16(1, 32766), -32765);
+        assert_eq!(subi_si16(2, 32767), -32765);
+        assert_eq!(subi_si16(2, 32766), -32764);
+        assert_eq!(subi_si16(3, 32767), -32764);
+        assert_eq!(subi_si16(3, 32766), -32763);
+        assert_eq!(subi_si16(4, 32767), -32763);
+        assert_eq!(subi_si16(4, 32766), -32762);
+        assert_eq!(subi_si16(-32547, 4), -32551);
+        assert_eq!(subi_si16(-32547, 3), -32550);
+        assert_eq!(subi_si16(-32547, 2), -32549);
+        assert_eq!(subi_si16(-32547, 1), -32548);
+        assert_eq!(subi_si16(-32547, 0), -32547);
+        assert_eq!(subi_si16(10486, 32767), -22281);
+        assert_eq!(subi_si16(10486, 32766), -22280);
+        assert_eq!(subi_si16(0, 16514), -16514);
+        assert_eq!(subi_si16(1, 16514), -16513);
+        assert_eq!(subi_si16(2, 16514), -16512);
+        assert_eq!(subi_si16(3, 16514), -16511);
+        assert_eq!(subi_si16(4, 16514), -16510);
+        assert_eq!(subi_si16(16514, 32767), -16253);
+        assert_eq!(subi_si16(16514, 32766), -16252);
+        assert_eq!(subi_si16(0, 10486), -10486);
+        assert_eq!(subi_si16(1, 10486), -10485);
+        assert_eq!(subi_si16(2, 10486), -10484);
+        assert_eq!(subi_si16(3, 10486), -10483);
+        assert_eq!(subi_si16(4, 10486), -10482);
+        assert_eq!(subi_si16(10486, 16514), -6028);
+        assert_eq!(subi_si16(-32768, -32547), -221);
+        assert_eq!(subi_si16(-32767, -32547), -220);
+        assert_eq!(subi_si16(0, 4), -4);
+        assert_eq!(subi_si16(0, 3), -3);
+        assert_eq!(subi_si16(1, 4), -3);
+        assert_eq!(subi_si16(0, 2), -2);
+        assert_eq!(subi_si16(1, 3), -2);
+        assert_eq!(subi_si16(2, 4), -2);
+        assert_eq!(subi_si16(-32768, -32767), -1);
+        assert_eq!(subi_si16(0, 1), -1);
+        assert_eq!(subi_si16(1, 2), -1);
+        assert_eq!(subi_si16(2, 3), -1);
+        assert_eq!(subi_si16(3, 4), -1);
+        assert_eq!(subi_si16(32766, 32767), -1);
+        assert_eq!(subi_si16(-32768, -32768), 0);
+        assert_eq!(subi_si16(-32767, -32767), 0);
+        assert_eq!(subi_si16(-32547, -32547), 0);
+        assert_eq!(subi_si16(0, 0), 0);
+        assert_eq!(subi_si16(1, 1), 0);
+        assert_eq!(subi_si16(2, 2), 0);
+        assert_eq!(subi_si16(3, 3), 0);
+        assert_eq!(subi_si16(4, 4), 0);
+        assert_eq!(subi_si16(10486, 10486), 0);
+        assert_eq!(subi_si16(16514, 16514), 0);
+        assert_eq!(subi_si16(32766, 32766), 0);
+        assert_eq!(subi_si16(32767, 32767), 0);
+        assert_eq!(subi_si16(-32767, -32768), 1);
+        assert_eq!(subi_si16(1, 0), 1);
+        assert_eq!(subi_si16(2, 1), 1);
+        assert_eq!(subi_si16(3, 2), 1);
+        assert_eq!(subi_si16(4, 3), 1);
+        assert_eq!(subi_si16(32767, 32766), 1);
+        assert_eq!(subi_si16(2, 0), 2);
+        assert_eq!(subi_si16(3, 1), 2);
+        assert_eq!(subi_si16(4, 2), 2);
+        assert_eq!(subi_si16(3, 0), 3);
+        assert_eq!(subi_si16(4, 1), 3);
+        assert_eq!(subi_si16(4, 0), 4);
+        assert_eq!(subi_si16(-32547, -32767), 220);
+        assert_eq!(subi_si16(-32547, -32768), 221);
+        assert_eq!(subi_si16(16514, 10486), 6028);
+        assert_eq!(subi_si16(10486, 4), 10482);
+        assert_eq!(subi_si16(10486, 3), 10483);
+        assert_eq!(subi_si16(10486, 2), 10484);
+        assert_eq!(subi_si16(10486, 1), 10485);
+        assert_eq!(subi_si16(10486, 0), 10486);
+        assert_eq!(subi_si16(32766, 16514), 16252);
+        assert_eq!(subi_si16(32767, 16514), 16253);
+        assert_eq!(subi_si16(16514, 4), 16510);
+        assert_eq!(subi_si16(16514, 3), 16511);
+        assert_eq!(subi_si16(16514, 2), 16512);
+        assert_eq!(subi_si16(16514, 1), 16513);
+        assert_eq!(subi_si16(16514, 0), 16514);
+        assert_eq!(subi_si16(32766, 10486), 22280);
+        assert_eq!(subi_si16(32767, 10486), 22281);
+        assert_eq!(subi_si16(0, -32547), 32547);
+        assert_eq!(subi_si16(1, -32547), 32548);
+        assert_eq!(subi_si16(2, -32547), 32549);
+        assert_eq!(subi_si16(3, -32547), 32550);
+        assert_eq!(subi_si16(4, -32547), 32551);
+        assert_eq!(subi_si16(32766, 4), 32762);
+        assert_eq!(subi_si16(32766, 3), 32763);
+        assert_eq!(subi_si16(32767, 4), 32763);
+        assert_eq!(subi_si16(32766, 2), 32764);
+        assert_eq!(subi_si16(32767, 3), 32764);
+        assert_eq!(subi_si16(32766, 1), 32765);
+        assert_eq!(subi_si16(32767, 2), 32765);
+        assert_eq!(subi_si16(32766, 0), 32766);
+        assert_eq!(subi_si16(32767, 1), 32766);
+        assert_eq!(subi_si16(0, -32767), 32767);
+        assert_eq!(subi_si16(32767, 0), 32767);
+        assert_eq!(subi_si32(-2147483648, 0), -2147483648);
+        assert_eq!(subi_si32(-2147483647, 1), -2147483648);
+        assert_eq!(subi_si32(-2147483647, 0), -2147483647);
+        assert_eq!(subi_si32(0, 2147483647), -2147483647);
+        assert_eq!(subi_si32(0, 2147483646), -2147483646);
+        assert_eq!(subi_si32(1, 2147483647), -2147483646);
+        assert_eq!(subi_si32(1, 2147483646), -2147483645);
+        assert_eq!(subi_si32(2, 2147483647), -2147483645);
+        assert_eq!(subi_si32(2, 2147483646), -2147483644);
+        assert_eq!(subi_si32(3, 2147483647), -2147483644);
+        assert_eq!(subi_si32(3, 2147483646), -2147483643);
+        assert_eq!(subi_si32(4, 2147483647), -2147483643);
+        assert_eq!(subi_si32(4, 2147483646), -2147483642);
+        assert_eq!(subi_si32(-1713183800, 4), -1713183804);
+        assert_eq!(subi_si32(-1713183800, 3), -1713183803);
+        assert_eq!(subi_si32(-1713183800, 2), -1713183802);
+        assert_eq!(subi_si32(-1713183800, 1), -1713183801);
+        assert_eq!(subi_si32(-1713183800, 0), -1713183800);
+        assert_eq!(subi_si32(-1252582164, 4), -1252582168);
+        assert_eq!(subi_si32(-1252582164, 3), -1252582167);
+        assert_eq!(subi_si32(-1252582164, 2), -1252582166);
+        assert_eq!(subi_si32(-1252582164, 1), -1252582165);
+        assert_eq!(subi_si32(-1252582164, 0), -1252582164);
+        assert_eq!(subi_si32(-2147483648, -1035405763), -1112077885);
+        assert_eq!(subi_si32(-2147483647, -1035405763), -1112077884);
+        assert_eq!(subi_si32(-1035405763, 4), -1035405767);
+        assert_eq!(subi_si32(-1035405763, 3), -1035405766);
+        assert_eq!(subi_si32(-1035405763, 2), -1035405765);
+        assert_eq!(subi_si32(-1035405763, 1), -1035405764);
+        assert_eq!(subi_si32(-1035405763, 0), -1035405763);
+        assert_eq!(subi_si32(-2147483648, -1252582164), -894901484);
+        assert_eq!(subi_si32(-2147483647, -1252582164), -894901483);
+        assert_eq!(subi_si32(-1713183800, -1035405763), -677778037);
+        assert_eq!(subi_si32(-1713183800, -1252582164), -460601636);
+        assert_eq!(subi_si32(-2147483648, -1713183800), -434299848);
+        assert_eq!(subi_si32(-2147483647, -1713183800), -434299847);
+        assert_eq!(subi_si32(-1252582164, -1035405763), -217176401);
+        assert_eq!(subi_si32(0, 4), -4);
+        assert_eq!(subi_si32(0, 3), -3);
+        assert_eq!(subi_si32(1, 4), -3);
+        assert_eq!(subi_si32(0, 2), -2);
+        assert_eq!(subi_si32(1, 3), -2);
+        assert_eq!(subi_si32(2, 4), -2);
+        assert_eq!(subi_si32(-2147483648, -2147483647), -1);
+        assert_eq!(subi_si32(0, 1), -1);
+        assert_eq!(subi_si32(1, 2), -1);
+        assert_eq!(subi_si32(2, 3), -1);
+        assert_eq!(subi_si32(3, 4), -1);
+        assert_eq!(subi_si32(2147483646, 2147483647), -1);
+        assert_eq!(subi_si32(-2147483648, -2147483648), 0);
+        assert_eq!(subi_si32(-2147483647, -2147483647), 0);
+        assert_eq!(subi_si32(-1713183800, -1713183800), 0);
+        assert_eq!(subi_si32(-1252582164, -1252582164), 0);
+        assert_eq!(subi_si32(-1035405763, -1035405763), 0);
+        assert_eq!(subi_si32(0, 0), 0);
+        assert_eq!(subi_si32(1, 1), 0);
+        assert_eq!(subi_si32(2, 2), 0);
+        assert_eq!(subi_si32(3, 3), 0);
+        assert_eq!(subi_si32(4, 4), 0);
+        assert_eq!(subi_si32(2147483646, 2147483646), 0);
+        assert_eq!(subi_si32(2147483647, 2147483647), 0);
+        assert_eq!(subi_si32(-2147483647, -2147483648), 1);
+        assert_eq!(subi_si32(1, 0), 1);
+        assert_eq!(subi_si32(2, 1), 1);
+        assert_eq!(subi_si32(3, 2), 1);
+        assert_eq!(subi_si32(4, 3), 1);
+        assert_eq!(subi_si32(2147483647, 2147483646), 1);
+        assert_eq!(subi_si32(2, 0), 2);
+        assert_eq!(subi_si32(3, 1), 2);
+        assert_eq!(subi_si32(4, 2), 2);
+        assert_eq!(subi_si32(3, 0), 3);
+        assert_eq!(subi_si32(4, 1), 3);
+        assert_eq!(subi_si32(4, 0), 4);
+        assert_eq!(subi_si32(-1035405763, -1252582164), 217176401);
+        assert_eq!(subi_si32(-1713183800, -2147483647), 434299847);
+        assert_eq!(subi_si32(-1713183800, -2147483648), 434299848);
+        assert_eq!(subi_si32(-1252582164, -1713183800), 460601636);
+        assert_eq!(subi_si32(-1035405763, -1713183800), 677778037);
+        assert_eq!(subi_si32(-1252582164, -2147483647), 894901483);
+        assert_eq!(subi_si32(-1252582164, -2147483648), 894901484);
+        assert_eq!(subi_si32(0, -1035405763), 1035405763);
+        assert_eq!(subi_si32(1, -1035405763), 1035405764);
+        assert_eq!(subi_si32(2, -1035405763), 1035405765);
+        assert_eq!(subi_si32(3, -1035405763), 1035405766);
+        assert_eq!(subi_si32(4, -1035405763), 1035405767);
+        assert_eq!(subi_si32(-1035405763, -2147483647), 1112077884);
+        assert_eq!(subi_si32(-1035405763, -2147483648), 1112077885);
+        assert_eq!(subi_si32(0, -1252582164), 1252582164);
+        assert_eq!(subi_si32(1, -1252582164), 1252582165);
+        assert_eq!(subi_si32(2, -1252582164), 1252582166);
+        assert_eq!(subi_si32(3, -1252582164), 1252582167);
+        assert_eq!(subi_si32(4, -1252582164), 1252582168);
+        assert_eq!(subi_si32(0, -1713183800), 1713183800);
+        assert_eq!(subi_si32(1, -1713183800), 1713183801);
+        assert_eq!(subi_si32(2, -1713183800), 1713183802);
+        assert_eq!(subi_si32(3, -1713183800), 1713183803);
+        assert_eq!(subi_si32(4, -1713183800), 1713183804);
+        assert_eq!(subi_si32(2147483646, 4), 2147483642);
+        assert_eq!(subi_si32(2147483646, 3), 2147483643);
+        assert_eq!(subi_si32(2147483647, 4), 2147483643);
+        assert_eq!(subi_si32(2147483646, 2), 2147483644);
+        assert_eq!(subi_si32(2147483647, 3), 2147483644);
+        assert_eq!(subi_si32(2147483646, 1), 2147483645);
+        assert_eq!(subi_si32(2147483647, 2), 2147483645);
+        assert_eq!(subi_si32(2147483646, 0), 2147483646);
+        assert_eq!(subi_si32(2147483647, 1), 2147483646);
+        assert_eq!(subi_si32(0, -2147483647), 2147483647);
+        assert_eq!(subi_si32(2147483647, 0), 2147483647);
+        assert_eq!(subi_si64(-9223372036854775808, 0), -9223372036854775808);
+        assert_eq!(subi_si64(-9223372036854775807, 1), -9223372036854775808);
+        assert_eq!(subi_si64(-9223372036854775807, 0), -9223372036854775807);
+        assert_eq!(subi_si64(0, 9223372036854775807), -9223372036854775807);
+        assert_eq!(subi_si64(0, 9223372036854775806), -9223372036854775806);
+        assert_eq!(subi_si64(1, 9223372036854775807), -9223372036854775806);
+        assert_eq!(subi_si64(1, 9223372036854775806), -9223372036854775805);
+        assert_eq!(subi_si64(2, 9223372036854775807), -9223372036854775805);
+        assert_eq!(subi_si64(2, 9223372036854775806), -9223372036854775804);
+        assert_eq!(subi_si64(3, 9223372036854775807), -9223372036854775804);
+        assert_eq!(subi_si64(3, 9223372036854775806), -9223372036854775803);
+        assert_eq!(subi_si64(4, 9223372036854775807), -9223372036854775803);
+        assert_eq!(subi_si64(4, 9223372036854775806), -9223372036854775802);
+        assert_eq!(
+            subi_si64(-9223372036854775808, -1328271339354574848),
+            -7895100697500200960
+        );
+        assert_eq!(
+            subi_si64(-9223372036854775807, -1328271339354574848),
+            -7895100697500200959
+        );
+        assert_eq!(
+            subi_si64(-9223372036854775808, -1741927215160008704),
+            -7481444821694767104
+        );
+        assert_eq!(
+            subi_si64(-9223372036854775807, -1741927215160008704),
+            -7481444821694767103
+        );
+        assert_eq!(
+            subi_si64(-1741927215160008704, 5577148965131116544),
+            -7319076180291125248
+        );
+        assert_eq!(
+            subi_si64(-1328271339354574848, 5577148965131116544),
+            -6905420304485691392
+        );
+        assert_eq!(subi_si64(0, 5577148965131116544), -5577148965131116544);
+        assert_eq!(subi_si64(1, 5577148965131116544), -5577148965131116543);
+        assert_eq!(subi_si64(2, 5577148965131116544), -5577148965131116542);
+        assert_eq!(subi_si64(3, 5577148965131116544), -5577148965131116541);
+        assert_eq!(subi_si64(4, 5577148965131116544), -5577148965131116540);
+        assert_eq!(
+            subi_si64(5577148965131116544, 9223372036854775807),
+            -3646223071723659263
+        );
+        assert_eq!(
+            subi_si64(5577148965131116544, 9223372036854775806),
+            -3646223071723659262
+        );
+        assert_eq!(subi_si64(-1741927215160008704, 4), -1741927215160008708);
+        assert_eq!(subi_si64(-1741927215160008704, 3), -1741927215160008707);
+        assert_eq!(subi_si64(-1741927215160008704, 2), -1741927215160008706);
+        assert_eq!(subi_si64(-1741927215160008704, 1), -1741927215160008705);
+        assert_eq!(subi_si64(-1741927215160008704, 0), -1741927215160008704);
+        assert_eq!(subi_si64(-1328271339354574848, 4), -1328271339354574852);
+        assert_eq!(subi_si64(-1328271339354574848, 3), -1328271339354574851);
+        assert_eq!(subi_si64(-1328271339354574848, 2), -1328271339354574850);
+        assert_eq!(subi_si64(-1328271339354574848, 1), -1328271339354574849);
+        assert_eq!(subi_si64(-1328271339354574848, 0), -1328271339354574848);
+        assert_eq!(
+            subi_si64(-1741927215160008704, -1328271339354574848),
+            -413655875805433856
+        );
+        assert_eq!(subi_si64(0, 4), -4);
+        assert_eq!(subi_si64(0, 3), -3);
+        assert_eq!(subi_si64(1, 4), -3);
+        assert_eq!(subi_si64(0, 2), -2);
+        assert_eq!(subi_si64(1, 3), -2);
+        assert_eq!(subi_si64(2, 4), -2);
+        assert_eq!(subi_si64(-9223372036854775808, -9223372036854775807), -1);
+        assert_eq!(subi_si64(0, 1), -1);
+        assert_eq!(subi_si64(1, 2), -1);
+        assert_eq!(subi_si64(2, 3), -1);
+        assert_eq!(subi_si64(3, 4), -1);
+        assert_eq!(subi_si64(9223372036854775806, 9223372036854775807), -1);
+        assert_eq!(subi_si64(-9223372036854775808, -9223372036854775808), 0);
+        assert_eq!(subi_si64(-9223372036854775807, -9223372036854775807), 0);
+        assert_eq!(subi_si64(-1741927215160008704, -1741927215160008704), 0);
+        assert_eq!(subi_si64(-1328271339354574848, -1328271339354574848), 0);
+        assert_eq!(subi_si64(0, 0), 0);
+        assert_eq!(subi_si64(1, 1), 0);
+        assert_eq!(subi_si64(2, 2), 0);
+        assert_eq!(subi_si64(3, 3), 0);
+        assert_eq!(subi_si64(4, 4), 0);
+        assert_eq!(subi_si64(5577148965131116544, 5577148965131116544), 0);
+        assert_eq!(subi_si64(9223372036854775806, 9223372036854775806), 0);
+        assert_eq!(subi_si64(9223372036854775807, 9223372036854775807), 0);
+        assert_eq!(subi_si64(-9223372036854775807, -9223372036854775808), 1);
+        assert_eq!(subi_si64(1, 0), 1);
+        assert_eq!(subi_si64(2, 1), 1);
+        assert_eq!(subi_si64(3, 2), 1);
+        assert_eq!(subi_si64(4, 3), 1);
+        assert_eq!(subi_si64(9223372036854775807, 9223372036854775806), 1);
+        assert_eq!(subi_si64(2, 0), 2);
+        assert_eq!(subi_si64(3, 1), 2);
+        assert_eq!(subi_si64(4, 2), 2);
+        assert_eq!(subi_si64(3, 0), 3);
+        assert_eq!(subi_si64(4, 1), 3);
+        assert_eq!(subi_si64(4, 0), 4);
+        assert_eq!(
+            subi_si64(-1328271339354574848, -1741927215160008704),
+            413655875805433856
+        );
+        assert_eq!(subi_si64(0, -1328271339354574848), 1328271339354574848);
+        assert_eq!(subi_si64(1, -1328271339354574848), 1328271339354574849);
+        assert_eq!(subi_si64(2, -1328271339354574848), 1328271339354574850);
+        assert_eq!(subi_si64(3, -1328271339354574848), 1328271339354574851);
+        assert_eq!(subi_si64(4, -1328271339354574848), 1328271339354574852);
+        assert_eq!(subi_si64(0, -1741927215160008704), 1741927215160008704);
+        assert_eq!(subi_si64(1, -1741927215160008704), 1741927215160008705);
+        assert_eq!(subi_si64(2, -1741927215160008704), 1741927215160008706);
+        assert_eq!(subi_si64(3, -1741927215160008704), 1741927215160008707);
+        assert_eq!(subi_si64(4, -1741927215160008704), 1741927215160008708);
+        assert_eq!(
+            subi_si64(9223372036854775806, 5577148965131116544),
+            3646223071723659262
+        );
+        assert_eq!(
+            subi_si64(9223372036854775807, 5577148965131116544),
+            3646223071723659263
+        );
+        assert_eq!(subi_si64(5577148965131116544, 4), 5577148965131116540);
+        assert_eq!(subi_si64(5577148965131116544, 3), 5577148965131116541);
+        assert_eq!(subi_si64(5577148965131116544, 2), 5577148965131116542);
+        assert_eq!(subi_si64(5577148965131116544, 1), 5577148965131116543);
+        assert_eq!(subi_si64(5577148965131116544, 0), 5577148965131116544);
+        assert_eq!(
+            subi_si64(5577148965131116544, -1328271339354574848),
+            6905420304485691392
+        );
+        assert_eq!(
+            subi_si64(5577148965131116544, -1741927215160008704),
+            7319076180291125248
+        );
+        assert_eq!(
+            subi_si64(-1741927215160008704, -9223372036854775807),
+            7481444821694767103
+        );
+        assert_eq!(
+            subi_si64(-1741927215160008704, -9223372036854775808),
+            7481444821694767104
+        );
+        assert_eq!(
+            subi_si64(-1328271339354574848, -9223372036854775807),
+            7895100697500200959
+        );
+        assert_eq!(
+            subi_si64(-1328271339354574848, -9223372036854775808),
+            7895100697500200960
+        );
+        assert_eq!(subi_si64(9223372036854775806, 4), 9223372036854775802);
+        assert_eq!(subi_si64(9223372036854775806, 3), 9223372036854775803);
+        assert_eq!(subi_si64(9223372036854775807, 4), 9223372036854775803);
+        assert_eq!(subi_si64(9223372036854775806, 2), 9223372036854775804);
+        assert_eq!(subi_si64(9223372036854775807, 3), 9223372036854775804);
+        assert_eq!(subi_si64(9223372036854775806, 1), 9223372036854775805);
+        assert_eq!(subi_si64(9223372036854775807, 2), 9223372036854775805);
+        assert_eq!(subi_si64(9223372036854775806, 0), 9223372036854775806);
+        assert_eq!(subi_si64(9223372036854775807, 1), 9223372036854775806);
+        assert_eq!(subi_si64(0, -9223372036854775807), 9223372036854775807);
+        assert_eq!(subi_si64(9223372036854775807, 0), 9223372036854775807);
+        assert_eq!(subi_si8(-128, 0), -128);
+        assert_eq!(subi_si8(-127, 1), -128);
+        assert_eq!(subi_si8(-127, 0), -127);
+        assert_eq!(subi_si8(0, 127), -127);
+        assert_eq!(subi_si8(0, 126), -126);
+        assert_eq!(subi_si8(1, 127), -126);
+        assert_eq!(subi_si8(1, 126), -125);
+        assert_eq!(subi_si8(2, 127), -125);
+        assert_eq!(subi_si8(2, 126), -124);
+        assert_eq!(subi_si8(3, 127), -124);
+        assert_eq!(subi_si8(3, 126), -123);
+        assert_eq!(subi_si8(4, 127), -123);
+        assert_eq!(subi_si8(4, 126), -122);
+        assert_eq!(subi_si8(16, 127), -111);
+        assert_eq!(subi_si8(16, 126), -110);
+        assert_eq!(subi_si8(0, 16), -16);
+        assert_eq!(subi_si8(1, 16), -15);
+        assert_eq!(subi_si8(2, 16), -14);
+        assert_eq!(subi_si8(3, 16), -13);
+        assert_eq!(subi_si8(4, 16), -12);
+        assert_eq!(subi_si8(0, 4), -4);
+        assert_eq!(subi_si8(0, 3), -3);
+        assert_eq!(subi_si8(1, 4), -3);
+        assert_eq!(subi_si8(0, 2), -2);
+        assert_eq!(subi_si8(1, 3), -2);
+        assert_eq!(subi_si8(2, 4), -2);
+        assert_eq!(subi_si8(-128, -127), -1);
+        assert_eq!(subi_si8(0, 1), -1);
+        assert_eq!(subi_si8(1, 2), -1);
+        assert_eq!(subi_si8(2, 3), -1);
+        assert_eq!(subi_si8(3, 4), -1);
+        assert_eq!(subi_si8(126, 127), -1);
+        assert_eq!(subi_si8(-128, -128), 0);
+        assert_eq!(subi_si8(-127, -127), 0);
+        assert_eq!(subi_si8(0, 0), 0);
+        assert_eq!(subi_si8(1, 1), 0);
+        assert_eq!(subi_si8(2, 2), 0);
+        assert_eq!(subi_si8(3, 3), 0);
+        assert_eq!(subi_si8(4, 4), 0);
+        assert_eq!(subi_si8(16, 16), 0);
+        assert_eq!(subi_si8(126, 126), 0);
+        assert_eq!(subi_si8(127, 127), 0);
+        assert_eq!(subi_si8(-127, -128), 1);
+        assert_eq!(subi_si8(1, 0), 1);
+        assert_eq!(subi_si8(2, 1), 1);
+        assert_eq!(subi_si8(3, 2), 1);
+        assert_eq!(subi_si8(4, 3), 1);
+        assert_eq!(subi_si8(127, 126), 1);
+        assert_eq!(subi_si8(2, 0), 2);
+        assert_eq!(subi_si8(3, 1), 2);
+        assert_eq!(subi_si8(4, 2), 2);
+        assert_eq!(subi_si8(3, 0), 3);
+        assert_eq!(subi_si8(4, 1), 3);
+        assert_eq!(subi_si8(4, 0), 4);
+        assert_eq!(subi_si8(16, 4), 12);
+        assert_eq!(subi_si8(16, 3), 13);
+        assert_eq!(subi_si8(16, 2), 14);
+        assert_eq!(subi_si8(16, 1), 15);
+        assert_eq!(subi_si8(16, 0), 16);
+        assert_eq!(subi_si8(126, 16), 110);
+        assert_eq!(subi_si8(127, 16), 111);
+        assert_eq!(subi_si8(126, 4), 122);
+        assert_eq!(subi_si8(126, 3), 123);
+        assert_eq!(subi_si8(127, 4), 123);
+        assert_eq!(subi_si8(126, 2), 124);
+        assert_eq!(subi_si8(127, 3), 124);
+        assert_eq!(subi_si8(126, 1), 125);
+        assert_eq!(subi_si8(127, 2), 125);
+        assert_eq!(subi_si8(126, 0), 126);
+        assert_eq!(subi_si8(127, 1), 126);
+        assert_eq!(subi_si8(0, -127), 127);
+        assert_eq!(subi_si8(127, 0), 127);
+        assert_eq!(subi_ui16(0, 0), 0);
+        assert_eq!(subi_ui16(1, 1), 0);
+        assert_eq!(subi_ui16(2, 2), 0);
+        assert_eq!(subi_ui16(3, 3), 0);
+        assert_eq!(subi_ui16(4, 4), 0);
+        assert_eq!(subi_ui16(1717, 1717), 0);
+        assert_eq!(subi_ui16(17988, 17988), 0);
+        assert_eq!(subi_ui16(65096, 65096), 0);
+        assert_eq!(subi_ui16(65534, 65534), 0);
+        assert_eq!(subi_ui16(65535, 65535), 0);
+        assert_eq!(subi_ui16(1, 0), 1);
+        assert_eq!(subi_ui16(2, 1), 1);
+        assert_eq!(subi_ui16(3, 2), 1);
+        assert_eq!(subi_ui16(4, 3), 1);
+        assert_eq!(subi_ui16(65535, 65534), 1);
+        assert_eq!(subi_ui16(2, 0), 2);
+        assert_eq!(subi_ui16(3, 1), 2);
+        assert_eq!(subi_ui16(4, 2), 2);
+        assert_eq!(subi_ui16(3, 0), 3);
+        assert_eq!(subi_ui16(4, 1), 3);
+        assert_eq!(subi_ui16(4, 0), 4);
+        assert_eq!(subi_ui16(65534, 65096), 438);
+        assert_eq!(subi_ui16(65535, 65096), 439);
+        assert_eq!(subi_ui16(1717, 4), 1713);
+        assert_eq!(subi_ui16(1717, 3), 1714);
+        assert_eq!(subi_ui16(1717, 2), 1715);
+        assert_eq!(subi_ui16(1717, 1), 1716);
+        assert_eq!(subi_ui16(1717, 0), 1717);
+        assert_eq!(subi_ui16(17988, 1717), 16271);
+        assert_eq!(subi_ui16(17988, 4), 17984);
+        assert_eq!(subi_ui16(17988, 3), 17985);
+        assert_eq!(subi_ui16(17988, 2), 17986);
+        assert_eq!(subi_ui16(17988, 1), 17987);
+        assert_eq!(subi_ui16(17988, 0), 17988);
+        assert_eq!(subi_ui16(65096, 17988), 47108);
+        assert_eq!(subi_ui16(65534, 17988), 47546);
+        assert_eq!(subi_ui16(65535, 17988), 47547);
+        assert_eq!(subi_ui16(65096, 1717), 63379);
+        assert_eq!(subi_ui16(65534, 1717), 63817);
+        assert_eq!(subi_ui16(65535, 1717), 63818);
+        assert_eq!(subi_ui16(65096, 4), 65092);
+        assert_eq!(subi_ui16(65096, 3), 65093);
+        assert_eq!(subi_ui16(65096, 2), 65094);
+        assert_eq!(subi_ui16(65096, 1), 65095);
+        assert_eq!(subi_ui16(65096, 0), 65096);
+        assert_eq!(subi_ui16(65534, 4), 65530);
+        assert_eq!(subi_ui16(65534, 3), 65531);
+        assert_eq!(subi_ui16(65535, 4), 65531);
+        assert_eq!(subi_ui16(65534, 2), 65532);
+        assert_eq!(subi_ui16(65535, 3), 65532);
+        assert_eq!(subi_ui16(65534, 1), 65533);
+        assert_eq!(subi_ui16(65535, 2), 65533);
+        assert_eq!(subi_ui16(65534, 0), 65534);
+        assert_eq!(subi_ui16(65535, 1), 65534);
+        assert_eq!(subi_ui16(65535, 0), 65535);
+        assert_eq!(subi_ui32(0, 0), 0);
+        assert_eq!(subi_ui32(1, 1), 0);
+        assert_eq!(subi_ui32(2, 2), 0);
+        assert_eq!(subi_ui32(3, 3), 0);
+        assert_eq!(subi_ui32(4, 4), 0);
+        assert_eq!(subi_ui32(2119154652, 2119154652), 0);
+        assert_eq!(subi_ui32(3002788344, 3002788344), 0);
+        assert_eq!(subi_ui32(3482297128, 3482297128), 0);
+        assert_eq!(subi_ui32(4294967294, 4294967294), 0);
+        assert_eq!(subi_ui32(4294967295, 4294967295), 0);
+        assert_eq!(subi_ui32(1, 0), 1);
+        assert_eq!(subi_ui32(2, 1), 1);
+        assert_eq!(subi_ui32(3, 2), 1);
+        assert_eq!(subi_ui32(4, 3), 1);
+        assert_eq!(subi_ui32(4294967295, 4294967294), 1);
+        assert_eq!(subi_ui32(2, 0), 2);
+        assert_eq!(subi_ui32(3, 1), 2);
+        assert_eq!(subi_ui32(4, 2), 2);
+        assert_eq!(subi_ui32(3, 0), 3);
+        assert_eq!(subi_ui32(4, 1), 3);
+        assert_eq!(subi_ui32(4, 0), 4);
+        assert_eq!(subi_ui32(3482297128, 3002788344), 479508784);
+        assert_eq!(subi_ui32(4294967294, 3482297128), 812670166);
+        assert_eq!(subi_ui32(4294967295, 3482297128), 812670167);
+        assert_eq!(subi_ui32(3002788344, 2119154652), 883633692);
+        assert_eq!(subi_ui32(4294967294, 3002788344), 1292178950);
+        assert_eq!(subi_ui32(4294967295, 3002788344), 1292178951);
+        assert_eq!(subi_ui32(3482297128, 2119154652), 1363142476);
+        assert_eq!(subi_ui32(2119154652, 4), 2119154648);
+        assert_eq!(subi_ui32(2119154652, 3), 2119154649);
+        assert_eq!(subi_ui32(2119154652, 2), 2119154650);
+        assert_eq!(subi_ui32(2119154652, 1), 2119154651);
+        assert_eq!(subi_ui32(2119154652, 0), 2119154652);
+        assert_eq!(subi_ui32(4294967294, 2119154652), 2175812642);
+        assert_eq!(subi_ui32(4294967295, 2119154652), 2175812643);
+        assert_eq!(subi_ui32(3002788344, 4), 3002788340);
+        assert_eq!(subi_ui32(3002788344, 3), 3002788341);
+        assert_eq!(subi_ui32(3002788344, 2), 3002788342);
+        assert_eq!(subi_ui32(3002788344, 1), 3002788343);
+        assert_eq!(subi_ui32(3002788344, 0), 3002788344);
+        assert_eq!(subi_ui32(3482297128, 4), 3482297124);
+        assert_eq!(subi_ui32(3482297128, 3), 3482297125);
+        assert_eq!(subi_ui32(3482297128, 2), 3482297126);
+        assert_eq!(subi_ui32(3482297128, 1), 3482297127);
+        assert_eq!(subi_ui32(3482297128, 0), 3482297128);
+        assert_eq!(subi_ui32(4294967294, 4), 4294967290);
+        assert_eq!(subi_ui32(4294967294, 3), 4294967291);
+        assert_eq!(subi_ui32(4294967295, 4), 4294967291);
+        assert_eq!(subi_ui32(4294967294, 2), 4294967292);
+        assert_eq!(subi_ui32(4294967295, 3), 4294967292);
+        assert_eq!(subi_ui32(4294967294, 1), 4294967293);
+        assert_eq!(subi_ui32(4294967295, 2), 4294967293);
+        assert_eq!(subi_ui32(4294967294, 0), 4294967294);
+        assert_eq!(subi_ui32(4294967295, 1), 4294967294);
+        assert_eq!(subi_ui32(4294967295, 0), 4294967295);
+        assert_eq!(subi_ui64(0, 0), 0);
+        assert_eq!(subi_ui64(1, 1), 0);
+        assert_eq!(subi_ui64(2, 2), 0);
+        assert_eq!(subi_ui64(3, 3), 0);
+        assert_eq!(subi_ui64(4, 4), 0);
+        assert_eq!(subi_ui64(191084152064409600, 191084152064409600), 0);
+        assert_eq!(subi_ui64(11015955194427482112, 11015955194427482112), 0);
+        assert_eq!(subi_ui64(16990600415051759616, 16990600415051759616), 0);
+        assert_eq!(subi_ui64(18446744073709551614, 18446744073709551614), 0);
+        assert_eq!(subi_ui64(18446744073709551615, 18446744073709551615), 0);
+        assert_eq!(subi_ui64(1, 0), 1);
+        assert_eq!(subi_ui64(2, 1), 1);
+        assert_eq!(subi_ui64(3, 2), 1);
+        assert_eq!(subi_ui64(4, 3), 1);
+        assert_eq!(subi_ui64(18446744073709551615, 18446744073709551614), 1);
+        assert_eq!(subi_ui64(2, 0), 2);
+        assert_eq!(subi_ui64(3, 1), 2);
+        assert_eq!(subi_ui64(4, 2), 2);
+        assert_eq!(subi_ui64(3, 0), 3);
+        assert_eq!(subi_ui64(4, 1), 3);
+        assert_eq!(subi_ui64(4, 0), 4);
+        assert_eq!(subi_ui64(191084152064409600, 4), 191084152064409596);
+        assert_eq!(subi_ui64(191084152064409600, 3), 191084152064409597);
+        assert_eq!(subi_ui64(191084152064409600, 2), 191084152064409598);
+        assert_eq!(subi_ui64(191084152064409600, 1), 191084152064409599);
+        assert_eq!(subi_ui64(191084152064409600, 0), 191084152064409600);
+        assert_eq!(
+            subi_ui64(18446744073709551614, 16990600415051759616),
+            1456143658657791998
+        );
+        assert_eq!(
+            subi_ui64(18446744073709551615, 16990600415051759616),
+            1456143658657791999
+        );
+        assert_eq!(
+            subi_ui64(16990600415051759616, 11015955194427482112),
+            5974645220624277504
+        );
+        assert_eq!(
+            subi_ui64(18446744073709551614, 11015955194427482112),
+            7430788879282069502
+        );
+        assert_eq!(
+            subi_ui64(18446744073709551615, 11015955194427482112),
+            7430788879282069503
+        );
+        assert_eq!(
+            subi_ui64(11015955194427482112, 191084152064409600),
+            10824871042363072512
+        );
+        assert_eq!(subi_ui64(11015955194427482112, 4), 11015955194427482108);
+        assert_eq!(subi_ui64(11015955194427482112, 3), 11015955194427482109);
+        assert_eq!(subi_ui64(11015955194427482112, 2), 11015955194427482110);
+        assert_eq!(subi_ui64(11015955194427482112, 1), 11015955194427482111);
+        assert_eq!(subi_ui64(11015955194427482112, 0), 11015955194427482112);
+        assert_eq!(
+            subi_ui64(16990600415051759616, 191084152064409600),
+            16799516262987350016
+        );
+        assert_eq!(subi_ui64(16990600415051759616, 4), 16990600415051759612);
+        assert_eq!(subi_ui64(16990600415051759616, 3), 16990600415051759613);
+        assert_eq!(subi_ui64(16990600415051759616, 2), 16990600415051759614);
+        assert_eq!(subi_ui64(16990600415051759616, 1), 16990600415051759615);
+        assert_eq!(subi_ui64(16990600415051759616, 0), 16990600415051759616);
+        assert_eq!(
+            subi_ui64(18446744073709551614, 191084152064409600),
+            18255659921645142014
+        );
+        assert_eq!(
+            subi_ui64(18446744073709551615, 191084152064409600),
+            18255659921645142015
+        );
+        assert_eq!(subi_ui64(18446744073709551614, 4), 18446744073709551610);
+        assert_eq!(subi_ui64(18446744073709551614, 3), 18446744073709551611);
+        assert_eq!(subi_ui64(18446744073709551615, 4), 18446744073709551611);
+        assert_eq!(subi_ui64(18446744073709551614, 2), 18446744073709551612);
+        assert_eq!(subi_ui64(18446744073709551615, 3), 18446744073709551612);
+        assert_eq!(subi_ui64(18446744073709551614, 1), 18446744073709551613);
+        assert_eq!(subi_ui64(18446744073709551615, 2), 18446744073709551613);
+        assert_eq!(subi_ui64(18446744073709551614, 0), 18446744073709551614);
+        assert_eq!(subi_ui64(18446744073709551615, 1), 18446744073709551614);
+        assert_eq!(subi_ui64(18446744073709551615, 0), 18446744073709551615);
+        assert_eq!(subi_ui8(0, 0), 0);
+        assert_eq!(subi_ui8(1, 1), 0);
+        assert_eq!(subi_ui8(2, 2), 0);
+        assert_eq!(subi_ui8(3, 3), 0);
+        assert_eq!(subi_ui8(4, 4), 0);
+        assert_eq!(subi_ui8(72, 72), 0);
+        assert_eq!(subi_ui8(100, 100), 0);
+        assert_eq!(subi_ui8(162, 162), 0);
+        assert_eq!(subi_ui8(254, 254), 0);
+        assert_eq!(subi_ui8(255, 255), 0);
+        assert_eq!(subi_ui8(1, 0), 1);
+        assert_eq!(subi_ui8(2, 1), 1);
+        assert_eq!(subi_ui8(3, 2), 1);
+        assert_eq!(subi_ui8(4, 3), 1);
+        assert_eq!(subi_ui8(255, 254), 1);
+        assert_eq!(subi_ui8(2, 0), 2);
+        assert_eq!(subi_ui8(3, 1), 2);
+        assert_eq!(subi_ui8(4, 2), 2);
+        assert_eq!(subi_ui8(3, 0), 3);
+        assert_eq!(subi_ui8(4, 1), 3);
+        assert_eq!(subi_ui8(4, 0), 4);
+        assert_eq!(subi_ui8(100, 72), 28);
+        assert_eq!(subi_ui8(162, 100), 62);
+        assert_eq!(subi_ui8(72, 4), 68);
+        assert_eq!(subi_ui8(72, 3), 69);
+        assert_eq!(subi_ui8(72, 2), 70);
+        assert_eq!(subi_ui8(72, 1), 71);
+        assert_eq!(subi_ui8(72, 0), 72);
+        assert_eq!(subi_ui8(162, 72), 90);
+        assert_eq!(subi_ui8(254, 162), 92);
+        assert_eq!(subi_ui8(255, 162), 93);
+        assert_eq!(subi_ui8(100, 4), 96);
+        assert_eq!(subi_ui8(100, 3), 97);
+        assert_eq!(subi_ui8(100, 2), 98);
+        assert_eq!(subi_ui8(100, 1), 99);
+        assert_eq!(subi_ui8(100, 0), 100);
+        assert_eq!(subi_ui8(254, 100), 154);
+        assert_eq!(subi_ui8(255, 100), 155);
+        assert_eq!(subi_ui8(162, 4), 158);
+        assert_eq!(subi_ui8(162, 3), 159);
+        assert_eq!(subi_ui8(162, 2), 160);
+        assert_eq!(subi_ui8(162, 1), 161);
+        assert_eq!(subi_ui8(162, 0), 162);
+        assert_eq!(subi_ui8(254, 72), 182);
+        assert_eq!(subi_ui8(255, 72), 183);
+        assert_eq!(subi_ui8(254, 4), 250);
+        assert_eq!(subi_ui8(254, 3), 251);
+        assert_eq!(subi_ui8(255, 4), 251);
+        assert_eq!(subi_ui8(254, 2), 252);
+        assert_eq!(subi_ui8(255, 3), 252);
+        assert_eq!(subi_ui8(254, 1), 253);
+        assert_eq!(subi_ui8(255, 2), 253);
+        assert_eq!(subi_ui8(254, 0), 254);
+        assert_eq!(subi_ui8(255, 1), 254);
+        assert_eq!(subi_ui8(255, 0), 255);
+    }
 }
diff --git a/arc-mlir/src/tests/arc-to-rust/int-bitops.mlir.rust-tests b/arc-mlir/src/tests/arc-to-rust/int-bitops.mlir.rust-tests
index 8a082f3e8..96980ca24 100644
--- a/arc-mlir/src/tests/arc-to-rust/int-bitops.mlir.rust-tests
+++ b/arc-mlir/src/tests/arc-to-rust/int-bitops.mlir.rust-tests
@@ -1,2804 +1,3307 @@
 #[cfg(test)]
 mod tests {
-use crate::arctorustintbitops::*;
-  #[rewrite(main)]
-  #[test]
-  fn it_works() {
-    assert_eq!(call!(and_si16(-32768, -32768)), -32768);
-    assert_eq!(call!(and_si16(-32768, -32767)), -32768);
-    assert_eq!(call!(and_si16(-32768, -32547)), -32768);
-    assert_eq!(call!(and_si16(-32767, -32768)), -32768);
-    assert_eq!(call!(and_si16(-32547, -32768)), -32768);
-    assert_eq!(call!(and_si16(-32767, -32767)), -32767);
-    assert_eq!(call!(and_si16(-32767, -32547)), -32767);
-    assert_eq!(call!(and_si16(-32547, -32767)), -32767);
-    assert_eq!(call!(and_si16(-32547, -32547)), -32547);
-    assert_eq!(call!(and_si16(-32768, 0)), 0);
-    assert_eq!(call!(and_si16(-32768, 1)), 0);
-    assert_eq!(call!(and_si16(-32768, 2)), 0);
-    assert_eq!(call!(and_si16(-32768, 3)), 0);
-    assert_eq!(call!(and_si16(-32768, 4)), 0);
-    assert_eq!(call!(and_si16(-32768, 10486)), 0);
-    assert_eq!(call!(and_si16(-32768, 16514)), 0);
-    assert_eq!(call!(and_si16(-32768, 32766)), 0);
-    assert_eq!(call!(and_si16(-32768, 32767)), 0);
-    assert_eq!(call!(and_si16(-32767, 0)), 0);
-    assert_eq!(call!(and_si16(-32767, 2)), 0);
-    assert_eq!(call!(and_si16(-32767, 4)), 0);
-    assert_eq!(call!(and_si16(-32767, 10486)), 0);
-    assert_eq!(call!(and_si16(-32767, 16514)), 0);
-    assert_eq!(call!(and_si16(-32767, 32766)), 0);
-    assert_eq!(call!(and_si16(-32547, 0)), 0);
-    assert_eq!(call!(and_si16(-32547, 2)), 0);
-    assert_eq!(call!(and_si16(0, -32768)), 0);
-    assert_eq!(call!(and_si16(0, -32767)), 0);
-    assert_eq!(call!(and_si16(0, -32547)), 0);
-    assert_eq!(call!(and_si16(0, 0)), 0);
-    assert_eq!(call!(and_si16(0, 1)), 0);
-    assert_eq!(call!(and_si16(0, 2)), 0);
-    assert_eq!(call!(and_si16(0, 3)), 0);
-    assert_eq!(call!(and_si16(0, 4)), 0);
-    assert_eq!(call!(and_si16(0, 10486)), 0);
-    assert_eq!(call!(and_si16(0, 16514)), 0);
-    assert_eq!(call!(and_si16(0, 32766)), 0);
-    assert_eq!(call!(and_si16(0, 32767)), 0);
-    assert_eq!(call!(and_si16(1, -32768)), 0);
-    assert_eq!(call!(and_si16(1, 0)), 0);
-    assert_eq!(call!(and_si16(1, 2)), 0);
-    assert_eq!(call!(and_si16(1, 4)), 0);
-    assert_eq!(call!(and_si16(1, 10486)), 0);
-    assert_eq!(call!(and_si16(1, 16514)), 0);
-    assert_eq!(call!(and_si16(1, 32766)), 0);
-    assert_eq!(call!(and_si16(2, -32768)), 0);
-    assert_eq!(call!(and_si16(2, -32767)), 0);
-    assert_eq!(call!(and_si16(2, -32547)), 0);
-    assert_eq!(call!(and_si16(2, 0)), 0);
-    assert_eq!(call!(and_si16(2, 1)), 0);
-    assert_eq!(call!(and_si16(2, 4)), 0);
-    assert_eq!(call!(and_si16(3, -32768)), 0);
-    assert_eq!(call!(and_si16(3, 0)), 0);
-    assert_eq!(call!(and_si16(3, 4)), 0);
-    assert_eq!(call!(and_si16(4, -32768)), 0);
-    assert_eq!(call!(and_si16(4, -32767)), 0);
-    assert_eq!(call!(and_si16(4, 0)), 0);
-    assert_eq!(call!(and_si16(4, 1)), 0);
-    assert_eq!(call!(and_si16(4, 2)), 0);
-    assert_eq!(call!(and_si16(4, 3)), 0);
-    assert_eq!(call!(and_si16(4, 16514)), 0);
-    assert_eq!(call!(and_si16(10486, -32768)), 0);
-    assert_eq!(call!(and_si16(10486, -32767)), 0);
-    assert_eq!(call!(and_si16(10486, 0)), 0);
-    assert_eq!(call!(and_si16(10486, 1)), 0);
-    assert_eq!(call!(and_si16(16514, -32768)), 0);
-    assert_eq!(call!(and_si16(16514, -32767)), 0);
-    assert_eq!(call!(and_si16(16514, 0)), 0);
-    assert_eq!(call!(and_si16(16514, 1)), 0);
-    assert_eq!(call!(and_si16(16514, 4)), 0);
-    assert_eq!(call!(and_si16(32766, -32768)), 0);
-    assert_eq!(call!(and_si16(32766, -32767)), 0);
-    assert_eq!(call!(and_si16(32766, 0)), 0);
-    assert_eq!(call!(and_si16(32766, 1)), 0);
-    assert_eq!(call!(and_si16(32767, -32768)), 0);
-    assert_eq!(call!(and_si16(32767, 0)), 0);
-    assert_eq!(call!(and_si16(-32767, 1)), 1);
-    assert_eq!(call!(and_si16(-32767, 3)), 1);
-    assert_eq!(call!(and_si16(-32767, 32767)), 1);
-    assert_eq!(call!(and_si16(-32547, 1)), 1);
-    assert_eq!(call!(and_si16(-32547, 3)), 1);
-    assert_eq!(call!(and_si16(1, -32767)), 1);
-    assert_eq!(call!(and_si16(1, -32547)), 1);
-    assert_eq!(call!(and_si16(1, 1)), 1);
-    assert_eq!(call!(and_si16(1, 3)), 1);
-    assert_eq!(call!(and_si16(1, 32767)), 1);
-    assert_eq!(call!(and_si16(3, -32767)), 1);
-    assert_eq!(call!(and_si16(3, -32547)), 1);
-    assert_eq!(call!(and_si16(3, 1)), 1);
-    assert_eq!(call!(and_si16(32767, -32767)), 1);
-    assert_eq!(call!(and_si16(32767, 1)), 1);
-    assert_eq!(call!(and_si16(2, 2)), 2);
-    assert_eq!(call!(and_si16(2, 3)), 2);
-    assert_eq!(call!(and_si16(2, 10486)), 2);
-    assert_eq!(call!(and_si16(2, 16514)), 2);
-    assert_eq!(call!(and_si16(2, 32766)), 2);
-    assert_eq!(call!(and_si16(2, 32767)), 2);
-    assert_eq!(call!(and_si16(3, 2)), 2);
-    assert_eq!(call!(and_si16(3, 10486)), 2);
-    assert_eq!(call!(and_si16(3, 16514)), 2);
-    assert_eq!(call!(and_si16(3, 32766)), 2);
-    assert_eq!(call!(and_si16(10486, 2)), 2);
-    assert_eq!(call!(and_si16(10486, 3)), 2);
-    assert_eq!(call!(and_si16(16514, 2)), 2);
-    assert_eq!(call!(and_si16(16514, 3)), 2);
-    assert_eq!(call!(and_si16(32766, 2)), 2);
-    assert_eq!(call!(and_si16(32766, 3)), 2);
-    assert_eq!(call!(and_si16(32767, 2)), 2);
-    assert_eq!(call!(and_si16(3, 3)), 3);
-    assert_eq!(call!(and_si16(3, 32767)), 3);
-    assert_eq!(call!(and_si16(32767, 3)), 3);
-    assert_eq!(call!(and_si16(-32547, 4)), 4);
-    assert_eq!(call!(and_si16(4, -32547)), 4);
-    assert_eq!(call!(and_si16(4, 4)), 4);
-    assert_eq!(call!(and_si16(4, 10486)), 4);
-    assert_eq!(call!(and_si16(4, 32766)), 4);
-    assert_eq!(call!(and_si16(4, 32767)), 4);
-    assert_eq!(call!(and_si16(10486, 4)), 4);
-    assert_eq!(call!(and_si16(32766, 4)), 4);
-    assert_eq!(call!(and_si16(32767, 4)), 4);
-    assert_eq!(call!(and_si16(-32547, 16514)), 128);
-    assert_eq!(call!(and_si16(16514, -32547)), 128);
-    assert_eq!(call!(and_si16(10486, 16514)), 130);
-    assert_eq!(call!(and_si16(16514, 10486)), 130);
-    assert_eq!(call!(and_si16(-32547, 10486)), 212);
-    assert_eq!(call!(and_si16(10486, -32547)), 212);
-    assert_eq!(call!(and_si16(-32547, 32766)), 220);
-    assert_eq!(call!(and_si16(32766, -32547)), 220);
-    assert_eq!(call!(and_si16(-32547, 32767)), 221);
-    assert_eq!(call!(and_si16(32767, -32547)), 221);
-    assert_eq!(call!(and_si16(10486, 10486)), 10486);
-    assert_eq!(call!(and_si16(10486, 32766)), 10486);
-    assert_eq!(call!(and_si16(10486, 32767)), 10486);
-    assert_eq!(call!(and_si16(32766, 10486)), 10486);
-    assert_eq!(call!(and_si16(32767, 10486)), 10486);
-    assert_eq!(call!(and_si16(16514, 16514)), 16514);
-    assert_eq!(call!(and_si16(16514, 32766)), 16514);
-    assert_eq!(call!(and_si16(16514, 32767)), 16514);
-    assert_eq!(call!(and_si16(32766, 16514)), 16514);
-    assert_eq!(call!(and_si16(32767, 16514)), 16514);
-    assert_eq!(call!(and_si16(32766, 32766)), 32766);
-    assert_eq!(call!(and_si16(32766, 32767)), 32766);
-    assert_eq!(call!(and_si16(32767, 32766)), 32766);
-    assert_eq!(call!(and_si16(32767, 32767)), 32767);
-    assert_eq!(call!(and_si32(-2147483648, -2147483648)), -2147483648);
-    assert_eq!(call!(and_si32(-2147483648, -2147483647)), -2147483648);
-    assert_eq!(call!(and_si32(-2147483648, -1713183800)), -2147483648);
-    assert_eq!(call!(and_si32(-2147483648, -1252582164)), -2147483648);
-    assert_eq!(call!(and_si32(-2147483648, -1035405763)), -2147483648);
-    assert_eq!(call!(and_si32(-2147483647, -2147483648)), -2147483648);
-    assert_eq!(call!(and_si32(-2147483647, -1713183800)), -2147483648);
-    assert_eq!(call!(and_si32(-2147483647, -1252582164)), -2147483648);
-    assert_eq!(call!(and_si32(-1713183800, -2147483648)), -2147483648);
-    assert_eq!(call!(and_si32(-1713183800, -2147483647)), -2147483648);
-    assert_eq!(call!(and_si32(-1252582164, -2147483648)), -2147483648);
-    assert_eq!(call!(and_si32(-1252582164, -2147483647)), -2147483648);
-    assert_eq!(call!(and_si32(-1035405763, -2147483648)), -2147483648);
-    assert_eq!(call!(and_si32(-2147483647, -2147483647)), -2147483647);
-    assert_eq!(call!(and_si32(-2147483647, -1035405763)), -2147483647);
-    assert_eq!(call!(and_si32(-1035405763, -2147483647)), -2147483647);
-    assert_eq!(call!(and_si32(-1252582164, -1035405763)), -2143284180);
-    assert_eq!(call!(and_si32(-1035405763, -1252582164)), -2143284180);
-    assert_eq!(call!(and_si32(-1713183800, -1035405763)), -2143231480);
-    assert_eq!(call!(and_si32(-1035405763, -1713183800)), -2143231480);
-    assert_eq!(call!(and_si32(-1713183800, -1252582164)), -1857945400);
-    assert_eq!(call!(and_si32(-1252582164, -1713183800)), -1857945400);
-    assert_eq!(call!(and_si32(-1713183800, -1713183800)), -1713183800);
-    assert_eq!(call!(and_si32(-1252582164, -1252582164)), -1252582164);
-    assert_eq!(call!(and_si32(-1035405763, -1035405763)), -1035405763);
-    assert_eq!(call!(and_si32(-2147483648, 0)), 0);
-    assert_eq!(call!(and_si32(-2147483648, 1)), 0);
-    assert_eq!(call!(and_si32(-2147483648, 2)), 0);
-    assert_eq!(call!(and_si32(-2147483648, 3)), 0);
-    assert_eq!(call!(and_si32(-2147483648, 4)), 0);
-    assert_eq!(call!(and_si32(-2147483648, 2147483646)), 0);
-    assert_eq!(call!(and_si32(-2147483648, 2147483647)), 0);
-    assert_eq!(call!(and_si32(-2147483647, 0)), 0);
-    assert_eq!(call!(and_si32(-2147483647, 2)), 0);
-    assert_eq!(call!(and_si32(-2147483647, 4)), 0);
-    assert_eq!(call!(and_si32(-2147483647, 2147483646)), 0);
-    assert_eq!(call!(and_si32(-1713183800, 0)), 0);
-    assert_eq!(call!(and_si32(-1713183800, 1)), 0);
-    assert_eq!(call!(and_si32(-1713183800, 2)), 0);
-    assert_eq!(call!(and_si32(-1713183800, 3)), 0);
-    assert_eq!(call!(and_si32(-1713183800, 4)), 0);
-    assert_eq!(call!(and_si32(-1252582164, 0)), 0);
-    assert_eq!(call!(and_si32(-1252582164, 1)), 0);
-    assert_eq!(call!(and_si32(-1252582164, 2)), 0);
-    assert_eq!(call!(and_si32(-1252582164, 3)), 0);
-    assert_eq!(call!(and_si32(-1035405763, 0)), 0);
-    assert_eq!(call!(and_si32(-1035405763, 2)), 0);
-    assert_eq!(call!(and_si32(0, -2147483648)), 0);
-    assert_eq!(call!(and_si32(0, -2147483647)), 0);
-    assert_eq!(call!(and_si32(0, -1713183800)), 0);
-    assert_eq!(call!(and_si32(0, -1252582164)), 0);
-    assert_eq!(call!(and_si32(0, -1035405763)), 0);
-    assert_eq!(call!(and_si32(0, 0)), 0);
-    assert_eq!(call!(and_si32(0, 1)), 0);
-    assert_eq!(call!(and_si32(0, 2)), 0);
-    assert_eq!(call!(and_si32(0, 3)), 0);
-    assert_eq!(call!(and_si32(0, 4)), 0);
-    assert_eq!(call!(and_si32(0, 2147483646)), 0);
-    assert_eq!(call!(and_si32(0, 2147483647)), 0);
-    assert_eq!(call!(and_si32(1, -2147483648)), 0);
-    assert_eq!(call!(and_si32(1, -1713183800)), 0);
-    assert_eq!(call!(and_si32(1, -1252582164)), 0);
-    assert_eq!(call!(and_si32(1, 0)), 0);
-    assert_eq!(call!(and_si32(1, 2)), 0);
-    assert_eq!(call!(and_si32(1, 4)), 0);
-    assert_eq!(call!(and_si32(1, 2147483646)), 0);
-    assert_eq!(call!(and_si32(2, -2147483648)), 0);
-    assert_eq!(call!(and_si32(2, -2147483647)), 0);
-    assert_eq!(call!(and_si32(2, -1713183800)), 0);
-    assert_eq!(call!(and_si32(2, -1252582164)), 0);
-    assert_eq!(call!(and_si32(2, -1035405763)), 0);
-    assert_eq!(call!(and_si32(2, 0)), 0);
-    assert_eq!(call!(and_si32(2, 1)), 0);
-    assert_eq!(call!(and_si32(2, 4)), 0);
-    assert_eq!(call!(and_si32(3, -2147483648)), 0);
-    assert_eq!(call!(and_si32(3, -1713183800)), 0);
-    assert_eq!(call!(and_si32(3, -1252582164)), 0);
-    assert_eq!(call!(and_si32(3, 0)), 0);
-    assert_eq!(call!(and_si32(3, 4)), 0);
-    assert_eq!(call!(and_si32(4, -2147483648)), 0);
-    assert_eq!(call!(and_si32(4, -2147483647)), 0);
-    assert_eq!(call!(and_si32(4, -1713183800)), 0);
-    assert_eq!(call!(and_si32(4, 0)), 0);
-    assert_eq!(call!(and_si32(4, 1)), 0);
-    assert_eq!(call!(and_si32(4, 2)), 0);
-    assert_eq!(call!(and_si32(4, 3)), 0);
-    assert_eq!(call!(and_si32(2147483646, -2147483648)), 0);
-    assert_eq!(call!(and_si32(2147483646, -2147483647)), 0);
-    assert_eq!(call!(and_si32(2147483646, 0)), 0);
-    assert_eq!(call!(and_si32(2147483646, 1)), 0);
-    assert_eq!(call!(and_si32(2147483647, -2147483648)), 0);
-    assert_eq!(call!(and_si32(2147483647, 0)), 0);
-    assert_eq!(call!(and_si32(-2147483647, 1)), 1);
-    assert_eq!(call!(and_si32(-2147483647, 3)), 1);
-    assert_eq!(call!(and_si32(-2147483647, 2147483647)), 1);
-    assert_eq!(call!(and_si32(-1035405763, 1)), 1);
-    assert_eq!(call!(and_si32(-1035405763, 3)), 1);
-    assert_eq!(call!(and_si32(1, -2147483647)), 1);
-    assert_eq!(call!(and_si32(1, -1035405763)), 1);
-    assert_eq!(call!(and_si32(1, 1)), 1);
-    assert_eq!(call!(and_si32(1, 3)), 1);
-    assert_eq!(call!(and_si32(1, 2147483647)), 1);
-    assert_eq!(call!(and_si32(3, -2147483647)), 1);
-    assert_eq!(call!(and_si32(3, -1035405763)), 1);
-    assert_eq!(call!(and_si32(3, 1)), 1);
-    assert_eq!(call!(and_si32(2147483647, -2147483647)), 1);
-    assert_eq!(call!(and_si32(2147483647, 1)), 1);
-    assert_eq!(call!(and_si32(2, 2)), 2);
-    assert_eq!(call!(and_si32(2, 3)), 2);
-    assert_eq!(call!(and_si32(2, 2147483646)), 2);
-    assert_eq!(call!(and_si32(2, 2147483647)), 2);
-    assert_eq!(call!(and_si32(3, 2)), 2);
-    assert_eq!(call!(and_si32(3, 2147483646)), 2);
-    assert_eq!(call!(and_si32(2147483646, 2)), 2);
-    assert_eq!(call!(and_si32(2147483646, 3)), 2);
-    assert_eq!(call!(and_si32(2147483647, 2)), 2);
-    assert_eq!(call!(and_si32(3, 3)), 3);
-    assert_eq!(call!(and_si32(3, 2147483647)), 3);
-    assert_eq!(call!(and_si32(2147483647, 3)), 3);
-    assert_eq!(call!(and_si32(-1252582164, 4)), 4);
-    assert_eq!(call!(and_si32(-1035405763, 4)), 4);
-    assert_eq!(call!(and_si32(4, -1252582164)), 4);
-    assert_eq!(call!(and_si32(4, -1035405763)), 4);
-    assert_eq!(call!(and_si32(4, 4)), 4);
-    assert_eq!(call!(and_si32(4, 2147483646)), 4);
-    assert_eq!(call!(and_si32(4, 2147483647)), 4);
-    assert_eq!(call!(and_si32(2147483646, 4)), 4);
-    assert_eq!(call!(and_si32(2147483647, 4)), 4);
-    assert_eq!(call!(and_si32(-1713183800, 2147483646)), 434299848);
-    assert_eq!(call!(and_si32(-1713183800, 2147483647)), 434299848);
-    assert_eq!(call!(and_si32(2147483646, -1713183800)), 434299848);
-    assert_eq!(call!(and_si32(2147483647, -1713183800)), 434299848);
-    assert_eq!(call!(and_si32(-1252582164, 2147483646)), 894901484);
-    assert_eq!(call!(and_si32(-1252582164, 2147483647)), 894901484);
-    assert_eq!(call!(and_si32(2147483646, -1252582164)), 894901484);
-    assert_eq!(call!(and_si32(2147483647, -1252582164)), 894901484);
-    assert_eq!(call!(and_si32(-1035405763, 2147483646)), 1112077884);
-    assert_eq!(call!(and_si32(2147483646, -1035405763)), 1112077884);
-    assert_eq!(call!(and_si32(-1035405763, 2147483647)), 1112077885);
-    assert_eq!(call!(and_si32(2147483647, -1035405763)), 1112077885);
-    assert_eq!(call!(and_si32(2147483646, 2147483646)), 2147483646);
-    assert_eq!(call!(and_si32(2147483646, 2147483647)), 2147483646);
-    assert_eq!(call!(and_si32(2147483647, 2147483646)), 2147483646);
-    assert_eq!(call!(and_si32(2147483647, 2147483647)), 2147483647);
-    assert_eq!(call!(and_si64(-9223372036854775808, -9223372036854775808)), -9223372036854775808);
-    assert_eq!(call!(and_si64(-9223372036854775808, -9223372036854775807)), -9223372036854775808);
-    assert_eq!(call!(and_si64(-9223372036854775808, -1741927215160008704)), -9223372036854775808);
-    assert_eq!(call!(and_si64(-9223372036854775808, -1328271339354574848)), -9223372036854775808);
-    assert_eq!(call!(and_si64(-9223372036854775807, -9223372036854775808)), -9223372036854775808);
-    assert_eq!(call!(and_si64(-9223372036854775807, -1741927215160008704)), -9223372036854775808);
-    assert_eq!(call!(and_si64(-9223372036854775807, -1328271339354574848)), -9223372036854775808);
-    assert_eq!(call!(and_si64(-1741927215160008704, -9223372036854775808)), -9223372036854775808);
-    assert_eq!(call!(and_si64(-1741927215160008704, -9223372036854775807)), -9223372036854775808);
-    assert_eq!(call!(and_si64(-1328271339354574848, -9223372036854775808)), -9223372036854775808);
-    assert_eq!(call!(and_si64(-1328271339354574848, -9223372036854775807)), -9223372036854775808);
-    assert_eq!(call!(and_si64(-9223372036854775807, -9223372036854775807)), -9223372036854775807);
-    assert_eq!(call!(and_si64(-1741927215160008704, -1328271339354574848)), -1904732091996692480);
-    assert_eq!(call!(and_si64(-1328271339354574848, -1741927215160008704)), -1904732091996692480);
-    assert_eq!(call!(and_si64(-1741927215160008704, -1741927215160008704)), -1741927215160008704);
-    assert_eq!(call!(and_si64(-1328271339354574848, -1328271339354574848)), -1328271339354574848);
-    assert_eq!(call!(and_si64(-9223372036854775808, 0)), 0);
-    assert_eq!(call!(and_si64(-9223372036854775808, 1)), 0);
-    assert_eq!(call!(and_si64(-9223372036854775808, 2)), 0);
-    assert_eq!(call!(and_si64(-9223372036854775808, 3)), 0);
-    assert_eq!(call!(and_si64(-9223372036854775808, 4)), 0);
-    assert_eq!(call!(and_si64(-9223372036854775808, 5577148965131116544)), 0);
-    assert_eq!(call!(and_si64(-9223372036854775808, 9223372036854775806)), 0);
-    assert_eq!(call!(and_si64(-9223372036854775808, 9223372036854775807)), 0);
-    assert_eq!(call!(and_si64(-9223372036854775807, 0)), 0);
-    assert_eq!(call!(and_si64(-9223372036854775807, 2)), 0);
-    assert_eq!(call!(and_si64(-9223372036854775807, 4)), 0);
-    assert_eq!(call!(and_si64(-9223372036854775807, 5577148965131116544)), 0);
-    assert_eq!(call!(and_si64(-9223372036854775807, 9223372036854775806)), 0);
-    assert_eq!(call!(and_si64(-1741927215160008704, 0)), 0);
-    assert_eq!(call!(and_si64(-1741927215160008704, 1)), 0);
-    assert_eq!(call!(and_si64(-1741927215160008704, 2)), 0);
-    assert_eq!(call!(and_si64(-1741927215160008704, 3)), 0);
-    assert_eq!(call!(and_si64(-1741927215160008704, 4)), 0);
-    assert_eq!(call!(and_si64(-1328271339354574848, 0)), 0);
-    assert_eq!(call!(and_si64(-1328271339354574848, 1)), 0);
-    assert_eq!(call!(and_si64(-1328271339354574848, 2)), 0);
-    assert_eq!(call!(and_si64(-1328271339354574848, 3)), 0);
-    assert_eq!(call!(and_si64(-1328271339354574848, 4)), 0);
-    assert_eq!(call!(and_si64(0, -9223372036854775808)), 0);
-    assert_eq!(call!(and_si64(0, -9223372036854775807)), 0);
-    assert_eq!(call!(and_si64(0, -1741927215160008704)), 0);
-    assert_eq!(call!(and_si64(0, -1328271339354574848)), 0);
-    assert_eq!(call!(and_si64(0, 0)), 0);
-    assert_eq!(call!(and_si64(0, 1)), 0);
-    assert_eq!(call!(and_si64(0, 2)), 0);
-    assert_eq!(call!(and_si64(0, 3)), 0);
-    assert_eq!(call!(and_si64(0, 4)), 0);
-    assert_eq!(call!(and_si64(0, 5577148965131116544)), 0);
-    assert_eq!(call!(and_si64(0, 9223372036854775806)), 0);
-    assert_eq!(call!(and_si64(0, 9223372036854775807)), 0);
-    assert_eq!(call!(and_si64(1, -9223372036854775808)), 0);
-    assert_eq!(call!(and_si64(1, -1741927215160008704)), 0);
-    assert_eq!(call!(and_si64(1, -1328271339354574848)), 0);
-    assert_eq!(call!(and_si64(1, 0)), 0);
-    assert_eq!(call!(and_si64(1, 2)), 0);
-    assert_eq!(call!(and_si64(1, 4)), 0);
-    assert_eq!(call!(and_si64(1, 5577148965131116544)), 0);
-    assert_eq!(call!(and_si64(1, 9223372036854775806)), 0);
-    assert_eq!(call!(and_si64(2, -9223372036854775808)), 0);
-    assert_eq!(call!(and_si64(2, -9223372036854775807)), 0);
-    assert_eq!(call!(and_si64(2, -1741927215160008704)), 0);
-    assert_eq!(call!(and_si64(2, -1328271339354574848)), 0);
-    assert_eq!(call!(and_si64(2, 0)), 0);
-    assert_eq!(call!(and_si64(2, 1)), 0);
-    assert_eq!(call!(and_si64(2, 4)), 0);
-    assert_eq!(call!(and_si64(2, 5577148965131116544)), 0);
-    assert_eq!(call!(and_si64(3, -9223372036854775808)), 0);
-    assert_eq!(call!(and_si64(3, -1741927215160008704)), 0);
-    assert_eq!(call!(and_si64(3, -1328271339354574848)), 0);
-    assert_eq!(call!(and_si64(3, 0)), 0);
-    assert_eq!(call!(and_si64(3, 4)), 0);
-    assert_eq!(call!(and_si64(3, 5577148965131116544)), 0);
-    assert_eq!(call!(and_si64(4, -9223372036854775808)), 0);
-    assert_eq!(call!(and_si64(4, -9223372036854775807)), 0);
-    assert_eq!(call!(and_si64(4, -1741927215160008704)), 0);
-    assert_eq!(call!(and_si64(4, -1328271339354574848)), 0);
-    assert_eq!(call!(and_si64(4, 0)), 0);
-    assert_eq!(call!(and_si64(4, 1)), 0);
-    assert_eq!(call!(and_si64(4, 2)), 0);
-    assert_eq!(call!(and_si64(4, 3)), 0);
-    assert_eq!(call!(and_si64(4, 5577148965131116544)), 0);
-    assert_eq!(call!(and_si64(5577148965131116544, -9223372036854775808)), 0);
-    assert_eq!(call!(and_si64(5577148965131116544, -9223372036854775807)), 0);
-    assert_eq!(call!(and_si64(5577148965131116544, 0)), 0);
-    assert_eq!(call!(and_si64(5577148965131116544, 1)), 0);
-    assert_eq!(call!(and_si64(5577148965131116544, 2)), 0);
-    assert_eq!(call!(and_si64(5577148965131116544, 3)), 0);
-    assert_eq!(call!(and_si64(5577148965131116544, 4)), 0);
-    assert_eq!(call!(and_si64(9223372036854775806, -9223372036854775808)), 0);
-    assert_eq!(call!(and_si64(9223372036854775806, -9223372036854775807)), 0);
-    assert_eq!(call!(and_si64(9223372036854775806, 0)), 0);
-    assert_eq!(call!(and_si64(9223372036854775806, 1)), 0);
-    assert_eq!(call!(and_si64(9223372036854775807, -9223372036854775808)), 0);
-    assert_eq!(call!(and_si64(9223372036854775807, 0)), 0);
-    assert_eq!(call!(and_si64(-9223372036854775807, 1)), 1);
-    assert_eq!(call!(and_si64(-9223372036854775807, 3)), 1);
-    assert_eq!(call!(and_si64(-9223372036854775807, 9223372036854775807)), 1);
-    assert_eq!(call!(and_si64(1, -9223372036854775807)), 1);
-    assert_eq!(call!(and_si64(1, 1)), 1);
-    assert_eq!(call!(and_si64(1, 3)), 1);
-    assert_eq!(call!(and_si64(1, 9223372036854775807)), 1);
-    assert_eq!(call!(and_si64(3, -9223372036854775807)), 1);
-    assert_eq!(call!(and_si64(3, 1)), 1);
-    assert_eq!(call!(and_si64(9223372036854775807, -9223372036854775807)), 1);
-    assert_eq!(call!(and_si64(9223372036854775807, 1)), 1);
-    assert_eq!(call!(and_si64(2, 2)), 2);
-    assert_eq!(call!(and_si64(2, 3)), 2);
-    assert_eq!(call!(and_si64(2, 9223372036854775806)), 2);
-    assert_eq!(call!(and_si64(2, 9223372036854775807)), 2);
-    assert_eq!(call!(and_si64(3, 2)), 2);
-    assert_eq!(call!(and_si64(3, 9223372036854775806)), 2);
-    assert_eq!(call!(and_si64(9223372036854775806, 2)), 2);
-    assert_eq!(call!(and_si64(9223372036854775806, 3)), 2);
-    assert_eq!(call!(and_si64(9223372036854775807, 2)), 2);
-    assert_eq!(call!(and_si64(3, 3)), 3);
-    assert_eq!(call!(and_si64(3, 9223372036854775807)), 3);
-    assert_eq!(call!(and_si64(9223372036854775807, 3)), 3);
-    assert_eq!(call!(and_si64(4, 4)), 4);
-    assert_eq!(call!(and_si64(4, 9223372036854775806)), 4);
-    assert_eq!(call!(and_si64(4, 9223372036854775807)), 4);
-    assert_eq!(call!(and_si64(9223372036854775806, 4)), 4);
-    assert_eq!(call!(and_si64(9223372036854775807, 4)), 4);
-    assert_eq!(call!(and_si64(-1741927215160008704, 5577148965131116544)), 4990554005496225792);
-    assert_eq!(call!(and_si64(5577148965131116544, -1741927215160008704)), 4990554005496225792);
-    assert_eq!(call!(and_si64(-1328271339354574848, 5577148965131116544)), 5548435020295708672);
-    assert_eq!(call!(and_si64(5577148965131116544, -1328271339354574848)), 5548435020295708672);
-    assert_eq!(call!(and_si64(5577148965131116544, 5577148965131116544)), 5577148965131116544);
-    assert_eq!(call!(and_si64(5577148965131116544, 9223372036854775806)), 5577148965131116544);
-    assert_eq!(call!(and_si64(5577148965131116544, 9223372036854775807)), 5577148965131116544);
-    assert_eq!(call!(and_si64(9223372036854775806, 5577148965131116544)), 5577148965131116544);
-    assert_eq!(call!(and_si64(9223372036854775807, 5577148965131116544)), 5577148965131116544);
-    assert_eq!(call!(and_si64(-1741927215160008704, 9223372036854775806)), 7481444821694767104);
-    assert_eq!(call!(and_si64(-1741927215160008704, 9223372036854775807)), 7481444821694767104);
-    assert_eq!(call!(and_si64(9223372036854775806, -1741927215160008704)), 7481444821694767104);
-    assert_eq!(call!(and_si64(9223372036854775807, -1741927215160008704)), 7481444821694767104);
-    assert_eq!(call!(and_si64(-1328271339354574848, 9223372036854775806)), 7895100697500200960);
-    assert_eq!(call!(and_si64(-1328271339354574848, 9223372036854775807)), 7895100697500200960);
-    assert_eq!(call!(and_si64(9223372036854775806, -1328271339354574848)), 7895100697500200960);
-    assert_eq!(call!(and_si64(9223372036854775807, -1328271339354574848)), 7895100697500200960);
-    assert_eq!(call!(and_si64(9223372036854775806, 9223372036854775806)), 9223372036854775806);
-    assert_eq!(call!(and_si64(9223372036854775806, 9223372036854775807)), 9223372036854775806);
-    assert_eq!(call!(and_si64(9223372036854775807, 9223372036854775806)), 9223372036854775806);
-    assert_eq!(call!(and_si64(9223372036854775807, 9223372036854775807)), 9223372036854775807);
-    assert_eq!(call!(and_si8(-128, -128)), -128);
-    assert_eq!(call!(and_si8(-128, -127)), -128);
-    assert_eq!(call!(and_si8(-127, -128)), -128);
-    assert_eq!(call!(and_si8(-127, -127)), -127);
-    assert_eq!(call!(and_si8(-128, 0)), 0);
-    assert_eq!(call!(and_si8(-128, 1)), 0);
-    assert_eq!(call!(and_si8(-128, 2)), 0);
-    assert_eq!(call!(and_si8(-128, 3)), 0);
-    assert_eq!(call!(and_si8(-128, 4)), 0);
-    assert_eq!(call!(and_si8(-128, 16)), 0);
-    assert_eq!(call!(and_si8(-128, 126)), 0);
-    assert_eq!(call!(and_si8(-128, 127)), 0);
-    assert_eq!(call!(and_si8(-127, 0)), 0);
-    assert_eq!(call!(and_si8(-127, 2)), 0);
-    assert_eq!(call!(and_si8(-127, 4)), 0);
-    assert_eq!(call!(and_si8(-127, 16)), 0);
-    assert_eq!(call!(and_si8(-127, 126)), 0);
-    assert_eq!(call!(and_si8(0, -128)), 0);
-    assert_eq!(call!(and_si8(0, -127)), 0);
-    assert_eq!(call!(and_si8(0, 0)), 0);
-    assert_eq!(call!(and_si8(0, 1)), 0);
-    assert_eq!(call!(and_si8(0, 2)), 0);
-    assert_eq!(call!(and_si8(0, 3)), 0);
-    assert_eq!(call!(and_si8(0, 4)), 0);
-    assert_eq!(call!(and_si8(0, 16)), 0);
-    assert_eq!(call!(and_si8(0, 126)), 0);
-    assert_eq!(call!(and_si8(0, 127)), 0);
-    assert_eq!(call!(and_si8(1, -128)), 0);
-    assert_eq!(call!(and_si8(1, 0)), 0);
-    assert_eq!(call!(and_si8(1, 2)), 0);
-    assert_eq!(call!(and_si8(1, 4)), 0);
-    assert_eq!(call!(and_si8(1, 16)), 0);
-    assert_eq!(call!(and_si8(1, 126)), 0);
-    assert_eq!(call!(and_si8(2, -128)), 0);
-    assert_eq!(call!(and_si8(2, -127)), 0);
-    assert_eq!(call!(and_si8(2, 0)), 0);
-    assert_eq!(call!(and_si8(2, 1)), 0);
-    assert_eq!(call!(and_si8(2, 4)), 0);
-    assert_eq!(call!(and_si8(2, 16)), 0);
-    assert_eq!(call!(and_si8(3, -128)), 0);
-    assert_eq!(call!(and_si8(3, 0)), 0);
-    assert_eq!(call!(and_si8(3, 4)), 0);
-    assert_eq!(call!(and_si8(3, 16)), 0);
-    assert_eq!(call!(and_si8(4, -128)), 0);
-    assert_eq!(call!(and_si8(4, -127)), 0);
-    assert_eq!(call!(and_si8(4, 0)), 0);
-    assert_eq!(call!(and_si8(4, 1)), 0);
-    assert_eq!(call!(and_si8(4, 2)), 0);
-    assert_eq!(call!(and_si8(4, 3)), 0);
-    assert_eq!(call!(and_si8(4, 16)), 0);
-    assert_eq!(call!(and_si8(16, -128)), 0);
-    assert_eq!(call!(and_si8(16, -127)), 0);
-    assert_eq!(call!(and_si8(16, 0)), 0);
-    assert_eq!(call!(and_si8(16, 1)), 0);
-    assert_eq!(call!(and_si8(16, 2)), 0);
-    assert_eq!(call!(and_si8(16, 3)), 0);
-    assert_eq!(call!(and_si8(16, 4)), 0);
-    assert_eq!(call!(and_si8(126, -128)), 0);
-    assert_eq!(call!(and_si8(126, -127)), 0);
-    assert_eq!(call!(and_si8(126, 0)), 0);
-    assert_eq!(call!(and_si8(126, 1)), 0);
-    assert_eq!(call!(and_si8(127, -128)), 0);
-    assert_eq!(call!(and_si8(127, 0)), 0);
-    assert_eq!(call!(and_si8(-127, 1)), 1);
-    assert_eq!(call!(and_si8(-127, 3)), 1);
-    assert_eq!(call!(and_si8(-127, 127)), 1);
-    assert_eq!(call!(and_si8(1, -127)), 1);
-    assert_eq!(call!(and_si8(1, 1)), 1);
-    assert_eq!(call!(and_si8(1, 3)), 1);
-    assert_eq!(call!(and_si8(1, 127)), 1);
-    assert_eq!(call!(and_si8(3, -127)), 1);
-    assert_eq!(call!(and_si8(3, 1)), 1);
-    assert_eq!(call!(and_si8(127, -127)), 1);
-    assert_eq!(call!(and_si8(127, 1)), 1);
-    assert_eq!(call!(and_si8(2, 2)), 2);
-    assert_eq!(call!(and_si8(2, 3)), 2);
-    assert_eq!(call!(and_si8(2, 126)), 2);
-    assert_eq!(call!(and_si8(2, 127)), 2);
-    assert_eq!(call!(and_si8(3, 2)), 2);
-    assert_eq!(call!(and_si8(3, 126)), 2);
-    assert_eq!(call!(and_si8(126, 2)), 2);
-    assert_eq!(call!(and_si8(126, 3)), 2);
-    assert_eq!(call!(and_si8(127, 2)), 2);
-    assert_eq!(call!(and_si8(3, 3)), 3);
-    assert_eq!(call!(and_si8(3, 127)), 3);
-    assert_eq!(call!(and_si8(127, 3)), 3);
-    assert_eq!(call!(and_si8(4, 4)), 4);
-    assert_eq!(call!(and_si8(4, 126)), 4);
-    assert_eq!(call!(and_si8(4, 127)), 4);
-    assert_eq!(call!(and_si8(126, 4)), 4);
-    assert_eq!(call!(and_si8(127, 4)), 4);
-    assert_eq!(call!(and_si8(16, 16)), 16);
-    assert_eq!(call!(and_si8(16, 126)), 16);
-    assert_eq!(call!(and_si8(16, 127)), 16);
-    assert_eq!(call!(and_si8(126, 16)), 16);
-    assert_eq!(call!(and_si8(127, 16)), 16);
-    assert_eq!(call!(and_si8(126, 126)), 126);
-    assert_eq!(call!(and_si8(126, 127)), 126);
-    assert_eq!(call!(and_si8(127, 126)), 126);
-    assert_eq!(call!(and_si8(127, 127)), 127);
-    assert_eq!(call!(and_ui16(0, 0)), 0);
-    assert_eq!(call!(and_ui16(0, 1)), 0);
-    assert_eq!(call!(and_ui16(0, 2)), 0);
-    assert_eq!(call!(and_ui16(0, 3)), 0);
-    assert_eq!(call!(and_ui16(0, 4)), 0);
-    assert_eq!(call!(and_ui16(0, 1717)), 0);
-    assert_eq!(call!(and_ui16(0, 17988)), 0);
-    assert_eq!(call!(and_ui16(0, 65096)), 0);
-    assert_eq!(call!(and_ui16(0, 65534)), 0);
-    assert_eq!(call!(and_ui16(0, 65535)), 0);
-    assert_eq!(call!(and_ui16(1, 0)), 0);
-    assert_eq!(call!(and_ui16(1, 2)), 0);
-    assert_eq!(call!(and_ui16(1, 4)), 0);
-    assert_eq!(call!(and_ui16(1, 17988)), 0);
-    assert_eq!(call!(and_ui16(1, 65096)), 0);
-    assert_eq!(call!(and_ui16(1, 65534)), 0);
-    assert_eq!(call!(and_ui16(2, 0)), 0);
-    assert_eq!(call!(and_ui16(2, 1)), 0);
-    assert_eq!(call!(and_ui16(2, 4)), 0);
-    assert_eq!(call!(and_ui16(2, 1717)), 0);
-    assert_eq!(call!(and_ui16(2, 17988)), 0);
-    assert_eq!(call!(and_ui16(2, 65096)), 0);
-    assert_eq!(call!(and_ui16(3, 0)), 0);
-    assert_eq!(call!(and_ui16(3, 4)), 0);
-    assert_eq!(call!(and_ui16(3, 17988)), 0);
-    assert_eq!(call!(and_ui16(3, 65096)), 0);
-    assert_eq!(call!(and_ui16(4, 0)), 0);
-    assert_eq!(call!(and_ui16(4, 1)), 0);
-    assert_eq!(call!(and_ui16(4, 2)), 0);
-    assert_eq!(call!(and_ui16(4, 3)), 0);
-    assert_eq!(call!(and_ui16(4, 65096)), 0);
-    assert_eq!(call!(and_ui16(1717, 0)), 0);
-    assert_eq!(call!(and_ui16(1717, 2)), 0);
-    assert_eq!(call!(and_ui16(17988, 0)), 0);
-    assert_eq!(call!(and_ui16(17988, 1)), 0);
-    assert_eq!(call!(and_ui16(17988, 2)), 0);
-    assert_eq!(call!(and_ui16(17988, 3)), 0);
-    assert_eq!(call!(and_ui16(65096, 0)), 0);
-    assert_eq!(call!(and_ui16(65096, 1)), 0);
-    assert_eq!(call!(and_ui16(65096, 2)), 0);
-    assert_eq!(call!(and_ui16(65096, 3)), 0);
-    assert_eq!(call!(and_ui16(65096, 4)), 0);
-    assert_eq!(call!(and_ui16(65534, 0)), 0);
-    assert_eq!(call!(and_ui16(65534, 1)), 0);
-    assert_eq!(call!(and_ui16(65535, 0)), 0);
-    assert_eq!(call!(and_ui16(1, 1)), 1);
-    assert_eq!(call!(and_ui16(1, 3)), 1);
-    assert_eq!(call!(and_ui16(1, 1717)), 1);
-    assert_eq!(call!(and_ui16(1, 65535)), 1);
-    assert_eq!(call!(and_ui16(3, 1)), 1);
-    assert_eq!(call!(and_ui16(3, 1717)), 1);
-    assert_eq!(call!(and_ui16(1717, 1)), 1);
-    assert_eq!(call!(and_ui16(1717, 3)), 1);
-    assert_eq!(call!(and_ui16(65535, 1)), 1);
-    assert_eq!(call!(and_ui16(2, 2)), 2);
-    assert_eq!(call!(and_ui16(2, 3)), 2);
-    assert_eq!(call!(and_ui16(2, 65534)), 2);
-    assert_eq!(call!(and_ui16(2, 65535)), 2);
-    assert_eq!(call!(and_ui16(3, 2)), 2);
-    assert_eq!(call!(and_ui16(3, 65534)), 2);
-    assert_eq!(call!(and_ui16(65534, 2)), 2);
-    assert_eq!(call!(and_ui16(65534, 3)), 2);
-    assert_eq!(call!(and_ui16(65535, 2)), 2);
-    assert_eq!(call!(and_ui16(3, 3)), 3);
-    assert_eq!(call!(and_ui16(3, 65535)), 3);
-    assert_eq!(call!(and_ui16(65535, 3)), 3);
-    assert_eq!(call!(and_ui16(4, 4)), 4);
-    assert_eq!(call!(and_ui16(4, 1717)), 4);
-    assert_eq!(call!(and_ui16(4, 17988)), 4);
-    assert_eq!(call!(and_ui16(4, 65534)), 4);
-    assert_eq!(call!(and_ui16(4, 65535)), 4);
-    assert_eq!(call!(and_ui16(1717, 4)), 4);
-    assert_eq!(call!(and_ui16(17988, 4)), 4);
-    assert_eq!(call!(and_ui16(65534, 4)), 4);
-    assert_eq!(call!(and_ui16(65535, 4)), 4);
-    assert_eq!(call!(and_ui16(1717, 65096)), 1536);
-    assert_eq!(call!(and_ui16(65096, 1717)), 1536);
-    assert_eq!(call!(and_ui16(1717, 17988)), 1540);
-    assert_eq!(call!(and_ui16(17988, 1717)), 1540);
-    assert_eq!(call!(and_ui16(1717, 65534)), 1716);
-    assert_eq!(call!(and_ui16(65534, 1717)), 1716);
-    assert_eq!(call!(and_ui16(1717, 1717)), 1717);
-    assert_eq!(call!(and_ui16(1717, 65535)), 1717);
-    assert_eq!(call!(and_ui16(65535, 1717)), 1717);
-    assert_eq!(call!(and_ui16(17988, 65096)), 17984);
-    assert_eq!(call!(and_ui16(65096, 17988)), 17984);
-    assert_eq!(call!(and_ui16(17988, 17988)), 17988);
-    assert_eq!(call!(and_ui16(17988, 65534)), 17988);
-    assert_eq!(call!(and_ui16(17988, 65535)), 17988);
-    assert_eq!(call!(and_ui16(65534, 17988)), 17988);
-    assert_eq!(call!(and_ui16(65535, 17988)), 17988);
-    assert_eq!(call!(and_ui16(65096, 65096)), 65096);
-    assert_eq!(call!(and_ui16(65096, 65534)), 65096);
-    assert_eq!(call!(and_ui16(65096, 65535)), 65096);
-    assert_eq!(call!(and_ui16(65534, 65096)), 65096);
-    assert_eq!(call!(and_ui16(65535, 65096)), 65096);
-    assert_eq!(call!(and_ui16(65534, 65534)), 65534);
-    assert_eq!(call!(and_ui16(65534, 65535)), 65534);
-    assert_eq!(call!(and_ui16(65535, 65534)), 65534);
-    assert_eq!(call!(and_ui16(65535, 65535)), 65535);
-    assert_eq!(call!(and_ui32(0, 0)), 0);
-    assert_eq!(call!(and_ui32(0, 1)), 0);
-    assert_eq!(call!(and_ui32(0, 2)), 0);
-    assert_eq!(call!(and_ui32(0, 3)), 0);
-    assert_eq!(call!(and_ui32(0, 4)), 0);
-    assert_eq!(call!(and_ui32(0, 2119154652)), 0);
-    assert_eq!(call!(and_ui32(0, 3002788344)), 0);
-    assert_eq!(call!(and_ui32(0, 3482297128)), 0);
-    assert_eq!(call!(and_ui32(0, 4294967294)), 0);
-    assert_eq!(call!(and_ui32(0, 4294967295)), 0);
-    assert_eq!(call!(and_ui32(1, 0)), 0);
-    assert_eq!(call!(and_ui32(1, 2)), 0);
-    assert_eq!(call!(and_ui32(1, 4)), 0);
-    assert_eq!(call!(and_ui32(1, 2119154652)), 0);
-    assert_eq!(call!(and_ui32(1, 3002788344)), 0);
-    assert_eq!(call!(and_ui32(1, 3482297128)), 0);
-    assert_eq!(call!(and_ui32(1, 4294967294)), 0);
-    assert_eq!(call!(and_ui32(2, 0)), 0);
-    assert_eq!(call!(and_ui32(2, 1)), 0);
-    assert_eq!(call!(and_ui32(2, 4)), 0);
-    assert_eq!(call!(and_ui32(2, 2119154652)), 0);
-    assert_eq!(call!(and_ui32(2, 3002788344)), 0);
-    assert_eq!(call!(and_ui32(2, 3482297128)), 0);
-    assert_eq!(call!(and_ui32(3, 0)), 0);
-    assert_eq!(call!(and_ui32(3, 4)), 0);
-    assert_eq!(call!(and_ui32(3, 2119154652)), 0);
-    assert_eq!(call!(and_ui32(3, 3002788344)), 0);
-    assert_eq!(call!(and_ui32(3, 3482297128)), 0);
-    assert_eq!(call!(and_ui32(4, 0)), 0);
-    assert_eq!(call!(and_ui32(4, 1)), 0);
-    assert_eq!(call!(and_ui32(4, 2)), 0);
-    assert_eq!(call!(and_ui32(4, 3)), 0);
-    assert_eq!(call!(and_ui32(4, 3002788344)), 0);
-    assert_eq!(call!(and_ui32(4, 3482297128)), 0);
-    assert_eq!(call!(and_ui32(2119154652, 0)), 0);
-    assert_eq!(call!(and_ui32(2119154652, 1)), 0);
-    assert_eq!(call!(and_ui32(2119154652, 2)), 0);
-    assert_eq!(call!(and_ui32(2119154652, 3)), 0);
-    assert_eq!(call!(and_ui32(3002788344, 0)), 0);
-    assert_eq!(call!(and_ui32(3002788344, 1)), 0);
-    assert_eq!(call!(and_ui32(3002788344, 2)), 0);
-    assert_eq!(call!(and_ui32(3002788344, 3)), 0);
-    assert_eq!(call!(and_ui32(3002788344, 4)), 0);
-    assert_eq!(call!(and_ui32(3482297128, 0)), 0);
-    assert_eq!(call!(and_ui32(3482297128, 1)), 0);
-    assert_eq!(call!(and_ui32(3482297128, 2)), 0);
-    assert_eq!(call!(and_ui32(3482297128, 3)), 0);
-    assert_eq!(call!(and_ui32(3482297128, 4)), 0);
-    assert_eq!(call!(and_ui32(4294967294, 0)), 0);
-    assert_eq!(call!(and_ui32(4294967294, 1)), 0);
-    assert_eq!(call!(and_ui32(4294967295, 0)), 0);
-    assert_eq!(call!(and_ui32(1, 1)), 1);
-    assert_eq!(call!(and_ui32(1, 3)), 1);
-    assert_eq!(call!(and_ui32(1, 4294967295)), 1);
-    assert_eq!(call!(and_ui32(3, 1)), 1);
-    assert_eq!(call!(and_ui32(4294967295, 1)), 1);
-    assert_eq!(call!(and_ui32(2, 2)), 2);
-    assert_eq!(call!(and_ui32(2, 3)), 2);
-    assert_eq!(call!(and_ui32(2, 4294967294)), 2);
-    assert_eq!(call!(and_ui32(2, 4294967295)), 2);
-    assert_eq!(call!(and_ui32(3, 2)), 2);
-    assert_eq!(call!(and_ui32(3, 4294967294)), 2);
-    assert_eq!(call!(and_ui32(4294967294, 2)), 2);
-    assert_eq!(call!(and_ui32(4294967294, 3)), 2);
-    assert_eq!(call!(and_ui32(4294967295, 2)), 2);
-    assert_eq!(call!(and_ui32(3, 3)), 3);
-    assert_eq!(call!(and_ui32(3, 4294967295)), 3);
-    assert_eq!(call!(and_ui32(4294967295, 3)), 3);
-    assert_eq!(call!(and_ui32(4, 4)), 4);
-    assert_eq!(call!(and_ui32(4, 2119154652)), 4);
-    assert_eq!(call!(and_ui32(4, 4294967294)), 4);
-    assert_eq!(call!(and_ui32(4, 4294967295)), 4);
-    assert_eq!(call!(and_ui32(2119154652, 4)), 4);
-    assert_eq!(call!(and_ui32(4294967294, 4)), 4);
-    assert_eq!(call!(and_ui32(4294967295, 4)), 4);
-    assert_eq!(call!(and_ui32(2119154652, 3002788344)), 843753944);
-    assert_eq!(call!(and_ui32(3002788344, 2119154652)), 843753944);
-    assert_eq!(call!(and_ui32(2119154652, 3482297128)), 1309647624);
-    assert_eq!(call!(and_ui32(3482297128, 2119154652)), 1309647624);
-    assert_eq!(call!(and_ui32(2119154652, 2119154652)), 2119154652);
-    assert_eq!(call!(and_ui32(2119154652, 4294967294)), 2119154652);
-    assert_eq!(call!(and_ui32(2119154652, 4294967295)), 2119154652);
-    assert_eq!(call!(and_ui32(4294967294, 2119154652)), 2119154652);
-    assert_eq!(call!(and_ui32(4294967295, 2119154652)), 2119154652);
-    assert_eq!(call!(and_ui32(3002788344, 3482297128)), 2190123304);
-    assert_eq!(call!(and_ui32(3482297128, 3002788344)), 2190123304);
-    assert_eq!(call!(and_ui32(3002788344, 3002788344)), 3002788344);
-    assert_eq!(call!(and_ui32(3002788344, 4294967294)), 3002788344);
-    assert_eq!(call!(and_ui32(3002788344, 4294967295)), 3002788344);
-    assert_eq!(call!(and_ui32(4294967294, 3002788344)), 3002788344);
-    assert_eq!(call!(and_ui32(4294967295, 3002788344)), 3002788344);
-    assert_eq!(call!(and_ui32(3482297128, 3482297128)), 3482297128);
-    assert_eq!(call!(and_ui32(3482297128, 4294967294)), 3482297128);
-    assert_eq!(call!(and_ui32(3482297128, 4294967295)), 3482297128);
-    assert_eq!(call!(and_ui32(4294967294, 3482297128)), 3482297128);
-    assert_eq!(call!(and_ui32(4294967295, 3482297128)), 3482297128);
-    assert_eq!(call!(and_ui32(4294967294, 4294967294)), 4294967294);
-    assert_eq!(call!(and_ui32(4294967294, 4294967295)), 4294967294);
-    assert_eq!(call!(and_ui32(4294967295, 4294967294)), 4294967294);
-    assert_eq!(call!(and_ui32(4294967295, 4294967295)), 4294967295);
-    assert_eq!(call!(and_ui64(0, 0)), 0);
-    assert_eq!(call!(and_ui64(0, 1)), 0);
-    assert_eq!(call!(and_ui64(0, 2)), 0);
-    assert_eq!(call!(and_ui64(0, 3)), 0);
-    assert_eq!(call!(and_ui64(0, 4)), 0);
-    assert_eq!(call!(and_ui64(0, 191084152064409600)), 0);
-    assert_eq!(call!(and_ui64(0, 11015955194427482112)), 0);
-    assert_eq!(call!(and_ui64(0, 16990600415051759616)), 0);
-    assert_eq!(call!(and_ui64(0, 18446744073709551614)), 0);
-    assert_eq!(call!(and_ui64(0, 18446744073709551615)), 0);
-    assert_eq!(call!(and_ui64(1, 0)), 0);
-    assert_eq!(call!(and_ui64(1, 2)), 0);
-    assert_eq!(call!(and_ui64(1, 4)), 0);
-    assert_eq!(call!(and_ui64(1, 191084152064409600)), 0);
-    assert_eq!(call!(and_ui64(1, 11015955194427482112)), 0);
-    assert_eq!(call!(and_ui64(1, 16990600415051759616)), 0);
-    assert_eq!(call!(and_ui64(1, 18446744073709551614)), 0);
-    assert_eq!(call!(and_ui64(2, 0)), 0);
-    assert_eq!(call!(and_ui64(2, 1)), 0);
-    assert_eq!(call!(and_ui64(2, 4)), 0);
-    assert_eq!(call!(and_ui64(2, 191084152064409600)), 0);
-    assert_eq!(call!(and_ui64(2, 11015955194427482112)), 0);
-    assert_eq!(call!(and_ui64(2, 16990600415051759616)), 0);
-    assert_eq!(call!(and_ui64(3, 0)), 0);
-    assert_eq!(call!(and_ui64(3, 4)), 0);
-    assert_eq!(call!(and_ui64(3, 191084152064409600)), 0);
-    assert_eq!(call!(and_ui64(3, 11015955194427482112)), 0);
-    assert_eq!(call!(and_ui64(3, 16990600415051759616)), 0);
-    assert_eq!(call!(and_ui64(4, 0)), 0);
-    assert_eq!(call!(and_ui64(4, 1)), 0);
-    assert_eq!(call!(and_ui64(4, 2)), 0);
-    assert_eq!(call!(and_ui64(4, 3)), 0);
-    assert_eq!(call!(and_ui64(4, 191084152064409600)), 0);
-    assert_eq!(call!(and_ui64(4, 11015955194427482112)), 0);
-    assert_eq!(call!(and_ui64(4, 16990600415051759616)), 0);
-    assert_eq!(call!(and_ui64(191084152064409600, 0)), 0);
-    assert_eq!(call!(and_ui64(191084152064409600, 1)), 0);
-    assert_eq!(call!(and_ui64(191084152064409600, 2)), 0);
-    assert_eq!(call!(and_ui64(191084152064409600, 3)), 0);
-    assert_eq!(call!(and_ui64(191084152064409600, 4)), 0);
-    assert_eq!(call!(and_ui64(11015955194427482112, 0)), 0);
-    assert_eq!(call!(and_ui64(11015955194427482112, 1)), 0);
-    assert_eq!(call!(and_ui64(11015955194427482112, 2)), 0);
-    assert_eq!(call!(and_ui64(11015955194427482112, 3)), 0);
-    assert_eq!(call!(and_ui64(11015955194427482112, 4)), 0);
-    assert_eq!(call!(and_ui64(16990600415051759616, 0)), 0);
-    assert_eq!(call!(and_ui64(16990600415051759616, 1)), 0);
-    assert_eq!(call!(and_ui64(16990600415051759616, 2)), 0);
-    assert_eq!(call!(and_ui64(16990600415051759616, 3)), 0);
-    assert_eq!(call!(and_ui64(16990600415051759616, 4)), 0);
-    assert_eq!(call!(and_ui64(18446744073709551614, 0)), 0);
-    assert_eq!(call!(and_ui64(18446744073709551614, 1)), 0);
-    assert_eq!(call!(and_ui64(18446744073709551615, 0)), 0);
-    assert_eq!(call!(and_ui64(1, 1)), 1);
-    assert_eq!(call!(and_ui64(1, 3)), 1);
-    assert_eq!(call!(and_ui64(1, 18446744073709551615)), 1);
-    assert_eq!(call!(and_ui64(3, 1)), 1);
-    assert_eq!(call!(and_ui64(18446744073709551615, 1)), 1);
-    assert_eq!(call!(and_ui64(2, 2)), 2);
-    assert_eq!(call!(and_ui64(2, 3)), 2);
-    assert_eq!(call!(and_ui64(2, 18446744073709551614)), 2);
-    assert_eq!(call!(and_ui64(2, 18446744073709551615)), 2);
-    assert_eq!(call!(and_ui64(3, 2)), 2);
-    assert_eq!(call!(and_ui64(3, 18446744073709551614)), 2);
-    assert_eq!(call!(and_ui64(18446744073709551614, 2)), 2);
-    assert_eq!(call!(and_ui64(18446744073709551614, 3)), 2);
-    assert_eq!(call!(and_ui64(18446744073709551615, 2)), 2);
-    assert_eq!(call!(and_ui64(3, 3)), 3);
-    assert_eq!(call!(and_ui64(3, 18446744073709551615)), 3);
-    assert_eq!(call!(and_ui64(18446744073709551615, 3)), 3);
-    assert_eq!(call!(and_ui64(4, 4)), 4);
-    assert_eq!(call!(and_ui64(4, 18446744073709551614)), 4);
-    assert_eq!(call!(and_ui64(4, 18446744073709551615)), 4);
-    assert_eq!(call!(and_ui64(18446744073709551614, 4)), 4);
-    assert_eq!(call!(and_ui64(18446744073709551615, 4)), 4);
-    assert_eq!(call!(and_ui64(191084152064409600, 11015955194427482112)), 45185538445017088);
-    assert_eq!(call!(and_ui64(11015955194427482112, 191084152064409600)), 45185538445017088);
-    assert_eq!(call!(and_ui64(191084152064409600, 16990600415051759616)), 180878484934066176);
-    assert_eq!(call!(and_ui64(16990600415051759616, 191084152064409600)), 180878484934066176);
-    assert_eq!(call!(and_ui64(191084152064409600, 191084152064409600)), 191084152064409600);
-    assert_eq!(call!(and_ui64(191084152064409600, 18446744073709551614)), 191084152064409600);
-    assert_eq!(call!(and_ui64(191084152064409600, 18446744073709551615)), 191084152064409600);
-    assert_eq!(call!(and_ui64(18446744073709551614, 191084152064409600)), 191084152064409600);
-    assert_eq!(call!(and_ui64(18446744073709551615, 191084152064409600)), 191084152064409600);
-    assert_eq!(call!(and_ui64(11015955194427482112, 16990600415051759616)), 9854025527415799808);
-    assert_eq!(call!(and_ui64(16990600415051759616, 11015955194427482112)), 9854025527415799808);
-    assert_eq!(call!(and_ui64(11015955194427482112, 11015955194427482112)), 11015955194427482112);
-    assert_eq!(call!(and_ui64(11015955194427482112, 18446744073709551614)), 11015955194427482112);
-    assert_eq!(call!(and_ui64(11015955194427482112, 18446744073709551615)), 11015955194427482112);
-    assert_eq!(call!(and_ui64(18446744073709551614, 11015955194427482112)), 11015955194427482112);
-    assert_eq!(call!(and_ui64(18446744073709551615, 11015955194427482112)), 11015955194427482112);
-    assert_eq!(call!(and_ui64(16990600415051759616, 16990600415051759616)), 16990600415051759616);
-    assert_eq!(call!(and_ui64(16990600415051759616, 18446744073709551614)), 16990600415051759616);
-    assert_eq!(call!(and_ui64(16990600415051759616, 18446744073709551615)), 16990600415051759616);
-    assert_eq!(call!(and_ui64(18446744073709551614, 16990600415051759616)), 16990600415051759616);
-    assert_eq!(call!(and_ui64(18446744073709551615, 16990600415051759616)), 16990600415051759616);
-    assert_eq!(call!(and_ui64(18446744073709551614, 18446744073709551614)), 18446744073709551614);
-    assert_eq!(call!(and_ui64(18446744073709551614, 18446744073709551615)), 18446744073709551614);
-    assert_eq!(call!(and_ui64(18446744073709551615, 18446744073709551614)), 18446744073709551614);
-    assert_eq!(call!(and_ui64(18446744073709551615, 18446744073709551615)), 18446744073709551615);
-    assert_eq!(call!(and_ui8(0, 0)), 0);
-    assert_eq!(call!(and_ui8(0, 1)), 0);
-    assert_eq!(call!(and_ui8(0, 2)), 0);
-    assert_eq!(call!(and_ui8(0, 3)), 0);
-    assert_eq!(call!(and_ui8(0, 4)), 0);
-    assert_eq!(call!(and_ui8(0, 72)), 0);
-    assert_eq!(call!(and_ui8(0, 100)), 0);
-    assert_eq!(call!(and_ui8(0, 162)), 0);
-    assert_eq!(call!(and_ui8(0, 254)), 0);
-    assert_eq!(call!(and_ui8(0, 255)), 0);
-    assert_eq!(call!(and_ui8(1, 0)), 0);
-    assert_eq!(call!(and_ui8(1, 2)), 0);
-    assert_eq!(call!(and_ui8(1, 4)), 0);
-    assert_eq!(call!(and_ui8(1, 72)), 0);
-    assert_eq!(call!(and_ui8(1, 100)), 0);
-    assert_eq!(call!(and_ui8(1, 162)), 0);
-    assert_eq!(call!(and_ui8(1, 254)), 0);
-    assert_eq!(call!(and_ui8(2, 0)), 0);
-    assert_eq!(call!(and_ui8(2, 1)), 0);
-    assert_eq!(call!(and_ui8(2, 4)), 0);
-    assert_eq!(call!(and_ui8(2, 72)), 0);
-    assert_eq!(call!(and_ui8(2, 100)), 0);
-    assert_eq!(call!(and_ui8(3, 0)), 0);
-    assert_eq!(call!(and_ui8(3, 4)), 0);
-    assert_eq!(call!(and_ui8(3, 72)), 0);
-    assert_eq!(call!(and_ui8(3, 100)), 0);
-    assert_eq!(call!(and_ui8(4, 0)), 0);
-    assert_eq!(call!(and_ui8(4, 1)), 0);
-    assert_eq!(call!(and_ui8(4, 2)), 0);
-    assert_eq!(call!(and_ui8(4, 3)), 0);
-    assert_eq!(call!(and_ui8(4, 72)), 0);
-    assert_eq!(call!(and_ui8(4, 162)), 0);
-    assert_eq!(call!(and_ui8(72, 0)), 0);
-    assert_eq!(call!(and_ui8(72, 1)), 0);
-    assert_eq!(call!(and_ui8(72, 2)), 0);
-    assert_eq!(call!(and_ui8(72, 3)), 0);
-    assert_eq!(call!(and_ui8(72, 4)), 0);
-    assert_eq!(call!(and_ui8(72, 162)), 0);
-    assert_eq!(call!(and_ui8(100, 0)), 0);
-    assert_eq!(call!(and_ui8(100, 1)), 0);
-    assert_eq!(call!(and_ui8(100, 2)), 0);
-    assert_eq!(call!(and_ui8(100, 3)), 0);
-    assert_eq!(call!(and_ui8(162, 0)), 0);
-    assert_eq!(call!(and_ui8(162, 1)), 0);
-    assert_eq!(call!(and_ui8(162, 4)), 0);
-    assert_eq!(call!(and_ui8(162, 72)), 0);
-    assert_eq!(call!(and_ui8(254, 0)), 0);
-    assert_eq!(call!(and_ui8(254, 1)), 0);
-    assert_eq!(call!(and_ui8(255, 0)), 0);
-    assert_eq!(call!(and_ui8(1, 1)), 1);
-    assert_eq!(call!(and_ui8(1, 3)), 1);
-    assert_eq!(call!(and_ui8(1, 255)), 1);
-    assert_eq!(call!(and_ui8(3, 1)), 1);
-    assert_eq!(call!(and_ui8(255, 1)), 1);
-    assert_eq!(call!(and_ui8(2, 2)), 2);
-    assert_eq!(call!(and_ui8(2, 3)), 2);
-    assert_eq!(call!(and_ui8(2, 162)), 2);
-    assert_eq!(call!(and_ui8(2, 254)), 2);
-    assert_eq!(call!(and_ui8(2, 255)), 2);
-    assert_eq!(call!(and_ui8(3, 2)), 2);
-    assert_eq!(call!(and_ui8(3, 162)), 2);
-    assert_eq!(call!(and_ui8(3, 254)), 2);
-    assert_eq!(call!(and_ui8(162, 2)), 2);
-    assert_eq!(call!(and_ui8(162, 3)), 2);
-    assert_eq!(call!(and_ui8(254, 2)), 2);
-    assert_eq!(call!(and_ui8(254, 3)), 2);
-    assert_eq!(call!(and_ui8(255, 2)), 2);
-    assert_eq!(call!(and_ui8(3, 3)), 3);
-    assert_eq!(call!(and_ui8(3, 255)), 3);
-    assert_eq!(call!(and_ui8(255, 3)), 3);
-    assert_eq!(call!(and_ui8(4, 4)), 4);
-    assert_eq!(call!(and_ui8(4, 100)), 4);
-    assert_eq!(call!(and_ui8(4, 254)), 4);
-    assert_eq!(call!(and_ui8(4, 255)), 4);
-    assert_eq!(call!(and_ui8(100, 4)), 4);
-    assert_eq!(call!(and_ui8(254, 4)), 4);
-    assert_eq!(call!(and_ui8(255, 4)), 4);
-    assert_eq!(call!(and_ui8(100, 162)), 32);
-    assert_eq!(call!(and_ui8(162, 100)), 32);
-    assert_eq!(call!(and_ui8(72, 100)), 64);
-    assert_eq!(call!(and_ui8(100, 72)), 64);
-    assert_eq!(call!(and_ui8(72, 72)), 72);
-    assert_eq!(call!(and_ui8(72, 254)), 72);
-    assert_eq!(call!(and_ui8(72, 255)), 72);
-    assert_eq!(call!(and_ui8(254, 72)), 72);
-    assert_eq!(call!(and_ui8(255, 72)), 72);
-    assert_eq!(call!(and_ui8(100, 100)), 100);
-    assert_eq!(call!(and_ui8(100, 254)), 100);
-    assert_eq!(call!(and_ui8(100, 255)), 100);
-    assert_eq!(call!(and_ui8(254, 100)), 100);
-    assert_eq!(call!(and_ui8(255, 100)), 100);
-    assert_eq!(call!(and_ui8(162, 162)), 162);
-    assert_eq!(call!(and_ui8(162, 254)), 162);
-    assert_eq!(call!(and_ui8(162, 255)), 162);
-    assert_eq!(call!(and_ui8(254, 162)), 162);
-    assert_eq!(call!(and_ui8(255, 162)), 162);
-    assert_eq!(call!(and_ui8(254, 254)), 254);
-    assert_eq!(call!(and_ui8(254, 255)), 254);
-    assert_eq!(call!(and_ui8(255, 254)), 254);
-    assert_eq!(call!(and_ui8(255, 255)), 255);
-    assert_eq!(call!(or_si16(-32768, -32768)), -32768);
-    assert_eq!(call!(or_si16(-32768, 0)), -32768);
-    assert_eq!(call!(or_si16(0, -32768)), -32768);
-    assert_eq!(call!(or_si16(-32768, -32767)), -32767);
-    assert_eq!(call!(or_si16(-32768, 1)), -32767);
-    assert_eq!(call!(or_si16(-32767, -32768)), -32767);
-    assert_eq!(call!(or_si16(-32767, -32767)), -32767);
-    assert_eq!(call!(or_si16(-32767, 0)), -32767);
-    assert_eq!(call!(or_si16(-32767, 1)), -32767);
-    assert_eq!(call!(or_si16(0, -32767)), -32767);
-    assert_eq!(call!(or_si16(1, -32768)), -32767);
-    assert_eq!(call!(or_si16(1, -32767)), -32767);
-    assert_eq!(call!(or_si16(-32768, 2)), -32766);
-    assert_eq!(call!(or_si16(2, -32768)), -32766);
-    assert_eq!(call!(or_si16(-32768, 3)), -32765);
-    assert_eq!(call!(or_si16(-32767, 2)), -32765);
-    assert_eq!(call!(or_si16(-32767, 3)), -32765);
-    assert_eq!(call!(or_si16(2, -32767)), -32765);
-    assert_eq!(call!(or_si16(3, -32768)), -32765);
-    assert_eq!(call!(or_si16(3, -32767)), -32765);
-    assert_eq!(call!(or_si16(-32768, 4)), -32764);
-    assert_eq!(call!(or_si16(4, -32768)), -32764);
-    assert_eq!(call!(or_si16(-32767, 4)), -32763);
-    assert_eq!(call!(or_si16(4, -32767)), -32763);
-    assert_eq!(call!(or_si16(-32768, -32547)), -32547);
-    assert_eq!(call!(or_si16(-32767, -32547)), -32547);
-    assert_eq!(call!(or_si16(-32547, -32768)), -32547);
-    assert_eq!(call!(or_si16(-32547, -32767)), -32547);
-    assert_eq!(call!(or_si16(-32547, -32547)), -32547);
-    assert_eq!(call!(or_si16(-32547, 0)), -32547);
-    assert_eq!(call!(or_si16(-32547, 1)), -32547);
-    assert_eq!(call!(or_si16(-32547, 4)), -32547);
-    assert_eq!(call!(or_si16(0, -32547)), -32547);
-    assert_eq!(call!(or_si16(1, -32547)), -32547);
-    assert_eq!(call!(or_si16(4, -32547)), -32547);
-    assert_eq!(call!(or_si16(-32547, 2)), -32545);
-    assert_eq!(call!(or_si16(-32547, 3)), -32545);
-    assert_eq!(call!(or_si16(2, -32547)), -32545);
-    assert_eq!(call!(or_si16(3, -32547)), -32545);
-    assert_eq!(call!(or_si16(-32768, 10486)), -22282);
-    assert_eq!(call!(or_si16(10486, -32768)), -22282);
-    assert_eq!(call!(or_si16(-32767, 10486)), -22281);
-    assert_eq!(call!(or_si16(10486, -32767)), -22281);
-    assert_eq!(call!(or_si16(-32547, 10486)), -22273);
-    assert_eq!(call!(or_si16(10486, -32547)), -22273);
-    assert_eq!(call!(or_si16(-32768, 16514)), -16254);
-    assert_eq!(call!(or_si16(16514, -32768)), -16254);
-    assert_eq!(call!(or_si16(-32767, 16514)), -16253);
-    assert_eq!(call!(or_si16(16514, -32767)), -16253);
-    assert_eq!(call!(or_si16(-32547, 16514)), -16161);
-    assert_eq!(call!(or_si16(16514, -32547)), -16161);
-    assert_eq!(call!(or_si16(-32768, 32766)), -2);
-    assert_eq!(call!(or_si16(32766, -32768)), -2);
-    assert_eq!(call!(or_si16(-32768, 32767)), -1);
-    assert_eq!(call!(or_si16(-32767, 32766)), -1);
-    assert_eq!(call!(or_si16(-32767, 32767)), -1);
-    assert_eq!(call!(or_si16(-32547, 32766)), -1);
-    assert_eq!(call!(or_si16(-32547, 32767)), -1);
-    assert_eq!(call!(or_si16(32766, -32767)), -1);
-    assert_eq!(call!(or_si16(32766, -32547)), -1);
-    assert_eq!(call!(or_si16(32767, -32768)), -1);
-    assert_eq!(call!(or_si16(32767, -32767)), -1);
-    assert_eq!(call!(or_si16(32767, -32547)), -1);
-    assert_eq!(call!(or_si16(0, 0)), 0);
-    assert_eq!(call!(or_si16(0, 1)), 1);
-    assert_eq!(call!(or_si16(1, 0)), 1);
-    assert_eq!(call!(or_si16(1, 1)), 1);
-    assert_eq!(call!(or_si16(0, 2)), 2);
-    assert_eq!(call!(or_si16(2, 0)), 2);
-    assert_eq!(call!(or_si16(2, 2)), 2);
-    assert_eq!(call!(or_si16(0, 3)), 3);
-    assert_eq!(call!(or_si16(1, 2)), 3);
-    assert_eq!(call!(or_si16(1, 3)), 3);
-    assert_eq!(call!(or_si16(2, 1)), 3);
-    assert_eq!(call!(or_si16(2, 3)), 3);
-    assert_eq!(call!(or_si16(3, 0)), 3);
-    assert_eq!(call!(or_si16(3, 1)), 3);
-    assert_eq!(call!(or_si16(3, 2)), 3);
-    assert_eq!(call!(or_si16(3, 3)), 3);
-    assert_eq!(call!(or_si16(0, 4)), 4);
-    assert_eq!(call!(or_si16(4, 0)), 4);
-    assert_eq!(call!(or_si16(4, 4)), 4);
-    assert_eq!(call!(or_si16(1, 4)), 5);
-    assert_eq!(call!(or_si16(4, 1)), 5);
-    assert_eq!(call!(or_si16(2, 4)), 6);
-    assert_eq!(call!(or_si16(4, 2)), 6);
-    assert_eq!(call!(or_si16(3, 4)), 7);
-    assert_eq!(call!(or_si16(4, 3)), 7);
-    assert_eq!(call!(or_si16(0, 10486)), 10486);
-    assert_eq!(call!(or_si16(2, 10486)), 10486);
-    assert_eq!(call!(or_si16(4, 10486)), 10486);
-    assert_eq!(call!(or_si16(10486, 0)), 10486);
-    assert_eq!(call!(or_si16(10486, 2)), 10486);
-    assert_eq!(call!(or_si16(10486, 4)), 10486);
-    assert_eq!(call!(or_si16(10486, 10486)), 10486);
-    assert_eq!(call!(or_si16(1, 10486)), 10487);
-    assert_eq!(call!(or_si16(3, 10486)), 10487);
-    assert_eq!(call!(or_si16(10486, 1)), 10487);
-    assert_eq!(call!(or_si16(10486, 3)), 10487);
-    assert_eq!(call!(or_si16(0, 16514)), 16514);
-    assert_eq!(call!(or_si16(2, 16514)), 16514);
-    assert_eq!(call!(or_si16(16514, 0)), 16514);
-    assert_eq!(call!(or_si16(16514, 2)), 16514);
-    assert_eq!(call!(or_si16(16514, 16514)), 16514);
-    assert_eq!(call!(or_si16(1, 16514)), 16515);
-    assert_eq!(call!(or_si16(3, 16514)), 16515);
-    assert_eq!(call!(or_si16(16514, 1)), 16515);
-    assert_eq!(call!(or_si16(16514, 3)), 16515);
-    assert_eq!(call!(or_si16(4, 16514)), 16518);
-    assert_eq!(call!(or_si16(16514, 4)), 16518);
-    assert_eq!(call!(or_si16(10486, 16514)), 26870);
-    assert_eq!(call!(or_si16(16514, 10486)), 26870);
-    assert_eq!(call!(or_si16(0, 32766)), 32766);
-    assert_eq!(call!(or_si16(2, 32766)), 32766);
-    assert_eq!(call!(or_si16(4, 32766)), 32766);
-    assert_eq!(call!(or_si16(10486, 32766)), 32766);
-    assert_eq!(call!(or_si16(16514, 32766)), 32766);
-    assert_eq!(call!(or_si16(32766, 0)), 32766);
-    assert_eq!(call!(or_si16(32766, 2)), 32766);
-    assert_eq!(call!(or_si16(32766, 4)), 32766);
-    assert_eq!(call!(or_si16(32766, 10486)), 32766);
-    assert_eq!(call!(or_si16(32766, 16514)), 32766);
-    assert_eq!(call!(or_si16(32766, 32766)), 32766);
-    assert_eq!(call!(or_si16(0, 32767)), 32767);
-    assert_eq!(call!(or_si16(1, 32766)), 32767);
-    assert_eq!(call!(or_si16(1, 32767)), 32767);
-    assert_eq!(call!(or_si16(2, 32767)), 32767);
-    assert_eq!(call!(or_si16(3, 32766)), 32767);
-    assert_eq!(call!(or_si16(3, 32767)), 32767);
-    assert_eq!(call!(or_si16(4, 32767)), 32767);
-    assert_eq!(call!(or_si16(10486, 32767)), 32767);
-    assert_eq!(call!(or_si16(16514, 32767)), 32767);
-    assert_eq!(call!(or_si16(32766, 1)), 32767);
-    assert_eq!(call!(or_si16(32766, 3)), 32767);
-    assert_eq!(call!(or_si16(32766, 32767)), 32767);
-    assert_eq!(call!(or_si16(32767, 0)), 32767);
-    assert_eq!(call!(or_si16(32767, 1)), 32767);
-    assert_eq!(call!(or_si16(32767, 2)), 32767);
-    assert_eq!(call!(or_si16(32767, 3)), 32767);
-    assert_eq!(call!(or_si16(32767, 4)), 32767);
-    assert_eq!(call!(or_si16(32767, 10486)), 32767);
-    assert_eq!(call!(or_si16(32767, 16514)), 32767);
-    assert_eq!(call!(or_si16(32767, 32766)), 32767);
-    assert_eq!(call!(or_si16(32767, 32767)), 32767);
-    assert_eq!(call!(or_si32(-2147483648, -2147483648)), -2147483648);
-    assert_eq!(call!(or_si32(-2147483648, 0)), -2147483648);
-    assert_eq!(call!(or_si32(0, -2147483648)), -2147483648);
-    assert_eq!(call!(or_si32(-2147483648, -2147483647)), -2147483647);
-    assert_eq!(call!(or_si32(-2147483648, 1)), -2147483647);
-    assert_eq!(call!(or_si32(-2147483647, -2147483648)), -2147483647);
-    assert_eq!(call!(or_si32(-2147483647, -2147483647)), -2147483647);
-    assert_eq!(call!(or_si32(-2147483647, 0)), -2147483647);
-    assert_eq!(call!(or_si32(-2147483647, 1)), -2147483647);
-    assert_eq!(call!(or_si32(0, -2147483647)), -2147483647);
-    assert_eq!(call!(or_si32(1, -2147483648)), -2147483647);
-    assert_eq!(call!(or_si32(1, -2147483647)), -2147483647);
-    assert_eq!(call!(or_si32(-2147483648, 2)), -2147483646);
-    assert_eq!(call!(or_si32(2, -2147483648)), -2147483646);
-    assert_eq!(call!(or_si32(-2147483648, 3)), -2147483645);
-    assert_eq!(call!(or_si32(-2147483647, 2)), -2147483645);
-    assert_eq!(call!(or_si32(-2147483647, 3)), -2147483645);
-    assert_eq!(call!(or_si32(2, -2147483647)), -2147483645);
-    assert_eq!(call!(or_si32(3, -2147483648)), -2147483645);
-    assert_eq!(call!(or_si32(3, -2147483647)), -2147483645);
-    assert_eq!(call!(or_si32(-2147483648, 4)), -2147483644);
-    assert_eq!(call!(or_si32(4, -2147483648)), -2147483644);
-    assert_eq!(call!(or_si32(-2147483647, 4)), -2147483643);
-    assert_eq!(call!(or_si32(4, -2147483647)), -2147483643);
-    assert_eq!(call!(or_si32(-2147483648, -1713183800)), -1713183800);
-    assert_eq!(call!(or_si32(-1713183800, -2147483648)), -1713183800);
-    assert_eq!(call!(or_si32(-1713183800, -1713183800)), -1713183800);
-    assert_eq!(call!(or_si32(-1713183800, 0)), -1713183800);
-    assert_eq!(call!(or_si32(0, -1713183800)), -1713183800);
-    assert_eq!(call!(or_si32(-2147483647, -1713183800)), -1713183799);
-    assert_eq!(call!(or_si32(-1713183800, -2147483647)), -1713183799);
-    assert_eq!(call!(or_si32(-1713183800, 1)), -1713183799);
-    assert_eq!(call!(or_si32(1, -1713183800)), -1713183799);
-    assert_eq!(call!(or_si32(-1713183800, 2)), -1713183798);
-    assert_eq!(call!(or_si32(2, -1713183800)), -1713183798);
-    assert_eq!(call!(or_si32(-1713183800, 3)), -1713183797);
-    assert_eq!(call!(or_si32(3, -1713183800)), -1713183797);
-    assert_eq!(call!(or_si32(-1713183800, 4)), -1713183796);
-    assert_eq!(call!(or_si32(4, -1713183800)), -1713183796);
-    assert_eq!(call!(or_si32(-2147483648, -1252582164)), -1252582164);
-    assert_eq!(call!(or_si32(-1252582164, -2147483648)), -1252582164);
-    assert_eq!(call!(or_si32(-1252582164, -1252582164)), -1252582164);
-    assert_eq!(call!(or_si32(-1252582164, 0)), -1252582164);
-    assert_eq!(call!(or_si32(-1252582164, 4)), -1252582164);
-    assert_eq!(call!(or_si32(0, -1252582164)), -1252582164);
-    assert_eq!(call!(or_si32(4, -1252582164)), -1252582164);
-    assert_eq!(call!(or_si32(-2147483647, -1252582164)), -1252582163);
-    assert_eq!(call!(or_si32(-1252582164, -2147483647)), -1252582163);
-    assert_eq!(call!(or_si32(-1252582164, 1)), -1252582163);
-    assert_eq!(call!(or_si32(1, -1252582164)), -1252582163);
-    assert_eq!(call!(or_si32(-1252582164, 2)), -1252582162);
-    assert_eq!(call!(or_si32(2, -1252582164)), -1252582162);
-    assert_eq!(call!(or_si32(-1252582164, 3)), -1252582161);
-    assert_eq!(call!(or_si32(3, -1252582164)), -1252582161);
-    assert_eq!(call!(or_si32(-1713183800, -1252582164)), -1107820564);
-    assert_eq!(call!(or_si32(-1252582164, -1713183800)), -1107820564);
-    assert_eq!(call!(or_si32(-2147483648, -1035405763)), -1035405763);
-    assert_eq!(call!(or_si32(-2147483647, -1035405763)), -1035405763);
-    assert_eq!(call!(or_si32(-1035405763, -2147483648)), -1035405763);
-    assert_eq!(call!(or_si32(-1035405763, -2147483647)), -1035405763);
-    assert_eq!(call!(or_si32(-1035405763, -1035405763)), -1035405763);
-    assert_eq!(call!(or_si32(-1035405763, 0)), -1035405763);
-    assert_eq!(call!(or_si32(-1035405763, 1)), -1035405763);
-    assert_eq!(call!(or_si32(-1035405763, 4)), -1035405763);
-    assert_eq!(call!(or_si32(0, -1035405763)), -1035405763);
-    assert_eq!(call!(or_si32(1, -1035405763)), -1035405763);
-    assert_eq!(call!(or_si32(4, -1035405763)), -1035405763);
-    assert_eq!(call!(or_si32(-1035405763, 2)), -1035405761);
-    assert_eq!(call!(or_si32(-1035405763, 3)), -1035405761);
-    assert_eq!(call!(or_si32(2, -1035405763)), -1035405761);
-    assert_eq!(call!(or_si32(3, -1035405763)), -1035405761);
-    assert_eq!(call!(or_si32(-1713183800, -1035405763)), -605358083);
-    assert_eq!(call!(or_si32(-1035405763, -1713183800)), -605358083);
-    assert_eq!(call!(or_si32(-1252582164, -1035405763)), -144703747);
-    assert_eq!(call!(or_si32(-1035405763, -1252582164)), -144703747);
-    assert_eq!(call!(or_si32(-2147483648, 2147483646)), -2);
-    assert_eq!(call!(or_si32(-1713183800, 2147483646)), -2);
-    assert_eq!(call!(or_si32(-1252582164, 2147483646)), -2);
-    assert_eq!(call!(or_si32(2147483646, -2147483648)), -2);
-    assert_eq!(call!(or_si32(2147483646, -1713183800)), -2);
-    assert_eq!(call!(or_si32(2147483646, -1252582164)), -2);
-    assert_eq!(call!(or_si32(-2147483648, 2147483647)), -1);
-    assert_eq!(call!(or_si32(-2147483647, 2147483646)), -1);
-    assert_eq!(call!(or_si32(-2147483647, 2147483647)), -1);
-    assert_eq!(call!(or_si32(-1713183800, 2147483647)), -1);
-    assert_eq!(call!(or_si32(-1252582164, 2147483647)), -1);
-    assert_eq!(call!(or_si32(-1035405763, 2147483646)), -1);
-    assert_eq!(call!(or_si32(-1035405763, 2147483647)), -1);
-    assert_eq!(call!(or_si32(2147483646, -2147483647)), -1);
-    assert_eq!(call!(or_si32(2147483646, -1035405763)), -1);
-    assert_eq!(call!(or_si32(2147483647, -2147483648)), -1);
-    assert_eq!(call!(or_si32(2147483647, -2147483647)), -1);
-    assert_eq!(call!(or_si32(2147483647, -1713183800)), -1);
-    assert_eq!(call!(or_si32(2147483647, -1252582164)), -1);
-    assert_eq!(call!(or_si32(2147483647, -1035405763)), -1);
-    assert_eq!(call!(or_si32(0, 0)), 0);
-    assert_eq!(call!(or_si32(0, 1)), 1);
-    assert_eq!(call!(or_si32(1, 0)), 1);
-    assert_eq!(call!(or_si32(1, 1)), 1);
-    assert_eq!(call!(or_si32(0, 2)), 2);
-    assert_eq!(call!(or_si32(2, 0)), 2);
-    assert_eq!(call!(or_si32(2, 2)), 2);
-    assert_eq!(call!(or_si32(0, 3)), 3);
-    assert_eq!(call!(or_si32(1, 2)), 3);
-    assert_eq!(call!(or_si32(1, 3)), 3);
-    assert_eq!(call!(or_si32(2, 1)), 3);
-    assert_eq!(call!(or_si32(2, 3)), 3);
-    assert_eq!(call!(or_si32(3, 0)), 3);
-    assert_eq!(call!(or_si32(3, 1)), 3);
-    assert_eq!(call!(or_si32(3, 2)), 3);
-    assert_eq!(call!(or_si32(3, 3)), 3);
-    assert_eq!(call!(or_si32(0, 4)), 4);
-    assert_eq!(call!(or_si32(4, 0)), 4);
-    assert_eq!(call!(or_si32(4, 4)), 4);
-    assert_eq!(call!(or_si32(1, 4)), 5);
-    assert_eq!(call!(or_si32(4, 1)), 5);
-    assert_eq!(call!(or_si32(2, 4)), 6);
-    assert_eq!(call!(or_si32(4, 2)), 6);
-    assert_eq!(call!(or_si32(3, 4)), 7);
-    assert_eq!(call!(or_si32(4, 3)), 7);
-    assert_eq!(call!(or_si32(0, 2147483646)), 2147483646);
-    assert_eq!(call!(or_si32(2, 2147483646)), 2147483646);
-    assert_eq!(call!(or_si32(4, 2147483646)), 2147483646);
-    assert_eq!(call!(or_si32(2147483646, 0)), 2147483646);
-    assert_eq!(call!(or_si32(2147483646, 2)), 2147483646);
-    assert_eq!(call!(or_si32(2147483646, 4)), 2147483646);
-    assert_eq!(call!(or_si32(2147483646, 2147483646)), 2147483646);
-    assert_eq!(call!(or_si32(0, 2147483647)), 2147483647);
-    assert_eq!(call!(or_si32(1, 2147483646)), 2147483647);
-    assert_eq!(call!(or_si32(1, 2147483647)), 2147483647);
-    assert_eq!(call!(or_si32(2, 2147483647)), 2147483647);
-    assert_eq!(call!(or_si32(3, 2147483646)), 2147483647);
-    assert_eq!(call!(or_si32(3, 2147483647)), 2147483647);
-    assert_eq!(call!(or_si32(4, 2147483647)), 2147483647);
-    assert_eq!(call!(or_si32(2147483646, 1)), 2147483647);
-    assert_eq!(call!(or_si32(2147483646, 3)), 2147483647);
-    assert_eq!(call!(or_si32(2147483646, 2147483647)), 2147483647);
-    assert_eq!(call!(or_si32(2147483647, 0)), 2147483647);
-    assert_eq!(call!(or_si32(2147483647, 1)), 2147483647);
-    assert_eq!(call!(or_si32(2147483647, 2)), 2147483647);
-    assert_eq!(call!(or_si32(2147483647, 3)), 2147483647);
-    assert_eq!(call!(or_si32(2147483647, 4)), 2147483647);
-    assert_eq!(call!(or_si32(2147483647, 2147483646)), 2147483647);
-    assert_eq!(call!(or_si32(2147483647, 2147483647)), 2147483647);
-    assert_eq!(call!(or_si64(-9223372036854775808, -9223372036854775808)), -9223372036854775808);
-    assert_eq!(call!(or_si64(-9223372036854775808, 0)), -9223372036854775808);
-    assert_eq!(call!(or_si64(0, -9223372036854775808)), -9223372036854775808);
-    assert_eq!(call!(or_si64(-9223372036854775808, -9223372036854775807)), -9223372036854775807);
-    assert_eq!(call!(or_si64(-9223372036854775808, 1)), -9223372036854775807);
-    assert_eq!(call!(or_si64(-9223372036854775807, -9223372036854775808)), -9223372036854775807);
-    assert_eq!(call!(or_si64(-9223372036854775807, -9223372036854775807)), -9223372036854775807);
-    assert_eq!(call!(or_si64(-9223372036854775807, 0)), -9223372036854775807);
-    assert_eq!(call!(or_si64(-9223372036854775807, 1)), -9223372036854775807);
-    assert_eq!(call!(or_si64(0, -9223372036854775807)), -9223372036854775807);
-    assert_eq!(call!(or_si64(1, -9223372036854775808)), -9223372036854775807);
-    assert_eq!(call!(or_si64(1, -9223372036854775807)), -9223372036854775807);
-    assert_eq!(call!(or_si64(-9223372036854775808, 2)), -9223372036854775806);
-    assert_eq!(call!(or_si64(2, -9223372036854775808)), -9223372036854775806);
-    assert_eq!(call!(or_si64(-9223372036854775808, 3)), -9223372036854775805);
-    assert_eq!(call!(or_si64(-9223372036854775807, 2)), -9223372036854775805);
-    assert_eq!(call!(or_si64(-9223372036854775807, 3)), -9223372036854775805);
-    assert_eq!(call!(or_si64(2, -9223372036854775807)), -9223372036854775805);
-    assert_eq!(call!(or_si64(3, -9223372036854775808)), -9223372036854775805);
-    assert_eq!(call!(or_si64(3, -9223372036854775807)), -9223372036854775805);
-    assert_eq!(call!(or_si64(-9223372036854775808, 4)), -9223372036854775804);
-    assert_eq!(call!(or_si64(4, -9223372036854775808)), -9223372036854775804);
-    assert_eq!(call!(or_si64(-9223372036854775807, 4)), -9223372036854775803);
-    assert_eq!(call!(or_si64(4, -9223372036854775807)), -9223372036854775803);
-    assert_eq!(call!(or_si64(-9223372036854775808, 5577148965131116544)), -3646223071723659264);
-    assert_eq!(call!(or_si64(5577148965131116544, -9223372036854775808)), -3646223071723659264);
-    assert_eq!(call!(or_si64(-9223372036854775807, 5577148965131116544)), -3646223071723659263);
-    assert_eq!(call!(or_si64(5577148965131116544, -9223372036854775807)), -3646223071723659263);
-    assert_eq!(call!(or_si64(-9223372036854775808, -1741927215160008704)), -1741927215160008704);
-    assert_eq!(call!(or_si64(-1741927215160008704, -9223372036854775808)), -1741927215160008704);
-    assert_eq!(call!(or_si64(-1741927215160008704, -1741927215160008704)), -1741927215160008704);
-    assert_eq!(call!(or_si64(-1741927215160008704, 0)), -1741927215160008704);
-    assert_eq!(call!(or_si64(0, -1741927215160008704)), -1741927215160008704);
-    assert_eq!(call!(or_si64(-9223372036854775807, -1741927215160008704)), -1741927215160008703);
-    assert_eq!(call!(or_si64(-1741927215160008704, -9223372036854775807)), -1741927215160008703);
-    assert_eq!(call!(or_si64(-1741927215160008704, 1)), -1741927215160008703);
-    assert_eq!(call!(or_si64(1, -1741927215160008704)), -1741927215160008703);
-    assert_eq!(call!(or_si64(-1741927215160008704, 2)), -1741927215160008702);
-    assert_eq!(call!(or_si64(2, -1741927215160008704)), -1741927215160008702);
-    assert_eq!(call!(or_si64(-1741927215160008704, 3)), -1741927215160008701);
-    assert_eq!(call!(or_si64(3, -1741927215160008704)), -1741927215160008701);
-    assert_eq!(call!(or_si64(-1741927215160008704, 4)), -1741927215160008700);
-    assert_eq!(call!(or_si64(4, -1741927215160008704)), -1741927215160008700);
-    assert_eq!(call!(or_si64(-9223372036854775808, -1328271339354574848)), -1328271339354574848);
-    assert_eq!(call!(or_si64(-1328271339354574848, -9223372036854775808)), -1328271339354574848);
-    assert_eq!(call!(or_si64(-1328271339354574848, -1328271339354574848)), -1328271339354574848);
-    assert_eq!(call!(or_si64(-1328271339354574848, 0)), -1328271339354574848);
-    assert_eq!(call!(or_si64(0, -1328271339354574848)), -1328271339354574848);
-    assert_eq!(call!(or_si64(-9223372036854775807, -1328271339354574848)), -1328271339354574847);
-    assert_eq!(call!(or_si64(-1328271339354574848, -9223372036854775807)), -1328271339354574847);
-    assert_eq!(call!(or_si64(-1328271339354574848, 1)), -1328271339354574847);
-    assert_eq!(call!(or_si64(1, -1328271339354574848)), -1328271339354574847);
-    assert_eq!(call!(or_si64(-1328271339354574848, 2)), -1328271339354574846);
-    assert_eq!(call!(or_si64(2, -1328271339354574848)), -1328271339354574846);
-    assert_eq!(call!(or_si64(-1328271339354574848, 3)), -1328271339354574845);
-    assert_eq!(call!(or_si64(3, -1328271339354574848)), -1328271339354574845);
-    assert_eq!(call!(or_si64(-1328271339354574848, 4)), -1328271339354574844);
-    assert_eq!(call!(or_si64(4, -1328271339354574848)), -1328271339354574844);
-    assert_eq!(call!(or_si64(-1328271339354574848, 5577148965131116544)), -1299557394519166976);
-    assert_eq!(call!(or_si64(5577148965131116544, -1328271339354574848)), -1299557394519166976);
-    assert_eq!(call!(or_si64(-1741927215160008704, -1328271339354574848)), -1165466462517891072);
-    assert_eq!(call!(or_si64(-1328271339354574848, -1741927215160008704)), -1165466462517891072);
-    assert_eq!(call!(or_si64(-1741927215160008704, 5577148965131116544)), -1155332255525117952);
-    assert_eq!(call!(or_si64(5577148965131116544, -1741927215160008704)), -1155332255525117952);
-    assert_eq!(call!(or_si64(-9223372036854775808, 9223372036854775806)), -2);
-    assert_eq!(call!(or_si64(-1741927215160008704, 9223372036854775806)), -2);
-    assert_eq!(call!(or_si64(-1328271339354574848, 9223372036854775806)), -2);
-    assert_eq!(call!(or_si64(9223372036854775806, -9223372036854775808)), -2);
-    assert_eq!(call!(or_si64(9223372036854775806, -1741927215160008704)), -2);
-    assert_eq!(call!(or_si64(9223372036854775806, -1328271339354574848)), -2);
-    assert_eq!(call!(or_si64(-9223372036854775808, 9223372036854775807)), -1);
-    assert_eq!(call!(or_si64(-9223372036854775807, 9223372036854775806)), -1);
-    assert_eq!(call!(or_si64(-9223372036854775807, 9223372036854775807)), -1);
-    assert_eq!(call!(or_si64(-1741927215160008704, 9223372036854775807)), -1);
-    assert_eq!(call!(or_si64(-1328271339354574848, 9223372036854775807)), -1);
-    assert_eq!(call!(or_si64(9223372036854775806, -9223372036854775807)), -1);
-    assert_eq!(call!(or_si64(9223372036854775807, -9223372036854775808)), -1);
-    assert_eq!(call!(or_si64(9223372036854775807, -9223372036854775807)), -1);
-    assert_eq!(call!(or_si64(9223372036854775807, -1741927215160008704)), -1);
-    assert_eq!(call!(or_si64(9223372036854775807, -1328271339354574848)), -1);
-    assert_eq!(call!(or_si64(0, 0)), 0);
-    assert_eq!(call!(or_si64(0, 1)), 1);
-    assert_eq!(call!(or_si64(1, 0)), 1);
-    assert_eq!(call!(or_si64(1, 1)), 1);
-    assert_eq!(call!(or_si64(0, 2)), 2);
-    assert_eq!(call!(or_si64(2, 0)), 2);
-    assert_eq!(call!(or_si64(2, 2)), 2);
-    assert_eq!(call!(or_si64(0, 3)), 3);
-    assert_eq!(call!(or_si64(1, 2)), 3);
-    assert_eq!(call!(or_si64(1, 3)), 3);
-    assert_eq!(call!(or_si64(2, 1)), 3);
-    assert_eq!(call!(or_si64(2, 3)), 3);
-    assert_eq!(call!(or_si64(3, 0)), 3);
-    assert_eq!(call!(or_si64(3, 1)), 3);
-    assert_eq!(call!(or_si64(3, 2)), 3);
-    assert_eq!(call!(or_si64(3, 3)), 3);
-    assert_eq!(call!(or_si64(0, 4)), 4);
-    assert_eq!(call!(or_si64(4, 0)), 4);
-    assert_eq!(call!(or_si64(4, 4)), 4);
-    assert_eq!(call!(or_si64(1, 4)), 5);
-    assert_eq!(call!(or_si64(4, 1)), 5);
-    assert_eq!(call!(or_si64(2, 4)), 6);
-    assert_eq!(call!(or_si64(4, 2)), 6);
-    assert_eq!(call!(or_si64(3, 4)), 7);
-    assert_eq!(call!(or_si64(4, 3)), 7);
-    assert_eq!(call!(or_si64(0, 5577148965131116544)), 5577148965131116544);
-    assert_eq!(call!(or_si64(5577148965131116544, 0)), 5577148965131116544);
-    assert_eq!(call!(or_si64(5577148965131116544, 5577148965131116544)), 5577148965131116544);
-    assert_eq!(call!(or_si64(1, 5577148965131116544)), 5577148965131116545);
-    assert_eq!(call!(or_si64(5577148965131116544, 1)), 5577148965131116545);
-    assert_eq!(call!(or_si64(2, 5577148965131116544)), 5577148965131116546);
-    assert_eq!(call!(or_si64(5577148965131116544, 2)), 5577148965131116546);
-    assert_eq!(call!(or_si64(3, 5577148965131116544)), 5577148965131116547);
-    assert_eq!(call!(or_si64(5577148965131116544, 3)), 5577148965131116547);
-    assert_eq!(call!(or_si64(4, 5577148965131116544)), 5577148965131116548);
-    assert_eq!(call!(or_si64(5577148965131116544, 4)), 5577148965131116548);
-    assert_eq!(call!(or_si64(0, 9223372036854775806)), 9223372036854775806);
-    assert_eq!(call!(or_si64(2, 9223372036854775806)), 9223372036854775806);
-    assert_eq!(call!(or_si64(4, 9223372036854775806)), 9223372036854775806);
-    assert_eq!(call!(or_si64(5577148965131116544, 9223372036854775806)), 9223372036854775806);
-    assert_eq!(call!(or_si64(9223372036854775806, 0)), 9223372036854775806);
-    assert_eq!(call!(or_si64(9223372036854775806, 2)), 9223372036854775806);
-    assert_eq!(call!(or_si64(9223372036854775806, 4)), 9223372036854775806);
-    assert_eq!(call!(or_si64(9223372036854775806, 5577148965131116544)), 9223372036854775806);
-    assert_eq!(call!(or_si64(9223372036854775806, 9223372036854775806)), 9223372036854775806);
-    assert_eq!(call!(or_si64(0, 9223372036854775807)), 9223372036854775807);
-    assert_eq!(call!(or_si64(1, 9223372036854775806)), 9223372036854775807);
-    assert_eq!(call!(or_si64(1, 9223372036854775807)), 9223372036854775807);
-    assert_eq!(call!(or_si64(2, 9223372036854775807)), 9223372036854775807);
-    assert_eq!(call!(or_si64(3, 9223372036854775806)), 9223372036854775807);
-    assert_eq!(call!(or_si64(3, 9223372036854775807)), 9223372036854775807);
-    assert_eq!(call!(or_si64(4, 9223372036854775807)), 9223372036854775807);
-    assert_eq!(call!(or_si64(5577148965131116544, 9223372036854775807)), 9223372036854775807);
-    assert_eq!(call!(or_si64(9223372036854775806, 1)), 9223372036854775807);
-    assert_eq!(call!(or_si64(9223372036854775806, 3)), 9223372036854775807);
-    assert_eq!(call!(or_si64(9223372036854775806, 9223372036854775807)), 9223372036854775807);
-    assert_eq!(call!(or_si64(9223372036854775807, 0)), 9223372036854775807);
-    assert_eq!(call!(or_si64(9223372036854775807, 1)), 9223372036854775807);
-    assert_eq!(call!(or_si64(9223372036854775807, 2)), 9223372036854775807);
-    assert_eq!(call!(or_si64(9223372036854775807, 3)), 9223372036854775807);
-    assert_eq!(call!(or_si64(9223372036854775807, 4)), 9223372036854775807);
-    assert_eq!(call!(or_si64(9223372036854775807, 5577148965131116544)), 9223372036854775807);
-    assert_eq!(call!(or_si64(9223372036854775807, 9223372036854775806)), 9223372036854775807);
-    assert_eq!(call!(or_si64(9223372036854775807, 9223372036854775807)), 9223372036854775807);
-    assert_eq!(call!(or_si8(-128, -128)), -128);
-    assert_eq!(call!(or_si8(-128, 0)), -128);
-    assert_eq!(call!(or_si8(0, -128)), -128);
-    assert_eq!(call!(or_si8(-128, -127)), -127);
-    assert_eq!(call!(or_si8(-128, 1)), -127);
-    assert_eq!(call!(or_si8(-127, -128)), -127);
-    assert_eq!(call!(or_si8(-127, -127)), -127);
-    assert_eq!(call!(or_si8(-127, 0)), -127);
-    assert_eq!(call!(or_si8(-127, 1)), -127);
-    assert_eq!(call!(or_si8(0, -127)), -127);
-    assert_eq!(call!(or_si8(1, -128)), -127);
-    assert_eq!(call!(or_si8(1, -127)), -127);
-    assert_eq!(call!(or_si8(-128, 2)), -126);
-    assert_eq!(call!(or_si8(2, -128)), -126);
-    assert_eq!(call!(or_si8(-128, 3)), -125);
-    assert_eq!(call!(or_si8(-127, 2)), -125);
-    assert_eq!(call!(or_si8(-127, 3)), -125);
-    assert_eq!(call!(or_si8(2, -127)), -125);
-    assert_eq!(call!(or_si8(3, -128)), -125);
-    assert_eq!(call!(or_si8(3, -127)), -125);
-    assert_eq!(call!(or_si8(-128, 4)), -124);
-    assert_eq!(call!(or_si8(4, -128)), -124);
-    assert_eq!(call!(or_si8(-127, 4)), -123);
-    assert_eq!(call!(or_si8(4, -127)), -123);
-    assert_eq!(call!(or_si8(-128, 16)), -112);
-    assert_eq!(call!(or_si8(16, -128)), -112);
-    assert_eq!(call!(or_si8(-127, 16)), -111);
-    assert_eq!(call!(or_si8(16, -127)), -111);
-    assert_eq!(call!(or_si8(-128, 126)), -2);
-    assert_eq!(call!(or_si8(126, -128)), -2);
-    assert_eq!(call!(or_si8(-128, 127)), -1);
-    assert_eq!(call!(or_si8(-127, 126)), -1);
-    assert_eq!(call!(or_si8(-127, 127)), -1);
-    assert_eq!(call!(or_si8(126, -127)), -1);
-    assert_eq!(call!(or_si8(127, -128)), -1);
-    assert_eq!(call!(or_si8(127, -127)), -1);
-    assert_eq!(call!(or_si8(0, 0)), 0);
-    assert_eq!(call!(or_si8(0, 1)), 1);
-    assert_eq!(call!(or_si8(1, 0)), 1);
-    assert_eq!(call!(or_si8(1, 1)), 1);
-    assert_eq!(call!(or_si8(0, 2)), 2);
-    assert_eq!(call!(or_si8(2, 0)), 2);
-    assert_eq!(call!(or_si8(2, 2)), 2);
-    assert_eq!(call!(or_si8(0, 3)), 3);
-    assert_eq!(call!(or_si8(1, 2)), 3);
-    assert_eq!(call!(or_si8(1, 3)), 3);
-    assert_eq!(call!(or_si8(2, 1)), 3);
-    assert_eq!(call!(or_si8(2, 3)), 3);
-    assert_eq!(call!(or_si8(3, 0)), 3);
-    assert_eq!(call!(or_si8(3, 1)), 3);
-    assert_eq!(call!(or_si8(3, 2)), 3);
-    assert_eq!(call!(or_si8(3, 3)), 3);
-    assert_eq!(call!(or_si8(0, 4)), 4);
-    assert_eq!(call!(or_si8(4, 0)), 4);
-    assert_eq!(call!(or_si8(4, 4)), 4);
-    assert_eq!(call!(or_si8(1, 4)), 5);
-    assert_eq!(call!(or_si8(4, 1)), 5);
-    assert_eq!(call!(or_si8(2, 4)), 6);
-    assert_eq!(call!(or_si8(4, 2)), 6);
-    assert_eq!(call!(or_si8(3, 4)), 7);
-    assert_eq!(call!(or_si8(4, 3)), 7);
-    assert_eq!(call!(or_si8(0, 16)), 16);
-    assert_eq!(call!(or_si8(16, 0)), 16);
-    assert_eq!(call!(or_si8(16, 16)), 16);
-    assert_eq!(call!(or_si8(1, 16)), 17);
-    assert_eq!(call!(or_si8(16, 1)), 17);
-    assert_eq!(call!(or_si8(2, 16)), 18);
-    assert_eq!(call!(or_si8(16, 2)), 18);
-    assert_eq!(call!(or_si8(3, 16)), 19);
-    assert_eq!(call!(or_si8(16, 3)), 19);
-    assert_eq!(call!(or_si8(4, 16)), 20);
-    assert_eq!(call!(or_si8(16, 4)), 20);
-    assert_eq!(call!(or_si8(0, 126)), 126);
-    assert_eq!(call!(or_si8(2, 126)), 126);
-    assert_eq!(call!(or_si8(4, 126)), 126);
-    assert_eq!(call!(or_si8(16, 126)), 126);
-    assert_eq!(call!(or_si8(126, 0)), 126);
-    assert_eq!(call!(or_si8(126, 2)), 126);
-    assert_eq!(call!(or_si8(126, 4)), 126);
-    assert_eq!(call!(or_si8(126, 16)), 126);
-    assert_eq!(call!(or_si8(126, 126)), 126);
-    assert_eq!(call!(or_si8(0, 127)), 127);
-    assert_eq!(call!(or_si8(1, 126)), 127);
-    assert_eq!(call!(or_si8(1, 127)), 127);
-    assert_eq!(call!(or_si8(2, 127)), 127);
-    assert_eq!(call!(or_si8(3, 126)), 127);
-    assert_eq!(call!(or_si8(3, 127)), 127);
-    assert_eq!(call!(or_si8(4, 127)), 127);
-    assert_eq!(call!(or_si8(16, 127)), 127);
-    assert_eq!(call!(or_si8(126, 1)), 127);
-    assert_eq!(call!(or_si8(126, 3)), 127);
-    assert_eq!(call!(or_si8(126, 127)), 127);
-    assert_eq!(call!(or_si8(127, 0)), 127);
-    assert_eq!(call!(or_si8(127, 1)), 127);
-    assert_eq!(call!(or_si8(127, 2)), 127);
-    assert_eq!(call!(or_si8(127, 3)), 127);
-    assert_eq!(call!(or_si8(127, 4)), 127);
-    assert_eq!(call!(or_si8(127, 16)), 127);
-    assert_eq!(call!(or_si8(127, 126)), 127);
-    assert_eq!(call!(or_si8(127, 127)), 127);
-    assert_eq!(call!(or_ui16(0, 0)), 0);
-    assert_eq!(call!(or_ui16(0, 1)), 1);
-    assert_eq!(call!(or_ui16(1, 0)), 1);
-    assert_eq!(call!(or_ui16(1, 1)), 1);
-    assert_eq!(call!(or_ui16(0, 2)), 2);
-    assert_eq!(call!(or_ui16(2, 0)), 2);
-    assert_eq!(call!(or_ui16(2, 2)), 2);
-    assert_eq!(call!(or_ui16(0, 3)), 3);
-    assert_eq!(call!(or_ui16(1, 2)), 3);
-    assert_eq!(call!(or_ui16(1, 3)), 3);
-    assert_eq!(call!(or_ui16(2, 1)), 3);
-    assert_eq!(call!(or_ui16(2, 3)), 3);
-    assert_eq!(call!(or_ui16(3, 0)), 3);
-    assert_eq!(call!(or_ui16(3, 1)), 3);
-    assert_eq!(call!(or_ui16(3, 2)), 3);
-    assert_eq!(call!(or_ui16(3, 3)), 3);
-    assert_eq!(call!(or_ui16(0, 4)), 4);
-    assert_eq!(call!(or_ui16(4, 0)), 4);
-    assert_eq!(call!(or_ui16(4, 4)), 4);
-    assert_eq!(call!(or_ui16(1, 4)), 5);
-    assert_eq!(call!(or_ui16(4, 1)), 5);
-    assert_eq!(call!(or_ui16(2, 4)), 6);
-    assert_eq!(call!(or_ui16(4, 2)), 6);
-    assert_eq!(call!(or_ui16(3, 4)), 7);
-    assert_eq!(call!(or_ui16(4, 3)), 7);
-    assert_eq!(call!(or_ui16(0, 1717)), 1717);
-    assert_eq!(call!(or_ui16(1, 1717)), 1717);
-    assert_eq!(call!(or_ui16(4, 1717)), 1717);
-    assert_eq!(call!(or_ui16(1717, 0)), 1717);
-    assert_eq!(call!(or_ui16(1717, 1)), 1717);
-    assert_eq!(call!(or_ui16(1717, 4)), 1717);
-    assert_eq!(call!(or_ui16(1717, 1717)), 1717);
-    assert_eq!(call!(or_ui16(2, 1717)), 1719);
-    assert_eq!(call!(or_ui16(3, 1717)), 1719);
-    assert_eq!(call!(or_ui16(1717, 2)), 1719);
-    assert_eq!(call!(or_ui16(1717, 3)), 1719);
-    assert_eq!(call!(or_ui16(0, 17988)), 17988);
-    assert_eq!(call!(or_ui16(4, 17988)), 17988);
-    assert_eq!(call!(or_ui16(17988, 0)), 17988);
-    assert_eq!(call!(or_ui16(17988, 4)), 17988);
-    assert_eq!(call!(or_ui16(17988, 17988)), 17988);
-    assert_eq!(call!(or_ui16(1, 17988)), 17989);
-    assert_eq!(call!(or_ui16(17988, 1)), 17989);
-    assert_eq!(call!(or_ui16(2, 17988)), 17990);
-    assert_eq!(call!(or_ui16(17988, 2)), 17990);
-    assert_eq!(call!(or_ui16(3, 17988)), 17991);
-    assert_eq!(call!(or_ui16(17988, 3)), 17991);
-    assert_eq!(call!(or_ui16(1717, 17988)), 18165);
-    assert_eq!(call!(or_ui16(17988, 1717)), 18165);
-    assert_eq!(call!(or_ui16(0, 65096)), 65096);
-    assert_eq!(call!(or_ui16(65096, 0)), 65096);
-    assert_eq!(call!(or_ui16(65096, 65096)), 65096);
-    assert_eq!(call!(or_ui16(1, 65096)), 65097);
-    assert_eq!(call!(or_ui16(65096, 1)), 65097);
-    assert_eq!(call!(or_ui16(2, 65096)), 65098);
-    assert_eq!(call!(or_ui16(65096, 2)), 65098);
-    assert_eq!(call!(or_ui16(3, 65096)), 65099);
-    assert_eq!(call!(or_ui16(65096, 3)), 65099);
-    assert_eq!(call!(or_ui16(4, 65096)), 65100);
-    assert_eq!(call!(or_ui16(17988, 65096)), 65100);
-    assert_eq!(call!(or_ui16(65096, 4)), 65100);
-    assert_eq!(call!(or_ui16(65096, 17988)), 65100);
-    assert_eq!(call!(or_ui16(1717, 65096)), 65277);
-    assert_eq!(call!(or_ui16(65096, 1717)), 65277);
-    assert_eq!(call!(or_ui16(0, 65534)), 65534);
-    assert_eq!(call!(or_ui16(2, 65534)), 65534);
-    assert_eq!(call!(or_ui16(4, 65534)), 65534);
-    assert_eq!(call!(or_ui16(17988, 65534)), 65534);
-    assert_eq!(call!(or_ui16(65096, 65534)), 65534);
-    assert_eq!(call!(or_ui16(65534, 0)), 65534);
-    assert_eq!(call!(or_ui16(65534, 2)), 65534);
-    assert_eq!(call!(or_ui16(65534, 4)), 65534);
-    assert_eq!(call!(or_ui16(65534, 17988)), 65534);
-    assert_eq!(call!(or_ui16(65534, 65096)), 65534);
-    assert_eq!(call!(or_ui16(65534, 65534)), 65534);
-    assert_eq!(call!(or_ui16(0, 65535)), 65535);
-    assert_eq!(call!(or_ui16(1, 65534)), 65535);
-    assert_eq!(call!(or_ui16(1, 65535)), 65535);
-    assert_eq!(call!(or_ui16(2, 65535)), 65535);
-    assert_eq!(call!(or_ui16(3, 65534)), 65535);
-    assert_eq!(call!(or_ui16(3, 65535)), 65535);
-    assert_eq!(call!(or_ui16(4, 65535)), 65535);
-    assert_eq!(call!(or_ui16(1717, 65534)), 65535);
-    assert_eq!(call!(or_ui16(1717, 65535)), 65535);
-    assert_eq!(call!(or_ui16(17988, 65535)), 65535);
-    assert_eq!(call!(or_ui16(65096, 65535)), 65535);
-    assert_eq!(call!(or_ui16(65534, 1)), 65535);
-    assert_eq!(call!(or_ui16(65534, 3)), 65535);
-    assert_eq!(call!(or_ui16(65534, 1717)), 65535);
-    assert_eq!(call!(or_ui16(65534, 65535)), 65535);
-    assert_eq!(call!(or_ui16(65535, 0)), 65535);
-    assert_eq!(call!(or_ui16(65535, 1)), 65535);
-    assert_eq!(call!(or_ui16(65535, 2)), 65535);
-    assert_eq!(call!(or_ui16(65535, 3)), 65535);
-    assert_eq!(call!(or_ui16(65535, 4)), 65535);
-    assert_eq!(call!(or_ui16(65535, 1717)), 65535);
-    assert_eq!(call!(or_ui16(65535, 17988)), 65535);
-    assert_eq!(call!(or_ui16(65535, 65096)), 65535);
-    assert_eq!(call!(or_ui16(65535, 65534)), 65535);
-    assert_eq!(call!(or_ui16(65535, 65535)), 65535);
-    assert_eq!(call!(or_ui32(0, 0)), 0);
-    assert_eq!(call!(or_ui32(0, 1)), 1);
-    assert_eq!(call!(or_ui32(1, 0)), 1);
-    assert_eq!(call!(or_ui32(1, 1)), 1);
-    assert_eq!(call!(or_ui32(0, 2)), 2);
-    assert_eq!(call!(or_ui32(2, 0)), 2);
-    assert_eq!(call!(or_ui32(2, 2)), 2);
-    assert_eq!(call!(or_ui32(0, 3)), 3);
-    assert_eq!(call!(or_ui32(1, 2)), 3);
-    assert_eq!(call!(or_ui32(1, 3)), 3);
-    assert_eq!(call!(or_ui32(2, 1)), 3);
-    assert_eq!(call!(or_ui32(2, 3)), 3);
-    assert_eq!(call!(or_ui32(3, 0)), 3);
-    assert_eq!(call!(or_ui32(3, 1)), 3);
-    assert_eq!(call!(or_ui32(3, 2)), 3);
-    assert_eq!(call!(or_ui32(3, 3)), 3);
-    assert_eq!(call!(or_ui32(0, 4)), 4);
-    assert_eq!(call!(or_ui32(4, 0)), 4);
-    assert_eq!(call!(or_ui32(4, 4)), 4);
-    assert_eq!(call!(or_ui32(1, 4)), 5);
-    assert_eq!(call!(or_ui32(4, 1)), 5);
-    assert_eq!(call!(or_ui32(2, 4)), 6);
-    assert_eq!(call!(or_ui32(4, 2)), 6);
-    assert_eq!(call!(or_ui32(3, 4)), 7);
-    assert_eq!(call!(or_ui32(4, 3)), 7);
-    assert_eq!(call!(or_ui32(0, 2119154652)), 2119154652);
-    assert_eq!(call!(or_ui32(4, 2119154652)), 2119154652);
-    assert_eq!(call!(or_ui32(2119154652, 0)), 2119154652);
-    assert_eq!(call!(or_ui32(2119154652, 4)), 2119154652);
-    assert_eq!(call!(or_ui32(2119154652, 2119154652)), 2119154652);
-    assert_eq!(call!(or_ui32(1, 2119154652)), 2119154653);
-    assert_eq!(call!(or_ui32(2119154652, 1)), 2119154653);
-    assert_eq!(call!(or_ui32(2, 2119154652)), 2119154654);
-    assert_eq!(call!(or_ui32(2119154652, 2)), 2119154654);
-    assert_eq!(call!(or_ui32(3, 2119154652)), 2119154655);
-    assert_eq!(call!(or_ui32(2119154652, 3)), 2119154655);
-    assert_eq!(call!(or_ui32(0, 3002788344)), 3002788344);
-    assert_eq!(call!(or_ui32(3002788344, 0)), 3002788344);
-    assert_eq!(call!(or_ui32(3002788344, 3002788344)), 3002788344);
-    assert_eq!(call!(or_ui32(1, 3002788344)), 3002788345);
-    assert_eq!(call!(or_ui32(3002788344, 1)), 3002788345);
-    assert_eq!(call!(or_ui32(2, 3002788344)), 3002788346);
-    assert_eq!(call!(or_ui32(3002788344, 2)), 3002788346);
-    assert_eq!(call!(or_ui32(3, 3002788344)), 3002788347);
-    assert_eq!(call!(or_ui32(3002788344, 3)), 3002788347);
-    assert_eq!(call!(or_ui32(4, 3002788344)), 3002788348);
-    assert_eq!(call!(or_ui32(3002788344, 4)), 3002788348);
-    assert_eq!(call!(or_ui32(0, 3482297128)), 3482297128);
-    assert_eq!(call!(or_ui32(3482297128, 0)), 3482297128);
-    assert_eq!(call!(or_ui32(3482297128, 3482297128)), 3482297128);
-    assert_eq!(call!(or_ui32(1, 3482297128)), 3482297129);
-    assert_eq!(call!(or_ui32(3482297128, 1)), 3482297129);
-    assert_eq!(call!(or_ui32(2, 3482297128)), 3482297130);
-    assert_eq!(call!(or_ui32(3482297128, 2)), 3482297130);
-    assert_eq!(call!(or_ui32(3, 3482297128)), 3482297131);
-    assert_eq!(call!(or_ui32(3482297128, 3)), 3482297131);
-    assert_eq!(call!(or_ui32(4, 3482297128)), 3482297132);
-    assert_eq!(call!(or_ui32(3482297128, 4)), 3482297132);
-    assert_eq!(call!(or_ui32(2119154652, 3002788344)), 4278189052);
-    assert_eq!(call!(or_ui32(3002788344, 2119154652)), 4278189052);
-    assert_eq!(call!(or_ui32(2119154652, 3482297128)), 4291804156);
-    assert_eq!(call!(or_ui32(3482297128, 2119154652)), 4291804156);
-    assert_eq!(call!(or_ui32(3002788344, 3482297128)), 4294962168);
-    assert_eq!(call!(or_ui32(3482297128, 3002788344)), 4294962168);
-    assert_eq!(call!(or_ui32(0, 4294967294)), 4294967294);
-    assert_eq!(call!(or_ui32(2, 4294967294)), 4294967294);
-    assert_eq!(call!(or_ui32(4, 4294967294)), 4294967294);
-    assert_eq!(call!(or_ui32(2119154652, 4294967294)), 4294967294);
-    assert_eq!(call!(or_ui32(3002788344, 4294967294)), 4294967294);
-    assert_eq!(call!(or_ui32(3482297128, 4294967294)), 4294967294);
-    assert_eq!(call!(or_ui32(4294967294, 0)), 4294967294);
-    assert_eq!(call!(or_ui32(4294967294, 2)), 4294967294);
-    assert_eq!(call!(or_ui32(4294967294, 4)), 4294967294);
-    assert_eq!(call!(or_ui32(4294967294, 2119154652)), 4294967294);
-    assert_eq!(call!(or_ui32(4294967294, 3002788344)), 4294967294);
-    assert_eq!(call!(or_ui32(4294967294, 3482297128)), 4294967294);
-    assert_eq!(call!(or_ui32(4294967294, 4294967294)), 4294967294);
-    assert_eq!(call!(or_ui32(0, 4294967295)), 4294967295);
-    assert_eq!(call!(or_ui32(1, 4294967294)), 4294967295);
-    assert_eq!(call!(or_ui32(1, 4294967295)), 4294967295);
-    assert_eq!(call!(or_ui32(2, 4294967295)), 4294967295);
-    assert_eq!(call!(or_ui32(3, 4294967294)), 4294967295);
-    assert_eq!(call!(or_ui32(3, 4294967295)), 4294967295);
-    assert_eq!(call!(or_ui32(4, 4294967295)), 4294967295);
-    assert_eq!(call!(or_ui32(2119154652, 4294967295)), 4294967295);
-    assert_eq!(call!(or_ui32(3002788344, 4294967295)), 4294967295);
-    assert_eq!(call!(or_ui32(3482297128, 4294967295)), 4294967295);
-    assert_eq!(call!(or_ui32(4294967294, 1)), 4294967295);
-    assert_eq!(call!(or_ui32(4294967294, 3)), 4294967295);
-    assert_eq!(call!(or_ui32(4294967294, 4294967295)), 4294967295);
-    assert_eq!(call!(or_ui32(4294967295, 0)), 4294967295);
-    assert_eq!(call!(or_ui32(4294967295, 1)), 4294967295);
-    assert_eq!(call!(or_ui32(4294967295, 2)), 4294967295);
-    assert_eq!(call!(or_ui32(4294967295, 3)), 4294967295);
-    assert_eq!(call!(or_ui32(4294967295, 4)), 4294967295);
-    assert_eq!(call!(or_ui32(4294967295, 2119154652)), 4294967295);
-    assert_eq!(call!(or_ui32(4294967295, 3002788344)), 4294967295);
-    assert_eq!(call!(or_ui32(4294967295, 3482297128)), 4294967295);
-    assert_eq!(call!(or_ui32(4294967295, 4294967294)), 4294967295);
-    assert_eq!(call!(or_ui32(4294967295, 4294967295)), 4294967295);
-    assert_eq!(call!(or_ui64(0, 0)), 0);
-    assert_eq!(call!(or_ui64(0, 1)), 1);
-    assert_eq!(call!(or_ui64(1, 0)), 1);
-    assert_eq!(call!(or_ui64(1, 1)), 1);
-    assert_eq!(call!(or_ui64(0, 2)), 2);
-    assert_eq!(call!(or_ui64(2, 0)), 2);
-    assert_eq!(call!(or_ui64(2, 2)), 2);
-    assert_eq!(call!(or_ui64(0, 3)), 3);
-    assert_eq!(call!(or_ui64(1, 2)), 3);
-    assert_eq!(call!(or_ui64(1, 3)), 3);
-    assert_eq!(call!(or_ui64(2, 1)), 3);
-    assert_eq!(call!(or_ui64(2, 3)), 3);
-    assert_eq!(call!(or_ui64(3, 0)), 3);
-    assert_eq!(call!(or_ui64(3, 1)), 3);
-    assert_eq!(call!(or_ui64(3, 2)), 3);
-    assert_eq!(call!(or_ui64(3, 3)), 3);
-    assert_eq!(call!(or_ui64(0, 4)), 4);
-    assert_eq!(call!(or_ui64(4, 0)), 4);
-    assert_eq!(call!(or_ui64(4, 4)), 4);
-    assert_eq!(call!(or_ui64(1, 4)), 5);
-    assert_eq!(call!(or_ui64(4, 1)), 5);
-    assert_eq!(call!(or_ui64(2, 4)), 6);
-    assert_eq!(call!(or_ui64(4, 2)), 6);
-    assert_eq!(call!(or_ui64(3, 4)), 7);
-    assert_eq!(call!(or_ui64(4, 3)), 7);
-    assert_eq!(call!(or_ui64(0, 191084152064409600)), 191084152064409600);
-    assert_eq!(call!(or_ui64(191084152064409600, 0)), 191084152064409600);
-    assert_eq!(call!(or_ui64(191084152064409600, 191084152064409600)), 191084152064409600);
-    assert_eq!(call!(or_ui64(1, 191084152064409600)), 191084152064409601);
-    assert_eq!(call!(or_ui64(191084152064409600, 1)), 191084152064409601);
-    assert_eq!(call!(or_ui64(2, 191084152064409600)), 191084152064409602);
-    assert_eq!(call!(or_ui64(191084152064409600, 2)), 191084152064409602);
-    assert_eq!(call!(or_ui64(3, 191084152064409600)), 191084152064409603);
-    assert_eq!(call!(or_ui64(191084152064409600, 3)), 191084152064409603);
-    assert_eq!(call!(or_ui64(4, 191084152064409600)), 191084152064409604);
-    assert_eq!(call!(or_ui64(191084152064409600, 4)), 191084152064409604);
-    assert_eq!(call!(or_ui64(0, 11015955194427482112)), 11015955194427482112);
-    assert_eq!(call!(or_ui64(11015955194427482112, 0)), 11015955194427482112);
-    assert_eq!(call!(or_ui64(11015955194427482112, 11015955194427482112)), 11015955194427482112);
-    assert_eq!(call!(or_ui64(1, 11015955194427482112)), 11015955194427482113);
-    assert_eq!(call!(or_ui64(11015955194427482112, 1)), 11015955194427482113);
-    assert_eq!(call!(or_ui64(2, 11015955194427482112)), 11015955194427482114);
-    assert_eq!(call!(or_ui64(11015955194427482112, 2)), 11015955194427482114);
-    assert_eq!(call!(or_ui64(3, 11015955194427482112)), 11015955194427482115);
-    assert_eq!(call!(or_ui64(11015955194427482112, 3)), 11015955194427482115);
-    assert_eq!(call!(or_ui64(4, 11015955194427482112)), 11015955194427482116);
-    assert_eq!(call!(or_ui64(11015955194427482112, 4)), 11015955194427482116);
-    assert_eq!(call!(or_ui64(191084152064409600, 11015955194427482112)), 11161853808046874624);
-    assert_eq!(call!(or_ui64(11015955194427482112, 191084152064409600)), 11161853808046874624);
-    assert_eq!(call!(or_ui64(0, 16990600415051759616)), 16990600415051759616);
-    assert_eq!(call!(or_ui64(16990600415051759616, 0)), 16990600415051759616);
-    assert_eq!(call!(or_ui64(16990600415051759616, 16990600415051759616)), 16990600415051759616);
-    assert_eq!(call!(or_ui64(1, 16990600415051759616)), 16990600415051759617);
-    assert_eq!(call!(or_ui64(16990600415051759616, 1)), 16990600415051759617);
-    assert_eq!(call!(or_ui64(2, 16990600415051759616)), 16990600415051759618);
-    assert_eq!(call!(or_ui64(16990600415051759616, 2)), 16990600415051759618);
-    assert_eq!(call!(or_ui64(3, 16990600415051759616)), 16990600415051759619);
-    assert_eq!(call!(or_ui64(16990600415051759616, 3)), 16990600415051759619);
-    assert_eq!(call!(or_ui64(4, 16990600415051759616)), 16990600415051759620);
-    assert_eq!(call!(or_ui64(16990600415051759616, 4)), 16990600415051759620);
-    assert_eq!(call!(or_ui64(191084152064409600, 16990600415051759616)), 17000806082182103040);
-    assert_eq!(call!(or_ui64(16990600415051759616, 191084152064409600)), 17000806082182103040);
-    assert_eq!(call!(or_ui64(11015955194427482112, 16990600415051759616)), 18152530082063441920);
-    assert_eq!(call!(or_ui64(16990600415051759616, 11015955194427482112)), 18152530082063441920);
-    assert_eq!(call!(or_ui64(0, 18446744073709551614)), 18446744073709551614);
-    assert_eq!(call!(or_ui64(2, 18446744073709551614)), 18446744073709551614);
-    assert_eq!(call!(or_ui64(4, 18446744073709551614)), 18446744073709551614);
-    assert_eq!(call!(or_ui64(191084152064409600, 18446744073709551614)), 18446744073709551614);
-    assert_eq!(call!(or_ui64(11015955194427482112, 18446744073709551614)), 18446744073709551614);
-    assert_eq!(call!(or_ui64(16990600415051759616, 18446744073709551614)), 18446744073709551614);
-    assert_eq!(call!(or_ui64(18446744073709551614, 0)), 18446744073709551614);
-    assert_eq!(call!(or_ui64(18446744073709551614, 2)), 18446744073709551614);
-    assert_eq!(call!(or_ui64(18446744073709551614, 4)), 18446744073709551614);
-    assert_eq!(call!(or_ui64(18446744073709551614, 191084152064409600)), 18446744073709551614);
-    assert_eq!(call!(or_ui64(18446744073709551614, 11015955194427482112)), 18446744073709551614);
-    assert_eq!(call!(or_ui64(18446744073709551614, 16990600415051759616)), 18446744073709551614);
-    assert_eq!(call!(or_ui64(18446744073709551614, 18446744073709551614)), 18446744073709551614);
-    assert_eq!(call!(or_ui64(0, 18446744073709551615)), 18446744073709551615);
-    assert_eq!(call!(or_ui64(1, 18446744073709551614)), 18446744073709551615);
-    assert_eq!(call!(or_ui64(1, 18446744073709551615)), 18446744073709551615);
-    assert_eq!(call!(or_ui64(2, 18446744073709551615)), 18446744073709551615);
-    assert_eq!(call!(or_ui64(3, 18446744073709551614)), 18446744073709551615);
-    assert_eq!(call!(or_ui64(3, 18446744073709551615)), 18446744073709551615);
-    assert_eq!(call!(or_ui64(4, 18446744073709551615)), 18446744073709551615);
-    assert_eq!(call!(or_ui64(191084152064409600, 18446744073709551615)), 18446744073709551615);
-    assert_eq!(call!(or_ui64(11015955194427482112, 18446744073709551615)), 18446744073709551615);
-    assert_eq!(call!(or_ui64(16990600415051759616, 18446744073709551615)), 18446744073709551615);
-    assert_eq!(call!(or_ui64(18446744073709551614, 1)), 18446744073709551615);
-    assert_eq!(call!(or_ui64(18446744073709551614, 3)), 18446744073709551615);
-    assert_eq!(call!(or_ui64(18446744073709551614, 18446744073709551615)), 18446744073709551615);
-    assert_eq!(call!(or_ui64(18446744073709551615, 0)), 18446744073709551615);
-    assert_eq!(call!(or_ui64(18446744073709551615, 1)), 18446744073709551615);
-    assert_eq!(call!(or_ui64(18446744073709551615, 2)), 18446744073709551615);
-    assert_eq!(call!(or_ui64(18446744073709551615, 3)), 18446744073709551615);
-    assert_eq!(call!(or_ui64(18446744073709551615, 4)), 18446744073709551615);
-    assert_eq!(call!(or_ui64(18446744073709551615, 191084152064409600)), 18446744073709551615);
-    assert_eq!(call!(or_ui64(18446744073709551615, 11015955194427482112)), 18446744073709551615);
-    assert_eq!(call!(or_ui64(18446744073709551615, 16990600415051759616)), 18446744073709551615);
-    assert_eq!(call!(or_ui64(18446744073709551615, 18446744073709551614)), 18446744073709551615);
-    assert_eq!(call!(or_ui64(18446744073709551615, 18446744073709551615)), 18446744073709551615);
-    assert_eq!(call!(or_ui8(0, 0)), 0);
-    assert_eq!(call!(or_ui8(0, 1)), 1);
-    assert_eq!(call!(or_ui8(1, 0)), 1);
-    assert_eq!(call!(or_ui8(1, 1)), 1);
-    assert_eq!(call!(or_ui8(0, 2)), 2);
-    assert_eq!(call!(or_ui8(2, 0)), 2);
-    assert_eq!(call!(or_ui8(2, 2)), 2);
-    assert_eq!(call!(or_ui8(0, 3)), 3);
-    assert_eq!(call!(or_ui8(1, 2)), 3);
-    assert_eq!(call!(or_ui8(1, 3)), 3);
-    assert_eq!(call!(or_ui8(2, 1)), 3);
-    assert_eq!(call!(or_ui8(2, 3)), 3);
-    assert_eq!(call!(or_ui8(3, 0)), 3);
-    assert_eq!(call!(or_ui8(3, 1)), 3);
-    assert_eq!(call!(or_ui8(3, 2)), 3);
-    assert_eq!(call!(or_ui8(3, 3)), 3);
-    assert_eq!(call!(or_ui8(0, 4)), 4);
-    assert_eq!(call!(or_ui8(4, 0)), 4);
-    assert_eq!(call!(or_ui8(4, 4)), 4);
-    assert_eq!(call!(or_ui8(1, 4)), 5);
-    assert_eq!(call!(or_ui8(4, 1)), 5);
-    assert_eq!(call!(or_ui8(2, 4)), 6);
-    assert_eq!(call!(or_ui8(4, 2)), 6);
-    assert_eq!(call!(or_ui8(3, 4)), 7);
-    assert_eq!(call!(or_ui8(4, 3)), 7);
-    assert_eq!(call!(or_ui8(0, 72)), 72);
-    assert_eq!(call!(or_ui8(72, 0)), 72);
-    assert_eq!(call!(or_ui8(72, 72)), 72);
-    assert_eq!(call!(or_ui8(1, 72)), 73);
-    assert_eq!(call!(or_ui8(72, 1)), 73);
-    assert_eq!(call!(or_ui8(2, 72)), 74);
-    assert_eq!(call!(or_ui8(72, 2)), 74);
-    assert_eq!(call!(or_ui8(3, 72)), 75);
-    assert_eq!(call!(or_ui8(72, 3)), 75);
-    assert_eq!(call!(or_ui8(4, 72)), 76);
-    assert_eq!(call!(or_ui8(72, 4)), 76);
-    assert_eq!(call!(or_ui8(0, 100)), 100);
-    assert_eq!(call!(or_ui8(4, 100)), 100);
-    assert_eq!(call!(or_ui8(100, 0)), 100);
-    assert_eq!(call!(or_ui8(100, 4)), 100);
-    assert_eq!(call!(or_ui8(100, 100)), 100);
-    assert_eq!(call!(or_ui8(1, 100)), 101);
-    assert_eq!(call!(or_ui8(100, 1)), 101);
-    assert_eq!(call!(or_ui8(2, 100)), 102);
-    assert_eq!(call!(or_ui8(100, 2)), 102);
-    assert_eq!(call!(or_ui8(3, 100)), 103);
-    assert_eq!(call!(or_ui8(100, 3)), 103);
-    assert_eq!(call!(or_ui8(72, 100)), 108);
-    assert_eq!(call!(or_ui8(100, 72)), 108);
-    assert_eq!(call!(or_ui8(0, 162)), 162);
-    assert_eq!(call!(or_ui8(2, 162)), 162);
-    assert_eq!(call!(or_ui8(162, 0)), 162);
-    assert_eq!(call!(or_ui8(162, 2)), 162);
-    assert_eq!(call!(or_ui8(162, 162)), 162);
-    assert_eq!(call!(or_ui8(1, 162)), 163);
-    assert_eq!(call!(or_ui8(3, 162)), 163);
-    assert_eq!(call!(or_ui8(162, 1)), 163);
-    assert_eq!(call!(or_ui8(162, 3)), 163);
-    assert_eq!(call!(or_ui8(4, 162)), 166);
-    assert_eq!(call!(or_ui8(162, 4)), 166);
-    assert_eq!(call!(or_ui8(100, 162)), 230);
-    assert_eq!(call!(or_ui8(162, 100)), 230);
-    assert_eq!(call!(or_ui8(72, 162)), 234);
-    assert_eq!(call!(or_ui8(162, 72)), 234);
-    assert_eq!(call!(or_ui8(0, 254)), 254);
-    assert_eq!(call!(or_ui8(2, 254)), 254);
-    assert_eq!(call!(or_ui8(4, 254)), 254);
-    assert_eq!(call!(or_ui8(72, 254)), 254);
-    assert_eq!(call!(or_ui8(100, 254)), 254);
-    assert_eq!(call!(or_ui8(162, 254)), 254);
-    assert_eq!(call!(or_ui8(254, 0)), 254);
-    assert_eq!(call!(or_ui8(254, 2)), 254);
-    assert_eq!(call!(or_ui8(254, 4)), 254);
-    assert_eq!(call!(or_ui8(254, 72)), 254);
-    assert_eq!(call!(or_ui8(254, 100)), 254);
-    assert_eq!(call!(or_ui8(254, 162)), 254);
-    assert_eq!(call!(or_ui8(254, 254)), 254);
-    assert_eq!(call!(or_ui8(0, 255)), 255);
-    assert_eq!(call!(or_ui8(1, 254)), 255);
-    assert_eq!(call!(or_ui8(1, 255)), 255);
-    assert_eq!(call!(or_ui8(2, 255)), 255);
-    assert_eq!(call!(or_ui8(3, 254)), 255);
-    assert_eq!(call!(or_ui8(3, 255)), 255);
-    assert_eq!(call!(or_ui8(4, 255)), 255);
-    assert_eq!(call!(or_ui8(72, 255)), 255);
-    assert_eq!(call!(or_ui8(100, 255)), 255);
-    assert_eq!(call!(or_ui8(162, 255)), 255);
-    assert_eq!(call!(or_ui8(254, 1)), 255);
-    assert_eq!(call!(or_ui8(254, 3)), 255);
-    assert_eq!(call!(or_ui8(254, 255)), 255);
-    assert_eq!(call!(or_ui8(255, 0)), 255);
-    assert_eq!(call!(or_ui8(255, 1)), 255);
-    assert_eq!(call!(or_ui8(255, 2)), 255);
-    assert_eq!(call!(or_ui8(255, 3)), 255);
-    assert_eq!(call!(or_ui8(255, 4)), 255);
-    assert_eq!(call!(or_ui8(255, 72)), 255);
-    assert_eq!(call!(or_ui8(255, 100)), 255);
-    assert_eq!(call!(or_ui8(255, 162)), 255);
-    assert_eq!(call!(or_ui8(255, 254)), 255);
-    assert_eq!(call!(or_ui8(255, 255)), 255);
-    assert_eq!(call!(xor_si16(-32768, 0)), -32768);
-    assert_eq!(call!(xor_si16(-32767, 1)), -32768);
-    assert_eq!(call!(xor_si16(0, -32768)), -32768);
-    assert_eq!(call!(xor_si16(1, -32767)), -32768);
-    assert_eq!(call!(xor_si16(-32768, 1)), -32767);
-    assert_eq!(call!(xor_si16(-32767, 0)), -32767);
-    assert_eq!(call!(xor_si16(0, -32767)), -32767);
-    assert_eq!(call!(xor_si16(1, -32768)), -32767);
-    assert_eq!(call!(xor_si16(-32768, 2)), -32766);
-    assert_eq!(call!(xor_si16(-32767, 3)), -32766);
-    assert_eq!(call!(xor_si16(2, -32768)), -32766);
-    assert_eq!(call!(xor_si16(3, -32767)), -32766);
-    assert_eq!(call!(xor_si16(-32768, 3)), -32765);
-    assert_eq!(call!(xor_si16(-32767, 2)), -32765);
-    assert_eq!(call!(xor_si16(2, -32767)), -32765);
-    assert_eq!(call!(xor_si16(3, -32768)), -32765);
-    assert_eq!(call!(xor_si16(-32768, 4)), -32764);
-    assert_eq!(call!(xor_si16(4, -32768)), -32764);
-    assert_eq!(call!(xor_si16(-32767, 4)), -32763);
-    assert_eq!(call!(xor_si16(4, -32767)), -32763);
-    assert_eq!(call!(xor_si16(-32547, 4)), -32551);
-    assert_eq!(call!(xor_si16(4, -32547)), -32551);
-    assert_eq!(call!(xor_si16(-32547, 1)), -32548);
-    assert_eq!(call!(xor_si16(1, -32547)), -32548);
-    assert_eq!(call!(xor_si16(-32547, 0)), -32547);
-    assert_eq!(call!(xor_si16(0, -32547)), -32547);
-    assert_eq!(call!(xor_si16(-32547, 3)), -32546);
-    assert_eq!(call!(xor_si16(3, -32547)), -32546);
-    assert_eq!(call!(xor_si16(-32547, 2)), -32545);
-    assert_eq!(call!(xor_si16(2, -32547)), -32545);
-    assert_eq!(call!(xor_si16(-32547, 10486)), -22485);
-    assert_eq!(call!(xor_si16(10486, -32547)), -22485);
-    assert_eq!(call!(xor_si16(-32768, 10486)), -22282);
-    assert_eq!(call!(xor_si16(10486, -32768)), -22282);
-    assert_eq!(call!(xor_si16(-32767, 10486)), -22281);
-    assert_eq!(call!(xor_si16(10486, -32767)), -22281);
-    assert_eq!(call!(xor_si16(-32547, 16514)), -16289);
-    assert_eq!(call!(xor_si16(16514, -32547)), -16289);
-    assert_eq!(call!(xor_si16(-32768, 16514)), -16254);
-    assert_eq!(call!(xor_si16(16514, -32768)), -16254);
-    assert_eq!(call!(xor_si16(-32767, 16514)), -16253);
-    assert_eq!(call!(xor_si16(16514, -32767)), -16253);
-    assert_eq!(call!(xor_si16(-32547, 32767)), -222);
-    assert_eq!(call!(xor_si16(32767, -32547)), -222);
-    assert_eq!(call!(xor_si16(-32547, 32766)), -221);
-    assert_eq!(call!(xor_si16(32766, -32547)), -221);
-    assert_eq!(call!(xor_si16(-32768, 32766)), -2);
-    assert_eq!(call!(xor_si16(-32767, 32767)), -2);
-    assert_eq!(call!(xor_si16(32766, -32768)), -2);
-    assert_eq!(call!(xor_si16(32767, -32767)), -2);
-    assert_eq!(call!(xor_si16(-32768, 32767)), -1);
-    assert_eq!(call!(xor_si16(-32767, 32766)), -1);
-    assert_eq!(call!(xor_si16(32766, -32767)), -1);
-    assert_eq!(call!(xor_si16(32767, -32768)), -1);
-    assert_eq!(call!(xor_si16(-32768, -32768)), 0);
-    assert_eq!(call!(xor_si16(-32767, -32767)), 0);
-    assert_eq!(call!(xor_si16(-32547, -32547)), 0);
-    assert_eq!(call!(xor_si16(0, 0)), 0);
-    assert_eq!(call!(xor_si16(1, 1)), 0);
-    assert_eq!(call!(xor_si16(2, 2)), 0);
-    assert_eq!(call!(xor_si16(3, 3)), 0);
-    assert_eq!(call!(xor_si16(4, 4)), 0);
-    assert_eq!(call!(xor_si16(10486, 10486)), 0);
-    assert_eq!(call!(xor_si16(16514, 16514)), 0);
-    assert_eq!(call!(xor_si16(32766, 32766)), 0);
-    assert_eq!(call!(xor_si16(32767, 32767)), 0);
-    assert_eq!(call!(xor_si16(-32768, -32767)), 1);
-    assert_eq!(call!(xor_si16(-32767, -32768)), 1);
-    assert_eq!(call!(xor_si16(0, 1)), 1);
-    assert_eq!(call!(xor_si16(1, 0)), 1);
-    assert_eq!(call!(xor_si16(2, 3)), 1);
-    assert_eq!(call!(xor_si16(3, 2)), 1);
-    assert_eq!(call!(xor_si16(32766, 32767)), 1);
-    assert_eq!(call!(xor_si16(32767, 32766)), 1);
-    assert_eq!(call!(xor_si16(0, 2)), 2);
-    assert_eq!(call!(xor_si16(1, 3)), 2);
-    assert_eq!(call!(xor_si16(2, 0)), 2);
-    assert_eq!(call!(xor_si16(3, 1)), 2);
-    assert_eq!(call!(xor_si16(0, 3)), 3);
-    assert_eq!(call!(xor_si16(1, 2)), 3);
-    assert_eq!(call!(xor_si16(2, 1)), 3);
-    assert_eq!(call!(xor_si16(3, 0)), 3);
-    assert_eq!(call!(xor_si16(0, 4)), 4);
-    assert_eq!(call!(xor_si16(4, 0)), 4);
-    assert_eq!(call!(xor_si16(1, 4)), 5);
-    assert_eq!(call!(xor_si16(4, 1)), 5);
-    assert_eq!(call!(xor_si16(2, 4)), 6);
-    assert_eq!(call!(xor_si16(4, 2)), 6);
-    assert_eq!(call!(xor_si16(3, 4)), 7);
-    assert_eq!(call!(xor_si16(4, 3)), 7);
-    assert_eq!(call!(xor_si16(-32767, -32547)), 220);
-    assert_eq!(call!(xor_si16(-32547, -32767)), 220);
-    assert_eq!(call!(xor_si16(-32768, -32547)), 221);
-    assert_eq!(call!(xor_si16(-32547, -32768)), 221);
-    assert_eq!(call!(xor_si16(4, 10486)), 10482);
-    assert_eq!(call!(xor_si16(10486, 4)), 10482);
-    assert_eq!(call!(xor_si16(2, 10486)), 10484);
-    assert_eq!(call!(xor_si16(10486, 2)), 10484);
-    assert_eq!(call!(xor_si16(3, 10486)), 10485);
-    assert_eq!(call!(xor_si16(10486, 3)), 10485);
-    assert_eq!(call!(xor_si16(0, 10486)), 10486);
-    assert_eq!(call!(xor_si16(10486, 0)), 10486);
-    assert_eq!(call!(xor_si16(1, 10486)), 10487);
-    assert_eq!(call!(xor_si16(10486, 1)), 10487);
-    assert_eq!(call!(xor_si16(16514, 32766)), 16252);
-    assert_eq!(call!(xor_si16(32766, 16514)), 16252);
-    assert_eq!(call!(xor_si16(16514, 32767)), 16253);
-    assert_eq!(call!(xor_si16(32767, 16514)), 16253);
-    assert_eq!(call!(xor_si16(2, 16514)), 16512);
-    assert_eq!(call!(xor_si16(16514, 2)), 16512);
-    assert_eq!(call!(xor_si16(3, 16514)), 16513);
-    assert_eq!(call!(xor_si16(16514, 3)), 16513);
-    assert_eq!(call!(xor_si16(0, 16514)), 16514);
-    assert_eq!(call!(xor_si16(16514, 0)), 16514);
-    assert_eq!(call!(xor_si16(1, 16514)), 16515);
-    assert_eq!(call!(xor_si16(16514, 1)), 16515);
-    assert_eq!(call!(xor_si16(4, 16514)), 16518);
-    assert_eq!(call!(xor_si16(16514, 4)), 16518);
-    assert_eq!(call!(xor_si16(10486, 32766)), 22280);
-    assert_eq!(call!(xor_si16(32766, 10486)), 22280);
-    assert_eq!(call!(xor_si16(10486, 32767)), 22281);
-    assert_eq!(call!(xor_si16(32767, 10486)), 22281);
-    assert_eq!(call!(xor_si16(10486, 16514)), 26740);
-    assert_eq!(call!(xor_si16(16514, 10486)), 26740);
-    assert_eq!(call!(xor_si16(4, 32766)), 32762);
-    assert_eq!(call!(xor_si16(32766, 4)), 32762);
-    assert_eq!(call!(xor_si16(4, 32767)), 32763);
-    assert_eq!(call!(xor_si16(32767, 4)), 32763);
-    assert_eq!(call!(xor_si16(2, 32766)), 32764);
-    assert_eq!(call!(xor_si16(3, 32767)), 32764);
-    assert_eq!(call!(xor_si16(32766, 2)), 32764);
-    assert_eq!(call!(xor_si16(32767, 3)), 32764);
-    assert_eq!(call!(xor_si16(2, 32767)), 32765);
-    assert_eq!(call!(xor_si16(3, 32766)), 32765);
-    assert_eq!(call!(xor_si16(32766, 3)), 32765);
-    assert_eq!(call!(xor_si16(32767, 2)), 32765);
-    assert_eq!(call!(xor_si16(0, 32766)), 32766);
-    assert_eq!(call!(xor_si16(1, 32767)), 32766);
-    assert_eq!(call!(xor_si16(32766, 0)), 32766);
-    assert_eq!(call!(xor_si16(32767, 1)), 32766);
-    assert_eq!(call!(xor_si16(0, 32767)), 32767);
-    assert_eq!(call!(xor_si16(1, 32766)), 32767);
-    assert_eq!(call!(xor_si16(32766, 1)), 32767);
-    assert_eq!(call!(xor_si16(32767, 0)), 32767);
-    assert_eq!(call!(xor_si32(-2147483648, 0)), -2147483648);
-    assert_eq!(call!(xor_si32(-2147483647, 1)), -2147483648);
-    assert_eq!(call!(xor_si32(0, -2147483648)), -2147483648);
-    assert_eq!(call!(xor_si32(1, -2147483647)), -2147483648);
-    assert_eq!(call!(xor_si32(-2147483648, 1)), -2147483647);
-    assert_eq!(call!(xor_si32(-2147483647, 0)), -2147483647);
-    assert_eq!(call!(xor_si32(0, -2147483647)), -2147483647);
-    assert_eq!(call!(xor_si32(1, -2147483648)), -2147483647);
-    assert_eq!(call!(xor_si32(-2147483648, 2)), -2147483646);
-    assert_eq!(call!(xor_si32(-2147483647, 3)), -2147483646);
-    assert_eq!(call!(xor_si32(2, -2147483648)), -2147483646);
-    assert_eq!(call!(xor_si32(3, -2147483647)), -2147483646);
-    assert_eq!(call!(xor_si32(-2147483648, 3)), -2147483645);
-    assert_eq!(call!(xor_si32(-2147483647, 2)), -2147483645);
-    assert_eq!(call!(xor_si32(2, -2147483647)), -2147483645);
-    assert_eq!(call!(xor_si32(3, -2147483648)), -2147483645);
-    assert_eq!(call!(xor_si32(-2147483648, 4)), -2147483644);
-    assert_eq!(call!(xor_si32(4, -2147483648)), -2147483644);
-    assert_eq!(call!(xor_si32(-2147483647, 4)), -2147483643);
-    assert_eq!(call!(xor_si32(4, -2147483647)), -2147483643);
-    assert_eq!(call!(xor_si32(-1713183800, 0)), -1713183800);
-    assert_eq!(call!(xor_si32(0, -1713183800)), -1713183800);
-    assert_eq!(call!(xor_si32(-1713183800, 1)), -1713183799);
-    assert_eq!(call!(xor_si32(1, -1713183800)), -1713183799);
-    assert_eq!(call!(xor_si32(-1713183800, 2)), -1713183798);
-    assert_eq!(call!(xor_si32(2, -1713183800)), -1713183798);
-    assert_eq!(call!(xor_si32(-1713183800, 3)), -1713183797);
-    assert_eq!(call!(xor_si32(3, -1713183800)), -1713183797);
-    assert_eq!(call!(xor_si32(-1713183800, 4)), -1713183796);
-    assert_eq!(call!(xor_si32(4, -1713183800)), -1713183796);
-    assert_eq!(call!(xor_si32(-1252582164, 4)), -1252582168);
-    assert_eq!(call!(xor_si32(4, -1252582164)), -1252582168);
-    assert_eq!(call!(xor_si32(-1252582164, 0)), -1252582164);
-    assert_eq!(call!(xor_si32(0, -1252582164)), -1252582164);
-    assert_eq!(call!(xor_si32(-1252582164, 1)), -1252582163);
-    assert_eq!(call!(xor_si32(1, -1252582164)), -1252582163);
-    assert_eq!(call!(xor_si32(-1252582164, 2)), -1252582162);
-    assert_eq!(call!(xor_si32(2, -1252582164)), -1252582162);
-    assert_eq!(call!(xor_si32(-1252582164, 3)), -1252582161);
-    assert_eq!(call!(xor_si32(3, -1252582164)), -1252582161);
-    assert_eq!(call!(xor_si32(-1035405763, 2147483647)), -1112077886);
-    assert_eq!(call!(xor_si32(2147483647, -1035405763)), -1112077886);
-    assert_eq!(call!(xor_si32(-1035405763, 2147483646)), -1112077885);
-    assert_eq!(call!(xor_si32(2147483646, -1035405763)), -1112077885);
-    assert_eq!(call!(xor_si32(-1035405763, 4)), -1035405767);
-    assert_eq!(call!(xor_si32(4, -1035405763)), -1035405767);
-    assert_eq!(call!(xor_si32(-1035405763, 1)), -1035405764);
-    assert_eq!(call!(xor_si32(1, -1035405763)), -1035405764);
-    assert_eq!(call!(xor_si32(-1035405763, 0)), -1035405763);
-    assert_eq!(call!(xor_si32(0, -1035405763)), -1035405763);
-    assert_eq!(call!(xor_si32(-1035405763, 3)), -1035405762);
-    assert_eq!(call!(xor_si32(3, -1035405763)), -1035405762);
-    assert_eq!(call!(xor_si32(-1035405763, 2)), -1035405761);
-    assert_eq!(call!(xor_si32(2, -1035405763)), -1035405761);
-    assert_eq!(call!(xor_si32(-1252582164, 2147483646)), -894901486);
-    assert_eq!(call!(xor_si32(2147483646, -1252582164)), -894901486);
-    assert_eq!(call!(xor_si32(-1252582164, 2147483647)), -894901485);
-    assert_eq!(call!(xor_si32(2147483647, -1252582164)), -894901485);
-    assert_eq!(call!(xor_si32(-1713183800, 2147483646)), -434299850);
-    assert_eq!(call!(xor_si32(2147483646, -1713183800)), -434299850);
-    assert_eq!(call!(xor_si32(-1713183800, 2147483647)), -434299849);
-    assert_eq!(call!(xor_si32(2147483647, -1713183800)), -434299849);
-    assert_eq!(call!(xor_si32(-2147483648, 2147483646)), -2);
-    assert_eq!(call!(xor_si32(-2147483647, 2147483647)), -2);
-    assert_eq!(call!(xor_si32(2147483646, -2147483648)), -2);
-    assert_eq!(call!(xor_si32(2147483647, -2147483647)), -2);
-    assert_eq!(call!(xor_si32(-2147483648, 2147483647)), -1);
-    assert_eq!(call!(xor_si32(-2147483647, 2147483646)), -1);
-    assert_eq!(call!(xor_si32(2147483646, -2147483647)), -1);
-    assert_eq!(call!(xor_si32(2147483647, -2147483648)), -1);
-    assert_eq!(call!(xor_si32(-2147483648, -2147483648)), 0);
-    assert_eq!(call!(xor_si32(-2147483647, -2147483647)), 0);
-    assert_eq!(call!(xor_si32(-1713183800, -1713183800)), 0);
-    assert_eq!(call!(xor_si32(-1252582164, -1252582164)), 0);
-    assert_eq!(call!(xor_si32(-1035405763, -1035405763)), 0);
-    assert_eq!(call!(xor_si32(0, 0)), 0);
-    assert_eq!(call!(xor_si32(1, 1)), 0);
-    assert_eq!(call!(xor_si32(2, 2)), 0);
-    assert_eq!(call!(xor_si32(3, 3)), 0);
-    assert_eq!(call!(xor_si32(4, 4)), 0);
-    assert_eq!(call!(xor_si32(2147483646, 2147483646)), 0);
-    assert_eq!(call!(xor_si32(2147483647, 2147483647)), 0);
-    assert_eq!(call!(xor_si32(-2147483648, -2147483647)), 1);
-    assert_eq!(call!(xor_si32(-2147483647, -2147483648)), 1);
-    assert_eq!(call!(xor_si32(0, 1)), 1);
-    assert_eq!(call!(xor_si32(1, 0)), 1);
-    assert_eq!(call!(xor_si32(2, 3)), 1);
-    assert_eq!(call!(xor_si32(3, 2)), 1);
-    assert_eq!(call!(xor_si32(2147483646, 2147483647)), 1);
-    assert_eq!(call!(xor_si32(2147483647, 2147483646)), 1);
-    assert_eq!(call!(xor_si32(0, 2)), 2);
-    assert_eq!(call!(xor_si32(1, 3)), 2);
-    assert_eq!(call!(xor_si32(2, 0)), 2);
-    assert_eq!(call!(xor_si32(3, 1)), 2);
-    assert_eq!(call!(xor_si32(0, 3)), 3);
-    assert_eq!(call!(xor_si32(1, 2)), 3);
-    assert_eq!(call!(xor_si32(2, 1)), 3);
-    assert_eq!(call!(xor_si32(3, 0)), 3);
-    assert_eq!(call!(xor_si32(0, 4)), 4);
-    assert_eq!(call!(xor_si32(4, 0)), 4);
-    assert_eq!(call!(xor_si32(1, 4)), 5);
-    assert_eq!(call!(xor_si32(4, 1)), 5);
-    assert_eq!(call!(xor_si32(2, 4)), 6);
-    assert_eq!(call!(xor_si32(4, 2)), 6);
-    assert_eq!(call!(xor_si32(3, 4)), 7);
-    assert_eq!(call!(xor_si32(4, 3)), 7);
-    assert_eq!(call!(xor_si32(-2147483648, -1713183800)), 434299848);
-    assert_eq!(call!(xor_si32(-1713183800, -2147483648)), 434299848);
-    assert_eq!(call!(xor_si32(-2147483647, -1713183800)), 434299849);
-    assert_eq!(call!(xor_si32(-1713183800, -2147483647)), 434299849);
-    assert_eq!(call!(xor_si32(-1713183800, -1252582164)), 750124836);
-    assert_eq!(call!(xor_si32(-1252582164, -1713183800)), 750124836);
-    assert_eq!(call!(xor_si32(-2147483648, -1252582164)), 894901484);
-    assert_eq!(call!(xor_si32(-1252582164, -2147483648)), 894901484);
-    assert_eq!(call!(xor_si32(-2147483647, -1252582164)), 894901485);
-    assert_eq!(call!(xor_si32(-1252582164, -2147483647)), 894901485);
-    assert_eq!(call!(xor_si32(-2147483647, -1035405763)), 1112077884);
-    assert_eq!(call!(xor_si32(-1035405763, -2147483647)), 1112077884);
-    assert_eq!(call!(xor_si32(-2147483648, -1035405763)), 1112077885);
-    assert_eq!(call!(xor_si32(-1035405763, -2147483648)), 1112077885);
-    assert_eq!(call!(xor_si32(-1713183800, -1035405763)), 1537873397);
-    assert_eq!(call!(xor_si32(-1035405763, -1713183800)), 1537873397);
-    assert_eq!(call!(xor_si32(-1252582164, -1035405763)), 1998580433);
-    assert_eq!(call!(xor_si32(-1035405763, -1252582164)), 1998580433);
-    assert_eq!(call!(xor_si32(4, 2147483646)), 2147483642);
-    assert_eq!(call!(xor_si32(2147483646, 4)), 2147483642);
-    assert_eq!(call!(xor_si32(4, 2147483647)), 2147483643);
-    assert_eq!(call!(xor_si32(2147483647, 4)), 2147483643);
-    assert_eq!(call!(xor_si32(2, 2147483646)), 2147483644);
-    assert_eq!(call!(xor_si32(3, 2147483647)), 2147483644);
-    assert_eq!(call!(xor_si32(2147483646, 2)), 2147483644);
-    assert_eq!(call!(xor_si32(2147483647, 3)), 2147483644);
-    assert_eq!(call!(xor_si32(2, 2147483647)), 2147483645);
-    assert_eq!(call!(xor_si32(3, 2147483646)), 2147483645);
-    assert_eq!(call!(xor_si32(2147483646, 3)), 2147483645);
-    assert_eq!(call!(xor_si32(2147483647, 2)), 2147483645);
-    assert_eq!(call!(xor_si32(0, 2147483646)), 2147483646);
-    assert_eq!(call!(xor_si32(1, 2147483647)), 2147483646);
-    assert_eq!(call!(xor_si32(2147483646, 0)), 2147483646);
-    assert_eq!(call!(xor_si32(2147483647, 1)), 2147483646);
-    assert_eq!(call!(xor_si32(0, 2147483647)), 2147483647);
-    assert_eq!(call!(xor_si32(1, 2147483646)), 2147483647);
-    assert_eq!(call!(xor_si32(2147483646, 1)), 2147483647);
-    assert_eq!(call!(xor_si32(2147483647, 0)), 2147483647);
-    assert_eq!(call!(xor_si64(-9223372036854775808, 0)), -9223372036854775808);
-    assert_eq!(call!(xor_si64(-9223372036854775807, 1)), -9223372036854775808);
-    assert_eq!(call!(xor_si64(0, -9223372036854775808)), -9223372036854775808);
-    assert_eq!(call!(xor_si64(1, -9223372036854775807)), -9223372036854775808);
-    assert_eq!(call!(xor_si64(-9223372036854775808, 1)), -9223372036854775807);
-    assert_eq!(call!(xor_si64(-9223372036854775807, 0)), -9223372036854775807);
-    assert_eq!(call!(xor_si64(0, -9223372036854775807)), -9223372036854775807);
-    assert_eq!(call!(xor_si64(1, -9223372036854775808)), -9223372036854775807);
-    assert_eq!(call!(xor_si64(-9223372036854775808, 2)), -9223372036854775806);
-    assert_eq!(call!(xor_si64(-9223372036854775807, 3)), -9223372036854775806);
-    assert_eq!(call!(xor_si64(2, -9223372036854775808)), -9223372036854775806);
-    assert_eq!(call!(xor_si64(3, -9223372036854775807)), -9223372036854775806);
-    assert_eq!(call!(xor_si64(-9223372036854775808, 3)), -9223372036854775805);
-    assert_eq!(call!(xor_si64(-9223372036854775807, 2)), -9223372036854775805);
-    assert_eq!(call!(xor_si64(2, -9223372036854775807)), -9223372036854775805);
-    assert_eq!(call!(xor_si64(3, -9223372036854775808)), -9223372036854775805);
-    assert_eq!(call!(xor_si64(-9223372036854775808, 4)), -9223372036854775804);
-    assert_eq!(call!(xor_si64(4, -9223372036854775808)), -9223372036854775804);
-    assert_eq!(call!(xor_si64(-9223372036854775807, 4)), -9223372036854775803);
-    assert_eq!(call!(xor_si64(4, -9223372036854775807)), -9223372036854775803);
-    assert_eq!(call!(xor_si64(-1328271339354574848, 9223372036854775806)), -7895100697500200962);
-    assert_eq!(call!(xor_si64(9223372036854775806, -1328271339354574848)), -7895100697500200962);
-    assert_eq!(call!(xor_si64(-1328271339354574848, 9223372036854775807)), -7895100697500200961);
-    assert_eq!(call!(xor_si64(9223372036854775807, -1328271339354574848)), -7895100697500200961);
-    assert_eq!(call!(xor_si64(-1741927215160008704, 9223372036854775806)), -7481444821694767106);
-    assert_eq!(call!(xor_si64(9223372036854775806, -1741927215160008704)), -7481444821694767106);
-    assert_eq!(call!(xor_si64(-1741927215160008704, 9223372036854775807)), -7481444821694767105);
-    assert_eq!(call!(xor_si64(9223372036854775807, -1741927215160008704)), -7481444821694767105);
-    assert_eq!(call!(xor_si64(-1328271339354574848, 5577148965131116544)), -6847992414814875648);
-    assert_eq!(call!(xor_si64(5577148965131116544, -1328271339354574848)), -6847992414814875648);
-    assert_eq!(call!(xor_si64(-1741927215160008704, 5577148965131116544)), -6145886261021343744);
-    assert_eq!(call!(xor_si64(5577148965131116544, -1741927215160008704)), -6145886261021343744);
-    assert_eq!(call!(xor_si64(-9223372036854775808, 5577148965131116544)), -3646223071723659264);
-    assert_eq!(call!(xor_si64(5577148965131116544, -9223372036854775808)), -3646223071723659264);
-    assert_eq!(call!(xor_si64(-9223372036854775807, 5577148965131116544)), -3646223071723659263);
-    assert_eq!(call!(xor_si64(5577148965131116544, -9223372036854775807)), -3646223071723659263);
-    assert_eq!(call!(xor_si64(-1741927215160008704, 0)), -1741927215160008704);
-    assert_eq!(call!(xor_si64(0, -1741927215160008704)), -1741927215160008704);
-    assert_eq!(call!(xor_si64(-1741927215160008704, 1)), -1741927215160008703);
-    assert_eq!(call!(xor_si64(1, -1741927215160008704)), -1741927215160008703);
-    assert_eq!(call!(xor_si64(-1741927215160008704, 2)), -1741927215160008702);
-    assert_eq!(call!(xor_si64(2, -1741927215160008704)), -1741927215160008702);
-    assert_eq!(call!(xor_si64(-1741927215160008704, 3)), -1741927215160008701);
-    assert_eq!(call!(xor_si64(3, -1741927215160008704)), -1741927215160008701);
-    assert_eq!(call!(xor_si64(-1741927215160008704, 4)), -1741927215160008700);
-    assert_eq!(call!(xor_si64(4, -1741927215160008704)), -1741927215160008700);
-    assert_eq!(call!(xor_si64(-1328271339354574848, 0)), -1328271339354574848);
-    assert_eq!(call!(xor_si64(0, -1328271339354574848)), -1328271339354574848);
-    assert_eq!(call!(xor_si64(-1328271339354574848, 1)), -1328271339354574847);
-    assert_eq!(call!(xor_si64(1, -1328271339354574848)), -1328271339354574847);
-    assert_eq!(call!(xor_si64(-1328271339354574848, 2)), -1328271339354574846);
-    assert_eq!(call!(xor_si64(2, -1328271339354574848)), -1328271339354574846);
-    assert_eq!(call!(xor_si64(-1328271339354574848, 3)), -1328271339354574845);
-    assert_eq!(call!(xor_si64(3, -1328271339354574848)), -1328271339354574845);
-    assert_eq!(call!(xor_si64(-1328271339354574848, 4)), -1328271339354574844);
-    assert_eq!(call!(xor_si64(4, -1328271339354574848)), -1328271339354574844);
-    assert_eq!(call!(xor_si64(-9223372036854775808, 9223372036854775806)), -2);
-    assert_eq!(call!(xor_si64(-9223372036854775807, 9223372036854775807)), -2);
-    assert_eq!(call!(xor_si64(9223372036854775806, -9223372036854775808)), -2);
-    assert_eq!(call!(xor_si64(9223372036854775807, -9223372036854775807)), -2);
-    assert_eq!(call!(xor_si64(-9223372036854775808, 9223372036854775807)), -1);
-    assert_eq!(call!(xor_si64(-9223372036854775807, 9223372036854775806)), -1);
-    assert_eq!(call!(xor_si64(9223372036854775806, -9223372036854775807)), -1);
-    assert_eq!(call!(xor_si64(9223372036854775807, -9223372036854775808)), -1);
-    assert_eq!(call!(xor_si64(-9223372036854775808, -9223372036854775808)), 0);
-    assert_eq!(call!(xor_si64(-9223372036854775807, -9223372036854775807)), 0);
-    assert_eq!(call!(xor_si64(-1741927215160008704, -1741927215160008704)), 0);
-    assert_eq!(call!(xor_si64(-1328271339354574848, -1328271339354574848)), 0);
-    assert_eq!(call!(xor_si64(0, 0)), 0);
-    assert_eq!(call!(xor_si64(1, 1)), 0);
-    assert_eq!(call!(xor_si64(2, 2)), 0);
-    assert_eq!(call!(xor_si64(3, 3)), 0);
-    assert_eq!(call!(xor_si64(4, 4)), 0);
-    assert_eq!(call!(xor_si64(5577148965131116544, 5577148965131116544)), 0);
-    assert_eq!(call!(xor_si64(9223372036854775806, 9223372036854775806)), 0);
-    assert_eq!(call!(xor_si64(9223372036854775807, 9223372036854775807)), 0);
-    assert_eq!(call!(xor_si64(-9223372036854775808, -9223372036854775807)), 1);
-    assert_eq!(call!(xor_si64(-9223372036854775807, -9223372036854775808)), 1);
-    assert_eq!(call!(xor_si64(0, 1)), 1);
-    assert_eq!(call!(xor_si64(1, 0)), 1);
-    assert_eq!(call!(xor_si64(2, 3)), 1);
-    assert_eq!(call!(xor_si64(3, 2)), 1);
-    assert_eq!(call!(xor_si64(9223372036854775806, 9223372036854775807)), 1);
-    assert_eq!(call!(xor_si64(9223372036854775807, 9223372036854775806)), 1);
-    assert_eq!(call!(xor_si64(0, 2)), 2);
-    assert_eq!(call!(xor_si64(1, 3)), 2);
-    assert_eq!(call!(xor_si64(2, 0)), 2);
-    assert_eq!(call!(xor_si64(3, 1)), 2);
-    assert_eq!(call!(xor_si64(0, 3)), 3);
-    assert_eq!(call!(xor_si64(1, 2)), 3);
-    assert_eq!(call!(xor_si64(2, 1)), 3);
-    assert_eq!(call!(xor_si64(3, 0)), 3);
-    assert_eq!(call!(xor_si64(0, 4)), 4);
-    assert_eq!(call!(xor_si64(4, 0)), 4);
-    assert_eq!(call!(xor_si64(1, 4)), 5);
-    assert_eq!(call!(xor_si64(4, 1)), 5);
-    assert_eq!(call!(xor_si64(2, 4)), 6);
-    assert_eq!(call!(xor_si64(4, 2)), 6);
-    assert_eq!(call!(xor_si64(3, 4)), 7);
-    assert_eq!(call!(xor_si64(4, 3)), 7);
-    assert_eq!(call!(xor_si64(-1741927215160008704, -1328271339354574848)), 739265629478801408);
-    assert_eq!(call!(xor_si64(-1328271339354574848, -1741927215160008704)), 739265629478801408);
-    assert_eq!(call!(xor_si64(5577148965131116544, 9223372036854775806)), 3646223071723659262);
-    assert_eq!(call!(xor_si64(9223372036854775806, 5577148965131116544)), 3646223071723659262);
-    assert_eq!(call!(xor_si64(5577148965131116544, 9223372036854775807)), 3646223071723659263);
-    assert_eq!(call!(xor_si64(9223372036854775807, 5577148965131116544)), 3646223071723659263);
-    assert_eq!(call!(xor_si64(0, 5577148965131116544)), 5577148965131116544);
-    assert_eq!(call!(xor_si64(5577148965131116544, 0)), 5577148965131116544);
-    assert_eq!(call!(xor_si64(1, 5577148965131116544)), 5577148965131116545);
-    assert_eq!(call!(xor_si64(5577148965131116544, 1)), 5577148965131116545);
-    assert_eq!(call!(xor_si64(2, 5577148965131116544)), 5577148965131116546);
-    assert_eq!(call!(xor_si64(5577148965131116544, 2)), 5577148965131116546);
-    assert_eq!(call!(xor_si64(3, 5577148965131116544)), 5577148965131116547);
-    assert_eq!(call!(xor_si64(5577148965131116544, 3)), 5577148965131116547);
-    assert_eq!(call!(xor_si64(4, 5577148965131116544)), 5577148965131116548);
-    assert_eq!(call!(xor_si64(5577148965131116544, 4)), 5577148965131116548);
-    assert_eq!(call!(xor_si64(-9223372036854775808, -1741927215160008704)), 7481444821694767104);
-    assert_eq!(call!(xor_si64(-1741927215160008704, -9223372036854775808)), 7481444821694767104);
-    assert_eq!(call!(xor_si64(-9223372036854775807, -1741927215160008704)), 7481444821694767105);
-    assert_eq!(call!(xor_si64(-1741927215160008704, -9223372036854775807)), 7481444821694767105);
-    assert_eq!(call!(xor_si64(-9223372036854775808, -1328271339354574848)), 7895100697500200960);
-    assert_eq!(call!(xor_si64(-1328271339354574848, -9223372036854775808)), 7895100697500200960);
-    assert_eq!(call!(xor_si64(-9223372036854775807, -1328271339354574848)), 7895100697500200961);
-    assert_eq!(call!(xor_si64(-1328271339354574848, -9223372036854775807)), 7895100697500200961);
-    assert_eq!(call!(xor_si64(4, 9223372036854775806)), 9223372036854775802);
-    assert_eq!(call!(xor_si64(9223372036854775806, 4)), 9223372036854775802);
-    assert_eq!(call!(xor_si64(4, 9223372036854775807)), 9223372036854775803);
-    assert_eq!(call!(xor_si64(9223372036854775807, 4)), 9223372036854775803);
-    assert_eq!(call!(xor_si64(2, 9223372036854775806)), 9223372036854775804);
-    assert_eq!(call!(xor_si64(3, 9223372036854775807)), 9223372036854775804);
-    assert_eq!(call!(xor_si64(9223372036854775806, 2)), 9223372036854775804);
-    assert_eq!(call!(xor_si64(9223372036854775807, 3)), 9223372036854775804);
-    assert_eq!(call!(xor_si64(2, 9223372036854775807)), 9223372036854775805);
-    assert_eq!(call!(xor_si64(3, 9223372036854775806)), 9223372036854775805);
-    assert_eq!(call!(xor_si64(9223372036854775806, 3)), 9223372036854775805);
-    assert_eq!(call!(xor_si64(9223372036854775807, 2)), 9223372036854775805);
-    assert_eq!(call!(xor_si64(0, 9223372036854775806)), 9223372036854775806);
-    assert_eq!(call!(xor_si64(1, 9223372036854775807)), 9223372036854775806);
-    assert_eq!(call!(xor_si64(9223372036854775806, 0)), 9223372036854775806);
-    assert_eq!(call!(xor_si64(9223372036854775807, 1)), 9223372036854775806);
-    assert_eq!(call!(xor_si64(0, 9223372036854775807)), 9223372036854775807);
-    assert_eq!(call!(xor_si64(1, 9223372036854775806)), 9223372036854775807);
-    assert_eq!(call!(xor_si64(9223372036854775806, 1)), 9223372036854775807);
-    assert_eq!(call!(xor_si64(9223372036854775807, 0)), 9223372036854775807);
-    assert_eq!(call!(xor_si8(-128, 0)), -128);
-    assert_eq!(call!(xor_si8(-127, 1)), -128);
-    assert_eq!(call!(xor_si8(0, -128)), -128);
-    assert_eq!(call!(xor_si8(1, -127)), -128);
-    assert_eq!(call!(xor_si8(-128, 1)), -127);
-    assert_eq!(call!(xor_si8(-127, 0)), -127);
-    assert_eq!(call!(xor_si8(0, -127)), -127);
-    assert_eq!(call!(xor_si8(1, -128)), -127);
-    assert_eq!(call!(xor_si8(-128, 2)), -126);
-    assert_eq!(call!(xor_si8(-127, 3)), -126);
-    assert_eq!(call!(xor_si8(2, -128)), -126);
-    assert_eq!(call!(xor_si8(3, -127)), -126);
-    assert_eq!(call!(xor_si8(-128, 3)), -125);
-    assert_eq!(call!(xor_si8(-127, 2)), -125);
-    assert_eq!(call!(xor_si8(2, -127)), -125);
-    assert_eq!(call!(xor_si8(3, -128)), -125);
-    assert_eq!(call!(xor_si8(-128, 4)), -124);
-    assert_eq!(call!(xor_si8(4, -128)), -124);
-    assert_eq!(call!(xor_si8(-127, 4)), -123);
-    assert_eq!(call!(xor_si8(4, -127)), -123);
-    assert_eq!(call!(xor_si8(-128, 16)), -112);
-    assert_eq!(call!(xor_si8(16, -128)), -112);
-    assert_eq!(call!(xor_si8(-127, 16)), -111);
-    assert_eq!(call!(xor_si8(16, -127)), -111);
-    assert_eq!(call!(xor_si8(-128, 126)), -2);
-    assert_eq!(call!(xor_si8(-127, 127)), -2);
-    assert_eq!(call!(xor_si8(126, -128)), -2);
-    assert_eq!(call!(xor_si8(127, -127)), -2);
-    assert_eq!(call!(xor_si8(-128, 127)), -1);
-    assert_eq!(call!(xor_si8(-127, 126)), -1);
-    assert_eq!(call!(xor_si8(126, -127)), -1);
-    assert_eq!(call!(xor_si8(127, -128)), -1);
-    assert_eq!(call!(xor_si8(-128, -128)), 0);
-    assert_eq!(call!(xor_si8(-127, -127)), 0);
-    assert_eq!(call!(xor_si8(0, 0)), 0);
-    assert_eq!(call!(xor_si8(1, 1)), 0);
-    assert_eq!(call!(xor_si8(2, 2)), 0);
-    assert_eq!(call!(xor_si8(3, 3)), 0);
-    assert_eq!(call!(xor_si8(4, 4)), 0);
-    assert_eq!(call!(xor_si8(16, 16)), 0);
-    assert_eq!(call!(xor_si8(126, 126)), 0);
-    assert_eq!(call!(xor_si8(127, 127)), 0);
-    assert_eq!(call!(xor_si8(-128, -127)), 1);
-    assert_eq!(call!(xor_si8(-127, -128)), 1);
-    assert_eq!(call!(xor_si8(0, 1)), 1);
-    assert_eq!(call!(xor_si8(1, 0)), 1);
-    assert_eq!(call!(xor_si8(2, 3)), 1);
-    assert_eq!(call!(xor_si8(3, 2)), 1);
-    assert_eq!(call!(xor_si8(126, 127)), 1);
-    assert_eq!(call!(xor_si8(127, 126)), 1);
-    assert_eq!(call!(xor_si8(0, 2)), 2);
-    assert_eq!(call!(xor_si8(1, 3)), 2);
-    assert_eq!(call!(xor_si8(2, 0)), 2);
-    assert_eq!(call!(xor_si8(3, 1)), 2);
-    assert_eq!(call!(xor_si8(0, 3)), 3);
-    assert_eq!(call!(xor_si8(1, 2)), 3);
-    assert_eq!(call!(xor_si8(2, 1)), 3);
-    assert_eq!(call!(xor_si8(3, 0)), 3);
-    assert_eq!(call!(xor_si8(0, 4)), 4);
-    assert_eq!(call!(xor_si8(4, 0)), 4);
-    assert_eq!(call!(xor_si8(1, 4)), 5);
-    assert_eq!(call!(xor_si8(4, 1)), 5);
-    assert_eq!(call!(xor_si8(2, 4)), 6);
-    assert_eq!(call!(xor_si8(4, 2)), 6);
-    assert_eq!(call!(xor_si8(3, 4)), 7);
-    assert_eq!(call!(xor_si8(4, 3)), 7);
-    assert_eq!(call!(xor_si8(0, 16)), 16);
-    assert_eq!(call!(xor_si8(16, 0)), 16);
-    assert_eq!(call!(xor_si8(1, 16)), 17);
-    assert_eq!(call!(xor_si8(16, 1)), 17);
-    assert_eq!(call!(xor_si8(2, 16)), 18);
-    assert_eq!(call!(xor_si8(16, 2)), 18);
-    assert_eq!(call!(xor_si8(3, 16)), 19);
-    assert_eq!(call!(xor_si8(16, 3)), 19);
-    assert_eq!(call!(xor_si8(4, 16)), 20);
-    assert_eq!(call!(xor_si8(16, 4)), 20);
-    assert_eq!(call!(xor_si8(16, 126)), 110);
-    assert_eq!(call!(xor_si8(126, 16)), 110);
-    assert_eq!(call!(xor_si8(16, 127)), 111);
-    assert_eq!(call!(xor_si8(127, 16)), 111);
-    assert_eq!(call!(xor_si8(4, 126)), 122);
-    assert_eq!(call!(xor_si8(126, 4)), 122);
-    assert_eq!(call!(xor_si8(4, 127)), 123);
-    assert_eq!(call!(xor_si8(127, 4)), 123);
-    assert_eq!(call!(xor_si8(2, 126)), 124);
-    assert_eq!(call!(xor_si8(3, 127)), 124);
-    assert_eq!(call!(xor_si8(126, 2)), 124);
-    assert_eq!(call!(xor_si8(127, 3)), 124);
-    assert_eq!(call!(xor_si8(2, 127)), 125);
-    assert_eq!(call!(xor_si8(3, 126)), 125);
-    assert_eq!(call!(xor_si8(126, 3)), 125);
-    assert_eq!(call!(xor_si8(127, 2)), 125);
-    assert_eq!(call!(xor_si8(0, 126)), 126);
-    assert_eq!(call!(xor_si8(1, 127)), 126);
-    assert_eq!(call!(xor_si8(126, 0)), 126);
-    assert_eq!(call!(xor_si8(127, 1)), 126);
-    assert_eq!(call!(xor_si8(0, 127)), 127);
-    assert_eq!(call!(xor_si8(1, 126)), 127);
-    assert_eq!(call!(xor_si8(126, 1)), 127);
-    assert_eq!(call!(xor_si8(127, 0)), 127);
-    assert_eq!(call!(xor_ui16(0, 0)), 0);
-    assert_eq!(call!(xor_ui16(1, 1)), 0);
-    assert_eq!(call!(xor_ui16(2, 2)), 0);
-    assert_eq!(call!(xor_ui16(3, 3)), 0);
-    assert_eq!(call!(xor_ui16(4, 4)), 0);
-    assert_eq!(call!(xor_ui16(1717, 1717)), 0);
-    assert_eq!(call!(xor_ui16(17988, 17988)), 0);
-    assert_eq!(call!(xor_ui16(65096, 65096)), 0);
-    assert_eq!(call!(xor_ui16(65534, 65534)), 0);
-    assert_eq!(call!(xor_ui16(65535, 65535)), 0);
-    assert_eq!(call!(xor_ui16(0, 1)), 1);
-    assert_eq!(call!(xor_ui16(1, 0)), 1);
-    assert_eq!(call!(xor_ui16(2, 3)), 1);
-    assert_eq!(call!(xor_ui16(3, 2)), 1);
-    assert_eq!(call!(xor_ui16(65534, 65535)), 1);
-    assert_eq!(call!(xor_ui16(65535, 65534)), 1);
-    assert_eq!(call!(xor_ui16(0, 2)), 2);
-    assert_eq!(call!(xor_ui16(1, 3)), 2);
-    assert_eq!(call!(xor_ui16(2, 0)), 2);
-    assert_eq!(call!(xor_ui16(3, 1)), 2);
-    assert_eq!(call!(xor_ui16(0, 3)), 3);
-    assert_eq!(call!(xor_ui16(1, 2)), 3);
-    assert_eq!(call!(xor_ui16(2, 1)), 3);
-    assert_eq!(call!(xor_ui16(3, 0)), 3);
-    assert_eq!(call!(xor_ui16(0, 4)), 4);
-    assert_eq!(call!(xor_ui16(4, 0)), 4);
-    assert_eq!(call!(xor_ui16(1, 4)), 5);
-    assert_eq!(call!(xor_ui16(4, 1)), 5);
-    assert_eq!(call!(xor_ui16(2, 4)), 6);
-    assert_eq!(call!(xor_ui16(4, 2)), 6);
-    assert_eq!(call!(xor_ui16(3, 4)), 7);
-    assert_eq!(call!(xor_ui16(4, 3)), 7);
-    assert_eq!(call!(xor_ui16(65096, 65534)), 438);
-    assert_eq!(call!(xor_ui16(65534, 65096)), 438);
-    assert_eq!(call!(xor_ui16(65096, 65535)), 439);
-    assert_eq!(call!(xor_ui16(65535, 65096)), 439);
-    assert_eq!(call!(xor_ui16(4, 1717)), 1713);
-    assert_eq!(call!(xor_ui16(1717, 4)), 1713);
-    assert_eq!(call!(xor_ui16(1, 1717)), 1716);
-    assert_eq!(call!(xor_ui16(1717, 1)), 1716);
-    assert_eq!(call!(xor_ui16(0, 1717)), 1717);
-    assert_eq!(call!(xor_ui16(1717, 0)), 1717);
-    assert_eq!(call!(xor_ui16(3, 1717)), 1718);
-    assert_eq!(call!(xor_ui16(1717, 3)), 1718);
-    assert_eq!(call!(xor_ui16(2, 1717)), 1719);
-    assert_eq!(call!(xor_ui16(1717, 2)), 1719);
-    assert_eq!(call!(xor_ui16(1717, 17988)), 16625);
-    assert_eq!(call!(xor_ui16(17988, 1717)), 16625);
-    assert_eq!(call!(xor_ui16(4, 17988)), 17984);
-    assert_eq!(call!(xor_ui16(17988, 4)), 17984);
-    assert_eq!(call!(xor_ui16(0, 17988)), 17988);
-    assert_eq!(call!(xor_ui16(17988, 0)), 17988);
-    assert_eq!(call!(xor_ui16(1, 17988)), 17989);
-    assert_eq!(call!(xor_ui16(17988, 1)), 17989);
-    assert_eq!(call!(xor_ui16(2, 17988)), 17990);
-    assert_eq!(call!(xor_ui16(17988, 2)), 17990);
-    assert_eq!(call!(xor_ui16(3, 17988)), 17991);
-    assert_eq!(call!(xor_ui16(17988, 3)), 17991);
-    assert_eq!(call!(xor_ui16(17988, 65096)), 47116);
-    assert_eq!(call!(xor_ui16(65096, 17988)), 47116);
-    assert_eq!(call!(xor_ui16(17988, 65534)), 47546);
-    assert_eq!(call!(xor_ui16(65534, 17988)), 47546);
-    assert_eq!(call!(xor_ui16(17988, 65535)), 47547);
-    assert_eq!(call!(xor_ui16(65535, 17988)), 47547);
-    assert_eq!(call!(xor_ui16(1717, 65096)), 63741);
-    assert_eq!(call!(xor_ui16(65096, 1717)), 63741);
-    assert_eq!(call!(xor_ui16(1717, 65535)), 63818);
-    assert_eq!(call!(xor_ui16(65535, 1717)), 63818);
-    assert_eq!(call!(xor_ui16(1717, 65534)), 63819);
-    assert_eq!(call!(xor_ui16(65534, 1717)), 63819);
-    assert_eq!(call!(xor_ui16(0, 65096)), 65096);
-    assert_eq!(call!(xor_ui16(65096, 0)), 65096);
-    assert_eq!(call!(xor_ui16(1, 65096)), 65097);
-    assert_eq!(call!(xor_ui16(65096, 1)), 65097);
-    assert_eq!(call!(xor_ui16(2, 65096)), 65098);
-    assert_eq!(call!(xor_ui16(65096, 2)), 65098);
-    assert_eq!(call!(xor_ui16(3, 65096)), 65099);
-    assert_eq!(call!(xor_ui16(65096, 3)), 65099);
-    assert_eq!(call!(xor_ui16(4, 65096)), 65100);
-    assert_eq!(call!(xor_ui16(65096, 4)), 65100);
-    assert_eq!(call!(xor_ui16(4, 65534)), 65530);
-    assert_eq!(call!(xor_ui16(65534, 4)), 65530);
-    assert_eq!(call!(xor_ui16(4, 65535)), 65531);
-    assert_eq!(call!(xor_ui16(65535, 4)), 65531);
-    assert_eq!(call!(xor_ui16(2, 65534)), 65532);
-    assert_eq!(call!(xor_ui16(3, 65535)), 65532);
-    assert_eq!(call!(xor_ui16(65534, 2)), 65532);
-    assert_eq!(call!(xor_ui16(65535, 3)), 65532);
-    assert_eq!(call!(xor_ui16(2, 65535)), 65533);
-    assert_eq!(call!(xor_ui16(3, 65534)), 65533);
-    assert_eq!(call!(xor_ui16(65534, 3)), 65533);
-    assert_eq!(call!(xor_ui16(65535, 2)), 65533);
-    assert_eq!(call!(xor_ui16(0, 65534)), 65534);
-    assert_eq!(call!(xor_ui16(1, 65535)), 65534);
-    assert_eq!(call!(xor_ui16(65534, 0)), 65534);
-    assert_eq!(call!(xor_ui16(65535, 1)), 65534);
-    assert_eq!(call!(xor_ui16(0, 65535)), 65535);
-    assert_eq!(call!(xor_ui16(1, 65534)), 65535);
-    assert_eq!(call!(xor_ui16(65534, 1)), 65535);
-    assert_eq!(call!(xor_ui16(65535, 0)), 65535);
-    assert_eq!(call!(xor_ui32(0, 0)), 0);
-    assert_eq!(call!(xor_ui32(1, 1)), 0);
-    assert_eq!(call!(xor_ui32(2, 2)), 0);
-    assert_eq!(call!(xor_ui32(3, 3)), 0);
-    assert_eq!(call!(xor_ui32(4, 4)), 0);
-    assert_eq!(call!(xor_ui32(2119154652, 2119154652)), 0);
-    assert_eq!(call!(xor_ui32(3002788344, 3002788344)), 0);
-    assert_eq!(call!(xor_ui32(3482297128, 3482297128)), 0);
-    assert_eq!(call!(xor_ui32(4294967294, 4294967294)), 0);
-    assert_eq!(call!(xor_ui32(4294967295, 4294967295)), 0);
-    assert_eq!(call!(xor_ui32(0, 1)), 1);
-    assert_eq!(call!(xor_ui32(1, 0)), 1);
-    assert_eq!(call!(xor_ui32(2, 3)), 1);
-    assert_eq!(call!(xor_ui32(3, 2)), 1);
-    assert_eq!(call!(xor_ui32(4294967294, 4294967295)), 1);
-    assert_eq!(call!(xor_ui32(4294967295, 4294967294)), 1);
-    assert_eq!(call!(xor_ui32(0, 2)), 2);
-    assert_eq!(call!(xor_ui32(1, 3)), 2);
-    assert_eq!(call!(xor_ui32(2, 0)), 2);
-    assert_eq!(call!(xor_ui32(3, 1)), 2);
-    assert_eq!(call!(xor_ui32(0, 3)), 3);
-    assert_eq!(call!(xor_ui32(1, 2)), 3);
-    assert_eq!(call!(xor_ui32(2, 1)), 3);
-    assert_eq!(call!(xor_ui32(3, 0)), 3);
-    assert_eq!(call!(xor_ui32(0, 4)), 4);
-    assert_eq!(call!(xor_ui32(4, 0)), 4);
-    assert_eq!(call!(xor_ui32(1, 4)), 5);
-    assert_eq!(call!(xor_ui32(4, 1)), 5);
-    assert_eq!(call!(xor_ui32(2, 4)), 6);
-    assert_eq!(call!(xor_ui32(4, 2)), 6);
-    assert_eq!(call!(xor_ui32(3, 4)), 7);
-    assert_eq!(call!(xor_ui32(4, 3)), 7);
-    assert_eq!(call!(xor_ui32(3482297128, 4294967294)), 812670166);
-    assert_eq!(call!(xor_ui32(4294967294, 3482297128)), 812670166);
-    assert_eq!(call!(xor_ui32(3482297128, 4294967295)), 812670167);
-    assert_eq!(call!(xor_ui32(4294967295, 3482297128)), 812670167);
-    assert_eq!(call!(xor_ui32(3002788344, 4294967294)), 1292178950);
-    assert_eq!(call!(xor_ui32(4294967294, 3002788344)), 1292178950);
-    assert_eq!(call!(xor_ui32(3002788344, 4294967295)), 1292178951);
-    assert_eq!(call!(xor_ui32(4294967295, 3002788344)), 1292178951);
-    assert_eq!(call!(xor_ui32(3002788344, 3482297128)), 2104838864);
-    assert_eq!(call!(xor_ui32(3482297128, 3002788344)), 2104838864);
-    assert_eq!(call!(xor_ui32(4, 2119154652)), 2119154648);
-    assert_eq!(call!(xor_ui32(2119154652, 4)), 2119154648);
-    assert_eq!(call!(xor_ui32(0, 2119154652)), 2119154652);
-    assert_eq!(call!(xor_ui32(2119154652, 0)), 2119154652);
-    assert_eq!(call!(xor_ui32(1, 2119154652)), 2119154653);
-    assert_eq!(call!(xor_ui32(2119154652, 1)), 2119154653);
-    assert_eq!(call!(xor_ui32(2, 2119154652)), 2119154654);
-    assert_eq!(call!(xor_ui32(2119154652, 2)), 2119154654);
-    assert_eq!(call!(xor_ui32(3, 2119154652)), 2119154655);
-    assert_eq!(call!(xor_ui32(2119154652, 3)), 2119154655);
-    assert_eq!(call!(xor_ui32(2119154652, 4294967294)), 2175812642);
-    assert_eq!(call!(xor_ui32(4294967294, 2119154652)), 2175812642);
-    assert_eq!(call!(xor_ui32(2119154652, 4294967295)), 2175812643);
-    assert_eq!(call!(xor_ui32(4294967295, 2119154652)), 2175812643);
-    assert_eq!(call!(xor_ui32(2119154652, 3482297128)), 2982156532);
-    assert_eq!(call!(xor_ui32(3482297128, 2119154652)), 2982156532);
-    assert_eq!(call!(xor_ui32(0, 3002788344)), 3002788344);
-    assert_eq!(call!(xor_ui32(3002788344, 0)), 3002788344);
-    assert_eq!(call!(xor_ui32(1, 3002788344)), 3002788345);
-    assert_eq!(call!(xor_ui32(3002788344, 1)), 3002788345);
-    assert_eq!(call!(xor_ui32(2, 3002788344)), 3002788346);
-    assert_eq!(call!(xor_ui32(3002788344, 2)), 3002788346);
-    assert_eq!(call!(xor_ui32(3, 3002788344)), 3002788347);
-    assert_eq!(call!(xor_ui32(3002788344, 3)), 3002788347);
-    assert_eq!(call!(xor_ui32(4, 3002788344)), 3002788348);
-    assert_eq!(call!(xor_ui32(3002788344, 4)), 3002788348);
-    assert_eq!(call!(xor_ui32(2119154652, 3002788344)), 3434435108);
-    assert_eq!(call!(xor_ui32(3002788344, 2119154652)), 3434435108);
-    assert_eq!(call!(xor_ui32(0, 3482297128)), 3482297128);
-    assert_eq!(call!(xor_ui32(3482297128, 0)), 3482297128);
-    assert_eq!(call!(xor_ui32(1, 3482297128)), 3482297129);
-    assert_eq!(call!(xor_ui32(3482297128, 1)), 3482297129);
-    assert_eq!(call!(xor_ui32(2, 3482297128)), 3482297130);
-    assert_eq!(call!(xor_ui32(3482297128, 2)), 3482297130);
-    assert_eq!(call!(xor_ui32(3, 3482297128)), 3482297131);
-    assert_eq!(call!(xor_ui32(3482297128, 3)), 3482297131);
-    assert_eq!(call!(xor_ui32(4, 3482297128)), 3482297132);
-    assert_eq!(call!(xor_ui32(3482297128, 4)), 3482297132);
-    assert_eq!(call!(xor_ui32(4, 4294967294)), 4294967290);
-    assert_eq!(call!(xor_ui32(4294967294, 4)), 4294967290);
-    assert_eq!(call!(xor_ui32(4, 4294967295)), 4294967291);
-    assert_eq!(call!(xor_ui32(4294967295, 4)), 4294967291);
-    assert_eq!(call!(xor_ui32(2, 4294967294)), 4294967292);
-    assert_eq!(call!(xor_ui32(3, 4294967295)), 4294967292);
-    assert_eq!(call!(xor_ui32(4294967294, 2)), 4294967292);
-    assert_eq!(call!(xor_ui32(4294967295, 3)), 4294967292);
-    assert_eq!(call!(xor_ui32(2, 4294967295)), 4294967293);
-    assert_eq!(call!(xor_ui32(3, 4294967294)), 4294967293);
-    assert_eq!(call!(xor_ui32(4294967294, 3)), 4294967293);
-    assert_eq!(call!(xor_ui32(4294967295, 2)), 4294967293);
-    assert_eq!(call!(xor_ui32(0, 4294967294)), 4294967294);
-    assert_eq!(call!(xor_ui32(1, 4294967295)), 4294967294);
-    assert_eq!(call!(xor_ui32(4294967294, 0)), 4294967294);
-    assert_eq!(call!(xor_ui32(4294967295, 1)), 4294967294);
-    assert_eq!(call!(xor_ui32(0, 4294967295)), 4294967295);
-    assert_eq!(call!(xor_ui32(1, 4294967294)), 4294967295);
-    assert_eq!(call!(xor_ui32(4294967294, 1)), 4294967295);
-    assert_eq!(call!(xor_ui32(4294967295, 0)), 4294967295);
-    assert_eq!(call!(xor_ui64(0, 0)), 0);
-    assert_eq!(call!(xor_ui64(1, 1)), 0);
-    assert_eq!(call!(xor_ui64(2, 2)), 0);
-    assert_eq!(call!(xor_ui64(3, 3)), 0);
-    assert_eq!(call!(xor_ui64(4, 4)), 0);
-    assert_eq!(call!(xor_ui64(191084152064409600, 191084152064409600)), 0);
-    assert_eq!(call!(xor_ui64(11015955194427482112, 11015955194427482112)), 0);
-    assert_eq!(call!(xor_ui64(16990600415051759616, 16990600415051759616)), 0);
-    assert_eq!(call!(xor_ui64(18446744073709551614, 18446744073709551614)), 0);
-    assert_eq!(call!(xor_ui64(18446744073709551615, 18446744073709551615)), 0);
-    assert_eq!(call!(xor_ui64(0, 1)), 1);
-    assert_eq!(call!(xor_ui64(1, 0)), 1);
-    assert_eq!(call!(xor_ui64(2, 3)), 1);
-    assert_eq!(call!(xor_ui64(3, 2)), 1);
-    assert_eq!(call!(xor_ui64(18446744073709551614, 18446744073709551615)), 1);
-    assert_eq!(call!(xor_ui64(18446744073709551615, 18446744073709551614)), 1);
-    assert_eq!(call!(xor_ui64(0, 2)), 2);
-    assert_eq!(call!(xor_ui64(1, 3)), 2);
-    assert_eq!(call!(xor_ui64(2, 0)), 2);
-    assert_eq!(call!(xor_ui64(3, 1)), 2);
-    assert_eq!(call!(xor_ui64(0, 3)), 3);
-    assert_eq!(call!(xor_ui64(1, 2)), 3);
-    assert_eq!(call!(xor_ui64(2, 1)), 3);
-    assert_eq!(call!(xor_ui64(3, 0)), 3);
-    assert_eq!(call!(xor_ui64(0, 4)), 4);
-    assert_eq!(call!(xor_ui64(4, 0)), 4);
-    assert_eq!(call!(xor_ui64(1, 4)), 5);
-    assert_eq!(call!(xor_ui64(4, 1)), 5);
-    assert_eq!(call!(xor_ui64(2, 4)), 6);
-    assert_eq!(call!(xor_ui64(4, 2)), 6);
-    assert_eq!(call!(xor_ui64(3, 4)), 7);
-    assert_eq!(call!(xor_ui64(4, 3)), 7);
-    assert_eq!(call!(xor_ui64(0, 191084152064409600)), 191084152064409600);
-    assert_eq!(call!(xor_ui64(191084152064409600, 0)), 191084152064409600);
-    assert_eq!(call!(xor_ui64(1, 191084152064409600)), 191084152064409601);
-    assert_eq!(call!(xor_ui64(191084152064409600, 1)), 191084152064409601);
-    assert_eq!(call!(xor_ui64(2, 191084152064409600)), 191084152064409602);
-    assert_eq!(call!(xor_ui64(191084152064409600, 2)), 191084152064409602);
-    assert_eq!(call!(xor_ui64(3, 191084152064409600)), 191084152064409603);
-    assert_eq!(call!(xor_ui64(191084152064409600, 3)), 191084152064409603);
-    assert_eq!(call!(xor_ui64(4, 191084152064409600)), 191084152064409604);
-    assert_eq!(call!(xor_ui64(191084152064409600, 4)), 191084152064409604);
-    assert_eq!(call!(xor_ui64(16990600415051759616, 18446744073709551614)), 1456143658657791998);
-    assert_eq!(call!(xor_ui64(18446744073709551614, 16990600415051759616)), 1456143658657791998);
-    assert_eq!(call!(xor_ui64(16990600415051759616, 18446744073709551615)), 1456143658657791999);
-    assert_eq!(call!(xor_ui64(18446744073709551615, 16990600415051759616)), 1456143658657791999);
-    assert_eq!(call!(xor_ui64(11015955194427482112, 18446744073709551614)), 7430788879282069502);
-    assert_eq!(call!(xor_ui64(18446744073709551614, 11015955194427482112)), 7430788879282069502);
-    assert_eq!(call!(xor_ui64(11015955194427482112, 18446744073709551615)), 7430788879282069503);
-    assert_eq!(call!(xor_ui64(18446744073709551615, 11015955194427482112)), 7430788879282069503);
-    assert_eq!(call!(xor_ui64(11015955194427482112, 16990600415051759616)), 8298504554647642112);
-    assert_eq!(call!(xor_ui64(16990600415051759616, 11015955194427482112)), 8298504554647642112);
-    assert_eq!(call!(xor_ui64(0, 11015955194427482112)), 11015955194427482112);
-    assert_eq!(call!(xor_ui64(11015955194427482112, 0)), 11015955194427482112);
-    assert_eq!(call!(xor_ui64(1, 11015955194427482112)), 11015955194427482113);
-    assert_eq!(call!(xor_ui64(11015955194427482112, 1)), 11015955194427482113);
-    assert_eq!(call!(xor_ui64(2, 11015955194427482112)), 11015955194427482114);
-    assert_eq!(call!(xor_ui64(11015955194427482112, 2)), 11015955194427482114);
-    assert_eq!(call!(xor_ui64(3, 11015955194427482112)), 11015955194427482115);
-    assert_eq!(call!(xor_ui64(11015955194427482112, 3)), 11015955194427482115);
-    assert_eq!(call!(xor_ui64(4, 11015955194427482112)), 11015955194427482116);
-    assert_eq!(call!(xor_ui64(11015955194427482112, 4)), 11015955194427482116);
-    assert_eq!(call!(xor_ui64(191084152064409600, 11015955194427482112)), 11116668269601857536);
-    assert_eq!(call!(xor_ui64(11015955194427482112, 191084152064409600)), 11116668269601857536);
-    assert_eq!(call!(xor_ui64(191084152064409600, 16990600415051759616)), 16819927597248036864);
-    assert_eq!(call!(xor_ui64(16990600415051759616, 191084152064409600)), 16819927597248036864);
-    assert_eq!(call!(xor_ui64(0, 16990600415051759616)), 16990600415051759616);
-    assert_eq!(call!(xor_ui64(16990600415051759616, 0)), 16990600415051759616);
-    assert_eq!(call!(xor_ui64(1, 16990600415051759616)), 16990600415051759617);
-    assert_eq!(call!(xor_ui64(16990600415051759616, 1)), 16990600415051759617);
-    assert_eq!(call!(xor_ui64(2, 16990600415051759616)), 16990600415051759618);
-    assert_eq!(call!(xor_ui64(16990600415051759616, 2)), 16990600415051759618);
-    assert_eq!(call!(xor_ui64(3, 16990600415051759616)), 16990600415051759619);
-    assert_eq!(call!(xor_ui64(16990600415051759616, 3)), 16990600415051759619);
-    assert_eq!(call!(xor_ui64(4, 16990600415051759616)), 16990600415051759620);
-    assert_eq!(call!(xor_ui64(16990600415051759616, 4)), 16990600415051759620);
-    assert_eq!(call!(xor_ui64(191084152064409600, 18446744073709551614)), 18255659921645142014);
-    assert_eq!(call!(xor_ui64(18446744073709551614, 191084152064409600)), 18255659921645142014);
-    assert_eq!(call!(xor_ui64(191084152064409600, 18446744073709551615)), 18255659921645142015);
-    assert_eq!(call!(xor_ui64(18446744073709551615, 191084152064409600)), 18255659921645142015);
-    assert_eq!(call!(xor_ui64(4, 18446744073709551614)), 18446744073709551610);
-    assert_eq!(call!(xor_ui64(18446744073709551614, 4)), 18446744073709551610);
-    assert_eq!(call!(xor_ui64(4, 18446744073709551615)), 18446744073709551611);
-    assert_eq!(call!(xor_ui64(18446744073709551615, 4)), 18446744073709551611);
-    assert_eq!(call!(xor_ui64(2, 18446744073709551614)), 18446744073709551612);
-    assert_eq!(call!(xor_ui64(3, 18446744073709551615)), 18446744073709551612);
-    assert_eq!(call!(xor_ui64(18446744073709551614, 2)), 18446744073709551612);
-    assert_eq!(call!(xor_ui64(18446744073709551615, 3)), 18446744073709551612);
-    assert_eq!(call!(xor_ui64(2, 18446744073709551615)), 18446744073709551613);
-    assert_eq!(call!(xor_ui64(3, 18446744073709551614)), 18446744073709551613);
-    assert_eq!(call!(xor_ui64(18446744073709551614, 3)), 18446744073709551613);
-    assert_eq!(call!(xor_ui64(18446744073709551615, 2)), 18446744073709551613);
-    assert_eq!(call!(xor_ui64(0, 18446744073709551614)), 18446744073709551614);
-    assert_eq!(call!(xor_ui64(1, 18446744073709551615)), 18446744073709551614);
-    assert_eq!(call!(xor_ui64(18446744073709551614, 0)), 18446744073709551614);
-    assert_eq!(call!(xor_ui64(18446744073709551615, 1)), 18446744073709551614);
-    assert_eq!(call!(xor_ui64(0, 18446744073709551615)), 18446744073709551615);
-    assert_eq!(call!(xor_ui64(1, 18446744073709551614)), 18446744073709551615);
-    assert_eq!(call!(xor_ui64(18446744073709551614, 1)), 18446744073709551615);
-    assert_eq!(call!(xor_ui64(18446744073709551615, 0)), 18446744073709551615);
-    assert_eq!(call!(xor_ui8(0, 0)), 0);
-    assert_eq!(call!(xor_ui8(1, 1)), 0);
-    assert_eq!(call!(xor_ui8(2, 2)), 0);
-    assert_eq!(call!(xor_ui8(3, 3)), 0);
-    assert_eq!(call!(xor_ui8(4, 4)), 0);
-    assert_eq!(call!(xor_ui8(72, 72)), 0);
-    assert_eq!(call!(xor_ui8(100, 100)), 0);
-    assert_eq!(call!(xor_ui8(162, 162)), 0);
-    assert_eq!(call!(xor_ui8(254, 254)), 0);
-    assert_eq!(call!(xor_ui8(255, 255)), 0);
-    assert_eq!(call!(xor_ui8(0, 1)), 1);
-    assert_eq!(call!(xor_ui8(1, 0)), 1);
-    assert_eq!(call!(xor_ui8(2, 3)), 1);
-    assert_eq!(call!(xor_ui8(3, 2)), 1);
-    assert_eq!(call!(xor_ui8(254, 255)), 1);
-    assert_eq!(call!(xor_ui8(255, 254)), 1);
-    assert_eq!(call!(xor_ui8(0, 2)), 2);
-    assert_eq!(call!(xor_ui8(1, 3)), 2);
-    assert_eq!(call!(xor_ui8(2, 0)), 2);
-    assert_eq!(call!(xor_ui8(3, 1)), 2);
-    assert_eq!(call!(xor_ui8(0, 3)), 3);
-    assert_eq!(call!(xor_ui8(1, 2)), 3);
-    assert_eq!(call!(xor_ui8(2, 1)), 3);
-    assert_eq!(call!(xor_ui8(3, 0)), 3);
-    assert_eq!(call!(xor_ui8(0, 4)), 4);
-    assert_eq!(call!(xor_ui8(4, 0)), 4);
-    assert_eq!(call!(xor_ui8(1, 4)), 5);
-    assert_eq!(call!(xor_ui8(4, 1)), 5);
-    assert_eq!(call!(xor_ui8(2, 4)), 6);
-    assert_eq!(call!(xor_ui8(4, 2)), 6);
-    assert_eq!(call!(xor_ui8(3, 4)), 7);
-    assert_eq!(call!(xor_ui8(4, 3)), 7);
-    assert_eq!(call!(xor_ui8(72, 100)), 44);
-    assert_eq!(call!(xor_ui8(100, 72)), 44);
-    assert_eq!(call!(xor_ui8(0, 72)), 72);
-    assert_eq!(call!(xor_ui8(72, 0)), 72);
-    assert_eq!(call!(xor_ui8(1, 72)), 73);
-    assert_eq!(call!(xor_ui8(72, 1)), 73);
-    assert_eq!(call!(xor_ui8(2, 72)), 74);
-    assert_eq!(call!(xor_ui8(72, 2)), 74);
-    assert_eq!(call!(xor_ui8(3, 72)), 75);
-    assert_eq!(call!(xor_ui8(72, 3)), 75);
-    assert_eq!(call!(xor_ui8(4, 72)), 76);
-    assert_eq!(call!(xor_ui8(72, 4)), 76);
-    assert_eq!(call!(xor_ui8(162, 254)), 92);
-    assert_eq!(call!(xor_ui8(254, 162)), 92);
-    assert_eq!(call!(xor_ui8(162, 255)), 93);
-    assert_eq!(call!(xor_ui8(255, 162)), 93);
-    assert_eq!(call!(xor_ui8(4, 100)), 96);
-    assert_eq!(call!(xor_ui8(100, 4)), 96);
-    assert_eq!(call!(xor_ui8(0, 100)), 100);
-    assert_eq!(call!(xor_ui8(100, 0)), 100);
-    assert_eq!(call!(xor_ui8(1, 100)), 101);
-    assert_eq!(call!(xor_ui8(100, 1)), 101);
-    assert_eq!(call!(xor_ui8(2, 100)), 102);
-    assert_eq!(call!(xor_ui8(100, 2)), 102);
-    assert_eq!(call!(xor_ui8(3, 100)), 103);
-    assert_eq!(call!(xor_ui8(100, 3)), 103);
-    assert_eq!(call!(xor_ui8(100, 254)), 154);
-    assert_eq!(call!(xor_ui8(254, 100)), 154);
-    assert_eq!(call!(xor_ui8(100, 255)), 155);
-    assert_eq!(call!(xor_ui8(255, 100)), 155);
-    assert_eq!(call!(xor_ui8(2, 162)), 160);
-    assert_eq!(call!(xor_ui8(162, 2)), 160);
-    assert_eq!(call!(xor_ui8(3, 162)), 161);
-    assert_eq!(call!(xor_ui8(162, 3)), 161);
-    assert_eq!(call!(xor_ui8(0, 162)), 162);
-    assert_eq!(call!(xor_ui8(162, 0)), 162);
-    assert_eq!(call!(xor_ui8(1, 162)), 163);
-    assert_eq!(call!(xor_ui8(162, 1)), 163);
-    assert_eq!(call!(xor_ui8(4, 162)), 166);
-    assert_eq!(call!(xor_ui8(162, 4)), 166);
-    assert_eq!(call!(xor_ui8(72, 254)), 182);
-    assert_eq!(call!(xor_ui8(254, 72)), 182);
-    assert_eq!(call!(xor_ui8(72, 255)), 183);
-    assert_eq!(call!(xor_ui8(255, 72)), 183);
-    assert_eq!(call!(xor_ui8(100, 162)), 198);
-    assert_eq!(call!(xor_ui8(162, 100)), 198);
-    assert_eq!(call!(xor_ui8(72, 162)), 234);
-    assert_eq!(call!(xor_ui8(162, 72)), 234);
-    assert_eq!(call!(xor_ui8(4, 254)), 250);
-    assert_eq!(call!(xor_ui8(254, 4)), 250);
-    assert_eq!(call!(xor_ui8(4, 255)), 251);
-    assert_eq!(call!(xor_ui8(255, 4)), 251);
-    assert_eq!(call!(xor_ui8(2, 254)), 252);
-    assert_eq!(call!(xor_ui8(3, 255)), 252);
-    assert_eq!(call!(xor_ui8(254, 2)), 252);
-    assert_eq!(call!(xor_ui8(255, 3)), 252);
-    assert_eq!(call!(xor_ui8(2, 255)), 253);
-    assert_eq!(call!(xor_ui8(3, 254)), 253);
-    assert_eq!(call!(xor_ui8(254, 3)), 253);
-    assert_eq!(call!(xor_ui8(255, 2)), 253);
-    assert_eq!(call!(xor_ui8(0, 254)), 254);
-    assert_eq!(call!(xor_ui8(1, 255)), 254);
-    assert_eq!(call!(xor_ui8(254, 0)), 254);
-    assert_eq!(call!(xor_ui8(255, 1)), 254);
-    assert_eq!(call!(xor_ui8(0, 255)), 255);
-    assert_eq!(call!(xor_ui8(1, 254)), 255);
-    assert_eq!(call!(xor_ui8(254, 1)), 255);
-    assert_eq!(call!(xor_ui8(255, 0)), 255);
-  }
+    use crate::arctorustintbitops::*;
+    #[test]
+    fn it_works() {
+        assert_eq!(and_si16(-32768, -32768), -32768);
+        assert_eq!(and_si16(-32768, -32767), -32768);
+        assert_eq!(and_si16(-32768, -32547), -32768);
+        assert_eq!(and_si16(-32767, -32768), -32768);
+        assert_eq!(and_si16(-32547, -32768), -32768);
+        assert_eq!(and_si16(-32767, -32767), -32767);
+        assert_eq!(and_si16(-32767, -32547), -32767);
+        assert_eq!(and_si16(-32547, -32767), -32767);
+        assert_eq!(and_si16(-32547, -32547), -32547);
+        assert_eq!(and_si16(-32768, 0), 0);
+        assert_eq!(and_si16(-32768, 1), 0);
+        assert_eq!(and_si16(-32768, 2), 0);
+        assert_eq!(and_si16(-32768, 3), 0);
+        assert_eq!(and_si16(-32768, 4), 0);
+        assert_eq!(and_si16(-32768, 10486), 0);
+        assert_eq!(and_si16(-32768, 16514), 0);
+        assert_eq!(and_si16(-32768, 32766), 0);
+        assert_eq!(and_si16(-32768, 32767), 0);
+        assert_eq!(and_si16(-32767, 0), 0);
+        assert_eq!(and_si16(-32767, 2), 0);
+        assert_eq!(and_si16(-32767, 4), 0);
+        assert_eq!(and_si16(-32767, 10486), 0);
+        assert_eq!(and_si16(-32767, 16514), 0);
+        assert_eq!(and_si16(-32767, 32766), 0);
+        assert_eq!(and_si16(-32547, 0), 0);
+        assert_eq!(and_si16(-32547, 2), 0);
+        assert_eq!(and_si16(0, -32768), 0);
+        assert_eq!(and_si16(0, -32767), 0);
+        assert_eq!(and_si16(0, -32547), 0);
+        assert_eq!(and_si16(0, 0), 0);
+        assert_eq!(and_si16(0, 1), 0);
+        assert_eq!(and_si16(0, 2), 0);
+        assert_eq!(and_si16(0, 3), 0);
+        assert_eq!(and_si16(0, 4), 0);
+        assert_eq!(and_si16(0, 10486), 0);
+        assert_eq!(and_si16(0, 16514), 0);
+        assert_eq!(and_si16(0, 32766), 0);
+        assert_eq!(and_si16(0, 32767), 0);
+        assert_eq!(and_si16(1, -32768), 0);
+        assert_eq!(and_si16(1, 0), 0);
+        assert_eq!(and_si16(1, 2), 0);
+        assert_eq!(and_si16(1, 4), 0);
+        assert_eq!(and_si16(1, 10486), 0);
+        assert_eq!(and_si16(1, 16514), 0);
+        assert_eq!(and_si16(1, 32766), 0);
+        assert_eq!(and_si16(2, -32768), 0);
+        assert_eq!(and_si16(2, -32767), 0);
+        assert_eq!(and_si16(2, -32547), 0);
+        assert_eq!(and_si16(2, 0), 0);
+        assert_eq!(and_si16(2, 1), 0);
+        assert_eq!(and_si16(2, 4), 0);
+        assert_eq!(and_si16(3, -32768), 0);
+        assert_eq!(and_si16(3, 0), 0);
+        assert_eq!(and_si16(3, 4), 0);
+        assert_eq!(and_si16(4, -32768), 0);
+        assert_eq!(and_si16(4, -32767), 0);
+        assert_eq!(and_si16(4, 0), 0);
+        assert_eq!(and_si16(4, 1), 0);
+        assert_eq!(and_si16(4, 2), 0);
+        assert_eq!(and_si16(4, 3), 0);
+        assert_eq!(and_si16(4, 16514), 0);
+        assert_eq!(and_si16(10486, -32768), 0);
+        assert_eq!(and_si16(10486, -32767), 0);
+        assert_eq!(and_si16(10486, 0), 0);
+        assert_eq!(and_si16(10486, 1), 0);
+        assert_eq!(and_si16(16514, -32768), 0);
+        assert_eq!(and_si16(16514, -32767), 0);
+        assert_eq!(and_si16(16514, 0), 0);
+        assert_eq!(and_si16(16514, 1), 0);
+        assert_eq!(and_si16(16514, 4), 0);
+        assert_eq!(and_si16(32766, -32768), 0);
+        assert_eq!(and_si16(32766, -32767), 0);
+        assert_eq!(and_si16(32766, 0), 0);
+        assert_eq!(and_si16(32766, 1), 0);
+        assert_eq!(and_si16(32767, -32768), 0);
+        assert_eq!(and_si16(32767, 0), 0);
+        assert_eq!(and_si16(-32767, 1), 1);
+        assert_eq!(and_si16(-32767, 3), 1);
+        assert_eq!(and_si16(-32767, 32767), 1);
+        assert_eq!(and_si16(-32547, 1), 1);
+        assert_eq!(and_si16(-32547, 3), 1);
+        assert_eq!(and_si16(1, -32767), 1);
+        assert_eq!(and_si16(1, -32547), 1);
+        assert_eq!(and_si16(1, 1), 1);
+        assert_eq!(and_si16(1, 3), 1);
+        assert_eq!(and_si16(1, 32767), 1);
+        assert_eq!(and_si16(3, -32767), 1);
+        assert_eq!(and_si16(3, -32547), 1);
+        assert_eq!(and_si16(3, 1), 1);
+        assert_eq!(and_si16(32767, -32767), 1);
+        assert_eq!(and_si16(32767, 1), 1);
+        assert_eq!(and_si16(2, 2), 2);
+        assert_eq!(and_si16(2, 3), 2);
+        assert_eq!(and_si16(2, 10486), 2);
+        assert_eq!(and_si16(2, 16514), 2);
+        assert_eq!(and_si16(2, 32766), 2);
+        assert_eq!(and_si16(2, 32767), 2);
+        assert_eq!(and_si16(3, 2), 2);
+        assert_eq!(and_si16(3, 10486), 2);
+        assert_eq!(and_si16(3, 16514), 2);
+        assert_eq!(and_si16(3, 32766), 2);
+        assert_eq!(and_si16(10486, 2), 2);
+        assert_eq!(and_si16(10486, 3), 2);
+        assert_eq!(and_si16(16514, 2), 2);
+        assert_eq!(and_si16(16514, 3), 2);
+        assert_eq!(and_si16(32766, 2), 2);
+        assert_eq!(and_si16(32766, 3), 2);
+        assert_eq!(and_si16(32767, 2), 2);
+        assert_eq!(and_si16(3, 3), 3);
+        assert_eq!(and_si16(3, 32767), 3);
+        assert_eq!(and_si16(32767, 3), 3);
+        assert_eq!(and_si16(-32547, 4), 4);
+        assert_eq!(and_si16(4, -32547), 4);
+        assert_eq!(and_si16(4, 4), 4);
+        assert_eq!(and_si16(4, 10486), 4);
+        assert_eq!(and_si16(4, 32766), 4);
+        assert_eq!(and_si16(4, 32767), 4);
+        assert_eq!(and_si16(10486, 4), 4);
+        assert_eq!(and_si16(32766, 4), 4);
+        assert_eq!(and_si16(32767, 4), 4);
+        assert_eq!(and_si16(-32547, 16514), 128);
+        assert_eq!(and_si16(16514, -32547), 128);
+        assert_eq!(and_si16(10486, 16514), 130);
+        assert_eq!(and_si16(16514, 10486), 130);
+        assert_eq!(and_si16(-32547, 10486), 212);
+        assert_eq!(and_si16(10486, -32547), 212);
+        assert_eq!(and_si16(-32547, 32766), 220);
+        assert_eq!(and_si16(32766, -32547), 220);
+        assert_eq!(and_si16(-32547, 32767), 221);
+        assert_eq!(and_si16(32767, -32547), 221);
+        assert_eq!(and_si16(10486, 10486), 10486);
+        assert_eq!(and_si16(10486, 32766), 10486);
+        assert_eq!(and_si16(10486, 32767), 10486);
+        assert_eq!(and_si16(32766, 10486), 10486);
+        assert_eq!(and_si16(32767, 10486), 10486);
+        assert_eq!(and_si16(16514, 16514), 16514);
+        assert_eq!(and_si16(16514, 32766), 16514);
+        assert_eq!(and_si16(16514, 32767), 16514);
+        assert_eq!(and_si16(32766, 16514), 16514);
+        assert_eq!(and_si16(32767, 16514), 16514);
+        assert_eq!(and_si16(32766, 32766), 32766);
+        assert_eq!(and_si16(32766, 32767), 32766);
+        assert_eq!(and_si16(32767, 32766), 32766);
+        assert_eq!(and_si16(32767, 32767), 32767);
+        assert_eq!(and_si32(-2147483648, -2147483648), -2147483648);
+        assert_eq!(and_si32(-2147483648, -2147483647), -2147483648);
+        assert_eq!(and_si32(-2147483648, -1713183800), -2147483648);
+        assert_eq!(and_si32(-2147483648, -1252582164), -2147483648);
+        assert_eq!(and_si32(-2147483648, -1035405763), -2147483648);
+        assert_eq!(and_si32(-2147483647, -2147483648), -2147483648);
+        assert_eq!(and_si32(-2147483647, -1713183800), -2147483648);
+        assert_eq!(and_si32(-2147483647, -1252582164), -2147483648);
+        assert_eq!(and_si32(-1713183800, -2147483648), -2147483648);
+        assert_eq!(and_si32(-1713183800, -2147483647), -2147483648);
+        assert_eq!(and_si32(-1252582164, -2147483648), -2147483648);
+        assert_eq!(and_si32(-1252582164, -2147483647), -2147483648);
+        assert_eq!(and_si32(-1035405763, -2147483648), -2147483648);
+        assert_eq!(and_si32(-2147483647, -2147483647), -2147483647);
+        assert_eq!(and_si32(-2147483647, -1035405763), -2147483647);
+        assert_eq!(and_si32(-1035405763, -2147483647), -2147483647);
+        assert_eq!(and_si32(-1252582164, -1035405763), -2143284180);
+        assert_eq!(and_si32(-1035405763, -1252582164), -2143284180);
+        assert_eq!(and_si32(-1713183800, -1035405763), -2143231480);
+        assert_eq!(and_si32(-1035405763, -1713183800), -2143231480);
+        assert_eq!(and_si32(-1713183800, -1252582164), -1857945400);
+        assert_eq!(and_si32(-1252582164, -1713183800), -1857945400);
+        assert_eq!(and_si32(-1713183800, -1713183800), -1713183800);
+        assert_eq!(and_si32(-1252582164, -1252582164), -1252582164);
+        assert_eq!(and_si32(-1035405763, -1035405763), -1035405763);
+        assert_eq!(and_si32(-2147483648, 0), 0);
+        assert_eq!(and_si32(-2147483648, 1), 0);
+        assert_eq!(and_si32(-2147483648, 2), 0);
+        assert_eq!(and_si32(-2147483648, 3), 0);
+        assert_eq!(and_si32(-2147483648, 4), 0);
+        assert_eq!(and_si32(-2147483648, 2147483646), 0);
+        assert_eq!(and_si32(-2147483648, 2147483647), 0);
+        assert_eq!(and_si32(-2147483647, 0), 0);
+        assert_eq!(and_si32(-2147483647, 2), 0);
+        assert_eq!(and_si32(-2147483647, 4), 0);
+        assert_eq!(and_si32(-2147483647, 2147483646), 0);
+        assert_eq!(and_si32(-1713183800, 0), 0);
+        assert_eq!(and_si32(-1713183800, 1), 0);
+        assert_eq!(and_si32(-1713183800, 2), 0);
+        assert_eq!(and_si32(-1713183800, 3), 0);
+        assert_eq!(and_si32(-1713183800, 4), 0);
+        assert_eq!(and_si32(-1252582164, 0), 0);
+        assert_eq!(and_si32(-1252582164, 1), 0);
+        assert_eq!(and_si32(-1252582164, 2), 0);
+        assert_eq!(and_si32(-1252582164, 3), 0);
+        assert_eq!(and_si32(-1035405763, 0), 0);
+        assert_eq!(and_si32(-1035405763, 2), 0);
+        assert_eq!(and_si32(0, -2147483648), 0);
+        assert_eq!(and_si32(0, -2147483647), 0);
+        assert_eq!(and_si32(0, -1713183800), 0);
+        assert_eq!(and_si32(0, -1252582164), 0);
+        assert_eq!(and_si32(0, -1035405763), 0);
+        assert_eq!(and_si32(0, 0), 0);
+        assert_eq!(and_si32(0, 1), 0);
+        assert_eq!(and_si32(0, 2), 0);
+        assert_eq!(and_si32(0, 3), 0);
+        assert_eq!(and_si32(0, 4), 0);
+        assert_eq!(and_si32(0, 2147483646), 0);
+        assert_eq!(and_si32(0, 2147483647), 0);
+        assert_eq!(and_si32(1, -2147483648), 0);
+        assert_eq!(and_si32(1, -1713183800), 0);
+        assert_eq!(and_si32(1, -1252582164), 0);
+        assert_eq!(and_si32(1, 0), 0);
+        assert_eq!(and_si32(1, 2), 0);
+        assert_eq!(and_si32(1, 4), 0);
+        assert_eq!(and_si32(1, 2147483646), 0);
+        assert_eq!(and_si32(2, -2147483648), 0);
+        assert_eq!(and_si32(2, -2147483647), 0);
+        assert_eq!(and_si32(2, -1713183800), 0);
+        assert_eq!(and_si32(2, -1252582164), 0);
+        assert_eq!(and_si32(2, -1035405763), 0);
+        assert_eq!(and_si32(2, 0), 0);
+        assert_eq!(and_si32(2, 1), 0);
+        assert_eq!(and_si32(2, 4), 0);
+        assert_eq!(and_si32(3, -2147483648), 0);
+        assert_eq!(and_si32(3, -1713183800), 0);
+        assert_eq!(and_si32(3, -1252582164), 0);
+        assert_eq!(and_si32(3, 0), 0);
+        assert_eq!(and_si32(3, 4), 0);
+        assert_eq!(and_si32(4, -2147483648), 0);
+        assert_eq!(and_si32(4, -2147483647), 0);
+        assert_eq!(and_si32(4, -1713183800), 0);
+        assert_eq!(and_si32(4, 0), 0);
+        assert_eq!(and_si32(4, 1), 0);
+        assert_eq!(and_si32(4, 2), 0);
+        assert_eq!(and_si32(4, 3), 0);
+        assert_eq!(and_si32(2147483646, -2147483648), 0);
+        assert_eq!(and_si32(2147483646, -2147483647), 0);
+        assert_eq!(and_si32(2147483646, 0), 0);
+        assert_eq!(and_si32(2147483646, 1), 0);
+        assert_eq!(and_si32(2147483647, -2147483648), 0);
+        assert_eq!(and_si32(2147483647, 0), 0);
+        assert_eq!(and_si32(-2147483647, 1), 1);
+        assert_eq!(and_si32(-2147483647, 3), 1);
+        assert_eq!(and_si32(-2147483647, 2147483647), 1);
+        assert_eq!(and_si32(-1035405763, 1), 1);
+        assert_eq!(and_si32(-1035405763, 3), 1);
+        assert_eq!(and_si32(1, -2147483647), 1);
+        assert_eq!(and_si32(1, -1035405763), 1);
+        assert_eq!(and_si32(1, 1), 1);
+        assert_eq!(and_si32(1, 3), 1);
+        assert_eq!(and_si32(1, 2147483647), 1);
+        assert_eq!(and_si32(3, -2147483647), 1);
+        assert_eq!(and_si32(3, -1035405763), 1);
+        assert_eq!(and_si32(3, 1), 1);
+        assert_eq!(and_si32(2147483647, -2147483647), 1);
+        assert_eq!(and_si32(2147483647, 1), 1);
+        assert_eq!(and_si32(2, 2), 2);
+        assert_eq!(and_si32(2, 3), 2);
+        assert_eq!(and_si32(2, 2147483646), 2);
+        assert_eq!(and_si32(2, 2147483647), 2);
+        assert_eq!(and_si32(3, 2), 2);
+        assert_eq!(and_si32(3, 2147483646), 2);
+        assert_eq!(and_si32(2147483646, 2), 2);
+        assert_eq!(and_si32(2147483646, 3), 2);
+        assert_eq!(and_si32(2147483647, 2), 2);
+        assert_eq!(and_si32(3, 3), 3);
+        assert_eq!(and_si32(3, 2147483647), 3);
+        assert_eq!(and_si32(2147483647, 3), 3);
+        assert_eq!(and_si32(-1252582164, 4), 4);
+        assert_eq!(and_si32(-1035405763, 4), 4);
+        assert_eq!(and_si32(4, -1252582164), 4);
+        assert_eq!(and_si32(4, -1035405763), 4);
+        assert_eq!(and_si32(4, 4), 4);
+        assert_eq!(and_si32(4, 2147483646), 4);
+        assert_eq!(and_si32(4, 2147483647), 4);
+        assert_eq!(and_si32(2147483646, 4), 4);
+        assert_eq!(and_si32(2147483647, 4), 4);
+        assert_eq!(and_si32(-1713183800, 2147483646), 434299848);
+        assert_eq!(and_si32(-1713183800, 2147483647), 434299848);
+        assert_eq!(and_si32(2147483646, -1713183800), 434299848);
+        assert_eq!(and_si32(2147483647, -1713183800), 434299848);
+        assert_eq!(and_si32(-1252582164, 2147483646), 894901484);
+        assert_eq!(and_si32(-1252582164, 2147483647), 894901484);
+        assert_eq!(and_si32(2147483646, -1252582164), 894901484);
+        assert_eq!(and_si32(2147483647, -1252582164), 894901484);
+        assert_eq!(and_si32(-1035405763, 2147483646), 1112077884);
+        assert_eq!(and_si32(2147483646, -1035405763), 1112077884);
+        assert_eq!(and_si32(-1035405763, 2147483647), 1112077885);
+        assert_eq!(and_si32(2147483647, -1035405763), 1112077885);
+        assert_eq!(and_si32(2147483646, 2147483646), 2147483646);
+        assert_eq!(and_si32(2147483646, 2147483647), 2147483646);
+        assert_eq!(and_si32(2147483647, 2147483646), 2147483646);
+        assert_eq!(and_si32(2147483647, 2147483647), 2147483647);
+        assert_eq!(
+            and_si64(-9223372036854775808, -9223372036854775808),
+            -9223372036854775808
+        );
+        assert_eq!(
+            and_si64(-9223372036854775808, -9223372036854775807),
+            -9223372036854775808
+        );
+        assert_eq!(
+            and_si64(-9223372036854775808, -1741927215160008704),
+            -9223372036854775808
+        );
+        assert_eq!(
+            and_si64(-9223372036854775808, -1328271339354574848),
+            -9223372036854775808
+        );
+        assert_eq!(
+            and_si64(-9223372036854775807, -9223372036854775808),
+            -9223372036854775808
+        );
+        assert_eq!(
+            and_si64(-9223372036854775807, -1741927215160008704),
+            -9223372036854775808
+        );
+        assert_eq!(
+            and_si64(-9223372036854775807, -1328271339354574848),
+            -9223372036854775808
+        );
+        assert_eq!(
+            and_si64(-1741927215160008704, -9223372036854775808),
+            -9223372036854775808
+        );
+        assert_eq!(
+            and_si64(-1741927215160008704, -9223372036854775807),
+            -9223372036854775808
+        );
+        assert_eq!(
+            and_si64(-1328271339354574848, -9223372036854775808),
+            -9223372036854775808
+        );
+        assert_eq!(
+            and_si64(-1328271339354574848, -9223372036854775807),
+            -9223372036854775808
+        );
+        assert_eq!(
+            and_si64(-9223372036854775807, -9223372036854775807),
+            -9223372036854775807
+        );
+        assert_eq!(
+            and_si64(-1741927215160008704, -1328271339354574848),
+            -1904732091996692480
+        );
+        assert_eq!(
+            and_si64(-1328271339354574848, -1741927215160008704),
+            -1904732091996692480
+        );
+        assert_eq!(
+            and_si64(-1741927215160008704, -1741927215160008704),
+            -1741927215160008704
+        );
+        assert_eq!(
+            and_si64(-1328271339354574848, -1328271339354574848),
+            -1328271339354574848
+        );
+        assert_eq!(and_si64(-9223372036854775808, 0), 0);
+        assert_eq!(and_si64(-9223372036854775808, 1), 0);
+        assert_eq!(and_si64(-9223372036854775808, 2), 0);
+        assert_eq!(and_si64(-9223372036854775808, 3), 0);
+        assert_eq!(and_si64(-9223372036854775808, 4), 0);
+        assert_eq!(and_si64(-9223372036854775808, 5577148965131116544), 0);
+        assert_eq!(and_si64(-9223372036854775808, 9223372036854775806), 0);
+        assert_eq!(and_si64(-9223372036854775808, 9223372036854775807), 0);
+        assert_eq!(and_si64(-9223372036854775807, 0), 0);
+        assert_eq!(and_si64(-9223372036854775807, 2), 0);
+        assert_eq!(and_si64(-9223372036854775807, 4), 0);
+        assert_eq!(and_si64(-9223372036854775807, 5577148965131116544), 0);
+        assert_eq!(and_si64(-9223372036854775807, 9223372036854775806), 0);
+        assert_eq!(and_si64(-1741927215160008704, 0), 0);
+        assert_eq!(and_si64(-1741927215160008704, 1), 0);
+        assert_eq!(and_si64(-1741927215160008704, 2), 0);
+        assert_eq!(and_si64(-1741927215160008704, 3), 0);
+        assert_eq!(and_si64(-1741927215160008704, 4), 0);
+        assert_eq!(and_si64(-1328271339354574848, 0), 0);
+        assert_eq!(and_si64(-1328271339354574848, 1), 0);
+        assert_eq!(and_si64(-1328271339354574848, 2), 0);
+        assert_eq!(and_si64(-1328271339354574848, 3), 0);
+        assert_eq!(and_si64(-1328271339354574848, 4), 0);
+        assert_eq!(and_si64(0, -9223372036854775808), 0);
+        assert_eq!(and_si64(0, -9223372036854775807), 0);
+        assert_eq!(and_si64(0, -1741927215160008704), 0);
+        assert_eq!(and_si64(0, -1328271339354574848), 0);
+        assert_eq!(and_si64(0, 0), 0);
+        assert_eq!(and_si64(0, 1), 0);
+        assert_eq!(and_si64(0, 2), 0);
+        assert_eq!(and_si64(0, 3), 0);
+        assert_eq!(and_si64(0, 4), 0);
+        assert_eq!(and_si64(0, 5577148965131116544), 0);
+        assert_eq!(and_si64(0, 9223372036854775806), 0);
+        assert_eq!(and_si64(0, 9223372036854775807), 0);
+        assert_eq!(and_si64(1, -9223372036854775808), 0);
+        assert_eq!(and_si64(1, -1741927215160008704), 0);
+        assert_eq!(and_si64(1, -1328271339354574848), 0);
+        assert_eq!(and_si64(1, 0), 0);
+        assert_eq!(and_si64(1, 2), 0);
+        assert_eq!(and_si64(1, 4), 0);
+        assert_eq!(and_si64(1, 5577148965131116544), 0);
+        assert_eq!(and_si64(1, 9223372036854775806), 0);
+        assert_eq!(and_si64(2, -9223372036854775808), 0);
+        assert_eq!(and_si64(2, -9223372036854775807), 0);
+        assert_eq!(and_si64(2, -1741927215160008704), 0);
+        assert_eq!(and_si64(2, -1328271339354574848), 0);
+        assert_eq!(and_si64(2, 0), 0);
+        assert_eq!(and_si64(2, 1), 0);
+        assert_eq!(and_si64(2, 4), 0);
+        assert_eq!(and_si64(2, 5577148965131116544), 0);
+        assert_eq!(and_si64(3, -9223372036854775808), 0);
+        assert_eq!(and_si64(3, -1741927215160008704), 0);
+        assert_eq!(and_si64(3, -1328271339354574848), 0);
+        assert_eq!(and_si64(3, 0), 0);
+        assert_eq!(and_si64(3, 4), 0);
+        assert_eq!(and_si64(3, 5577148965131116544), 0);
+        assert_eq!(and_si64(4, -9223372036854775808), 0);
+        assert_eq!(and_si64(4, -9223372036854775807), 0);
+        assert_eq!(and_si64(4, -1741927215160008704), 0);
+        assert_eq!(and_si64(4, -1328271339354574848), 0);
+        assert_eq!(and_si64(4, 0), 0);
+        assert_eq!(and_si64(4, 1), 0);
+        assert_eq!(and_si64(4, 2), 0);
+        assert_eq!(and_si64(4, 3), 0);
+        assert_eq!(and_si64(4, 5577148965131116544), 0);
+        assert_eq!(and_si64(5577148965131116544, -9223372036854775808), 0);
+        assert_eq!(and_si64(5577148965131116544, -9223372036854775807), 0);
+        assert_eq!(and_si64(5577148965131116544, 0), 0);
+        assert_eq!(and_si64(5577148965131116544, 1), 0);
+        assert_eq!(and_si64(5577148965131116544, 2), 0);
+        assert_eq!(and_si64(5577148965131116544, 3), 0);
+        assert_eq!(and_si64(5577148965131116544, 4), 0);
+        assert_eq!(and_si64(9223372036854775806, -9223372036854775808), 0);
+        assert_eq!(and_si64(9223372036854775806, -9223372036854775807), 0);
+        assert_eq!(and_si64(9223372036854775806, 0), 0);
+        assert_eq!(and_si64(9223372036854775806, 1), 0);
+        assert_eq!(and_si64(9223372036854775807, -9223372036854775808), 0);
+        assert_eq!(and_si64(9223372036854775807, 0), 0);
+        assert_eq!(and_si64(-9223372036854775807, 1), 1);
+        assert_eq!(and_si64(-9223372036854775807, 3), 1);
+        assert_eq!(and_si64(-9223372036854775807, 9223372036854775807), 1);
+        assert_eq!(and_si64(1, -9223372036854775807), 1);
+        assert_eq!(and_si64(1, 1), 1);
+        assert_eq!(and_si64(1, 3), 1);
+        assert_eq!(and_si64(1, 9223372036854775807), 1);
+        assert_eq!(and_si64(3, -9223372036854775807), 1);
+        assert_eq!(and_si64(3, 1), 1);
+        assert_eq!(and_si64(9223372036854775807, -9223372036854775807), 1);
+        assert_eq!(and_si64(9223372036854775807, 1), 1);
+        assert_eq!(and_si64(2, 2), 2);
+        assert_eq!(and_si64(2, 3), 2);
+        assert_eq!(and_si64(2, 9223372036854775806), 2);
+        assert_eq!(and_si64(2, 9223372036854775807), 2);
+        assert_eq!(and_si64(3, 2), 2);
+        assert_eq!(and_si64(3, 9223372036854775806), 2);
+        assert_eq!(and_si64(9223372036854775806, 2), 2);
+        assert_eq!(and_si64(9223372036854775806, 3), 2);
+        assert_eq!(and_si64(9223372036854775807, 2), 2);
+        assert_eq!(and_si64(3, 3), 3);
+        assert_eq!(and_si64(3, 9223372036854775807), 3);
+        assert_eq!(and_si64(9223372036854775807, 3), 3);
+        assert_eq!(and_si64(4, 4), 4);
+        assert_eq!(and_si64(4, 9223372036854775806), 4);
+        assert_eq!(and_si64(4, 9223372036854775807), 4);
+        assert_eq!(and_si64(9223372036854775806, 4), 4);
+        assert_eq!(and_si64(9223372036854775807, 4), 4);
+        assert_eq!(
+            and_si64(-1741927215160008704, 5577148965131116544),
+            4990554005496225792
+        );
+        assert_eq!(
+            and_si64(5577148965131116544, -1741927215160008704),
+            4990554005496225792
+        );
+        assert_eq!(
+            and_si64(-1328271339354574848, 5577148965131116544),
+            5548435020295708672
+        );
+        assert_eq!(
+            and_si64(5577148965131116544, -1328271339354574848),
+            5548435020295708672
+        );
+        assert_eq!(
+            and_si64(5577148965131116544, 5577148965131116544),
+            5577148965131116544
+        );
+        assert_eq!(
+            and_si64(5577148965131116544, 9223372036854775806),
+            5577148965131116544
+        );
+        assert_eq!(
+            and_si64(5577148965131116544, 9223372036854775807),
+            5577148965131116544
+        );
+        assert_eq!(
+            and_si64(9223372036854775806, 5577148965131116544),
+            5577148965131116544
+        );
+        assert_eq!(
+            and_si64(9223372036854775807, 5577148965131116544),
+            5577148965131116544
+        );
+        assert_eq!(
+            and_si64(-1741927215160008704, 9223372036854775806),
+            7481444821694767104
+        );
+        assert_eq!(
+            and_si64(-1741927215160008704, 9223372036854775807),
+            7481444821694767104
+        );
+        assert_eq!(
+            and_si64(9223372036854775806, -1741927215160008704),
+            7481444821694767104
+        );
+        assert_eq!(
+            and_si64(9223372036854775807, -1741927215160008704),
+            7481444821694767104
+        );
+        assert_eq!(
+            and_si64(-1328271339354574848, 9223372036854775806),
+            7895100697500200960
+        );
+        assert_eq!(
+            and_si64(-1328271339354574848, 9223372036854775807),
+            7895100697500200960
+        );
+        assert_eq!(
+            and_si64(9223372036854775806, -1328271339354574848),
+            7895100697500200960
+        );
+        assert_eq!(
+            and_si64(9223372036854775807, -1328271339354574848),
+            7895100697500200960
+        );
+        assert_eq!(
+            and_si64(9223372036854775806, 9223372036854775806),
+            9223372036854775806
+        );
+        assert_eq!(
+            and_si64(9223372036854775806, 9223372036854775807),
+            9223372036854775806
+        );
+        assert_eq!(
+            and_si64(9223372036854775807, 9223372036854775806),
+            9223372036854775806
+        );
+        assert_eq!(
+            and_si64(9223372036854775807, 9223372036854775807),
+            9223372036854775807
+        );
+        assert_eq!(and_si8(-128, -128), -128);
+        assert_eq!(and_si8(-128, -127), -128);
+        assert_eq!(and_si8(-127, -128), -128);
+        assert_eq!(and_si8(-127, -127), -127);
+        assert_eq!(and_si8(-128, 0), 0);
+        assert_eq!(and_si8(-128, 1), 0);
+        assert_eq!(and_si8(-128, 2), 0);
+        assert_eq!(and_si8(-128, 3), 0);
+        assert_eq!(and_si8(-128, 4), 0);
+        assert_eq!(and_si8(-128, 16), 0);
+        assert_eq!(and_si8(-128, 126), 0);
+        assert_eq!(and_si8(-128, 127), 0);
+        assert_eq!(and_si8(-127, 0), 0);
+        assert_eq!(and_si8(-127, 2), 0);
+        assert_eq!(and_si8(-127, 4), 0);
+        assert_eq!(and_si8(-127, 16), 0);
+        assert_eq!(and_si8(-127, 126), 0);
+        assert_eq!(and_si8(0, -128), 0);
+        assert_eq!(and_si8(0, -127), 0);
+        assert_eq!(and_si8(0, 0), 0);
+        assert_eq!(and_si8(0, 1), 0);
+        assert_eq!(and_si8(0, 2), 0);
+        assert_eq!(and_si8(0, 3), 0);
+        assert_eq!(and_si8(0, 4), 0);
+        assert_eq!(and_si8(0, 16), 0);
+        assert_eq!(and_si8(0, 126), 0);
+        assert_eq!(and_si8(0, 127), 0);
+        assert_eq!(and_si8(1, -128), 0);
+        assert_eq!(and_si8(1, 0), 0);
+        assert_eq!(and_si8(1, 2), 0);
+        assert_eq!(and_si8(1, 4), 0);
+        assert_eq!(and_si8(1, 16), 0);
+        assert_eq!(and_si8(1, 126), 0);
+        assert_eq!(and_si8(2, -128), 0);
+        assert_eq!(and_si8(2, -127), 0);
+        assert_eq!(and_si8(2, 0), 0);
+        assert_eq!(and_si8(2, 1), 0);
+        assert_eq!(and_si8(2, 4), 0);
+        assert_eq!(and_si8(2, 16), 0);
+        assert_eq!(and_si8(3, -128), 0);
+        assert_eq!(and_si8(3, 0), 0);
+        assert_eq!(and_si8(3, 4), 0);
+        assert_eq!(and_si8(3, 16), 0);
+        assert_eq!(and_si8(4, -128), 0);
+        assert_eq!(and_si8(4, -127), 0);
+        assert_eq!(and_si8(4, 0), 0);
+        assert_eq!(and_si8(4, 1), 0);
+        assert_eq!(and_si8(4, 2), 0);
+        assert_eq!(and_si8(4, 3), 0);
+        assert_eq!(and_si8(4, 16), 0);
+        assert_eq!(and_si8(16, -128), 0);
+        assert_eq!(and_si8(16, -127), 0);
+        assert_eq!(and_si8(16, 0), 0);
+        assert_eq!(and_si8(16, 1), 0);
+        assert_eq!(and_si8(16, 2), 0);
+        assert_eq!(and_si8(16, 3), 0);
+        assert_eq!(and_si8(16, 4), 0);
+        assert_eq!(and_si8(126, -128), 0);
+        assert_eq!(and_si8(126, -127), 0);
+        assert_eq!(and_si8(126, 0), 0);
+        assert_eq!(and_si8(126, 1), 0);
+        assert_eq!(and_si8(127, -128), 0);
+        assert_eq!(and_si8(127, 0), 0);
+        assert_eq!(and_si8(-127, 1), 1);
+        assert_eq!(and_si8(-127, 3), 1);
+        assert_eq!(and_si8(-127, 127), 1);
+        assert_eq!(and_si8(1, -127), 1);
+        assert_eq!(and_si8(1, 1), 1);
+        assert_eq!(and_si8(1, 3), 1);
+        assert_eq!(and_si8(1, 127), 1);
+        assert_eq!(and_si8(3, -127), 1);
+        assert_eq!(and_si8(3, 1), 1);
+        assert_eq!(and_si8(127, -127), 1);
+        assert_eq!(and_si8(127, 1), 1);
+        assert_eq!(and_si8(2, 2), 2);
+        assert_eq!(and_si8(2, 3), 2);
+        assert_eq!(and_si8(2, 126), 2);
+        assert_eq!(and_si8(2, 127), 2);
+        assert_eq!(and_si8(3, 2), 2);
+        assert_eq!(and_si8(3, 126), 2);
+        assert_eq!(and_si8(126, 2), 2);
+        assert_eq!(and_si8(126, 3), 2);
+        assert_eq!(and_si8(127, 2), 2);
+        assert_eq!(and_si8(3, 3), 3);
+        assert_eq!(and_si8(3, 127), 3);
+        assert_eq!(and_si8(127, 3), 3);
+        assert_eq!(and_si8(4, 4), 4);
+        assert_eq!(and_si8(4, 126), 4);
+        assert_eq!(and_si8(4, 127), 4);
+        assert_eq!(and_si8(126, 4), 4);
+        assert_eq!(and_si8(127, 4), 4);
+        assert_eq!(and_si8(16, 16), 16);
+        assert_eq!(and_si8(16, 126), 16);
+        assert_eq!(and_si8(16, 127), 16);
+        assert_eq!(and_si8(126, 16), 16);
+        assert_eq!(and_si8(127, 16), 16);
+        assert_eq!(and_si8(126, 126), 126);
+        assert_eq!(and_si8(126, 127), 126);
+        assert_eq!(and_si8(127, 126), 126);
+        assert_eq!(and_si8(127, 127), 127);
+        assert_eq!(and_ui16(0, 0), 0);
+        assert_eq!(and_ui16(0, 1), 0);
+        assert_eq!(and_ui16(0, 2), 0);
+        assert_eq!(and_ui16(0, 3), 0);
+        assert_eq!(and_ui16(0, 4), 0);
+        assert_eq!(and_ui16(0, 1717), 0);
+        assert_eq!(and_ui16(0, 17988), 0);
+        assert_eq!(and_ui16(0, 65096), 0);
+        assert_eq!(and_ui16(0, 65534), 0);
+        assert_eq!(and_ui16(0, 65535), 0);
+        assert_eq!(and_ui16(1, 0), 0);
+        assert_eq!(and_ui16(1, 2), 0);
+        assert_eq!(and_ui16(1, 4), 0);
+        assert_eq!(and_ui16(1, 17988), 0);
+        assert_eq!(and_ui16(1, 65096), 0);
+        assert_eq!(and_ui16(1, 65534), 0);
+        assert_eq!(and_ui16(2, 0), 0);
+        assert_eq!(and_ui16(2, 1), 0);
+        assert_eq!(and_ui16(2, 4), 0);
+        assert_eq!(and_ui16(2, 1717), 0);
+        assert_eq!(and_ui16(2, 17988), 0);
+        assert_eq!(and_ui16(2, 65096), 0);
+        assert_eq!(and_ui16(3, 0), 0);
+        assert_eq!(and_ui16(3, 4), 0);
+        assert_eq!(and_ui16(3, 17988), 0);
+        assert_eq!(and_ui16(3, 65096), 0);
+        assert_eq!(and_ui16(4, 0), 0);
+        assert_eq!(and_ui16(4, 1), 0);
+        assert_eq!(and_ui16(4, 2), 0);
+        assert_eq!(and_ui16(4, 3), 0);
+        assert_eq!(and_ui16(4, 65096), 0);
+        assert_eq!(and_ui16(1717, 0), 0);
+        assert_eq!(and_ui16(1717, 2), 0);
+        assert_eq!(and_ui16(17988, 0), 0);
+        assert_eq!(and_ui16(17988, 1), 0);
+        assert_eq!(and_ui16(17988, 2), 0);
+        assert_eq!(and_ui16(17988, 3), 0);
+        assert_eq!(and_ui16(65096, 0), 0);
+        assert_eq!(and_ui16(65096, 1), 0);
+        assert_eq!(and_ui16(65096, 2), 0);
+        assert_eq!(and_ui16(65096, 3), 0);
+        assert_eq!(and_ui16(65096, 4), 0);
+        assert_eq!(and_ui16(65534, 0), 0);
+        assert_eq!(and_ui16(65534, 1), 0);
+        assert_eq!(and_ui16(65535, 0), 0);
+        assert_eq!(and_ui16(1, 1), 1);
+        assert_eq!(and_ui16(1, 3), 1);
+        assert_eq!(and_ui16(1, 1717), 1);
+        assert_eq!(and_ui16(1, 65535), 1);
+        assert_eq!(and_ui16(3, 1), 1);
+        assert_eq!(and_ui16(3, 1717), 1);
+        assert_eq!(and_ui16(1717, 1), 1);
+        assert_eq!(and_ui16(1717, 3), 1);
+        assert_eq!(and_ui16(65535, 1), 1);
+        assert_eq!(and_ui16(2, 2), 2);
+        assert_eq!(and_ui16(2, 3), 2);
+        assert_eq!(and_ui16(2, 65534), 2);
+        assert_eq!(and_ui16(2, 65535), 2);
+        assert_eq!(and_ui16(3, 2), 2);
+        assert_eq!(and_ui16(3, 65534), 2);
+        assert_eq!(and_ui16(65534, 2), 2);
+        assert_eq!(and_ui16(65534, 3), 2);
+        assert_eq!(and_ui16(65535, 2), 2);
+        assert_eq!(and_ui16(3, 3), 3);
+        assert_eq!(and_ui16(3, 65535), 3);
+        assert_eq!(and_ui16(65535, 3), 3);
+        assert_eq!(and_ui16(4, 4), 4);
+        assert_eq!(and_ui16(4, 1717), 4);
+        assert_eq!(and_ui16(4, 17988), 4);
+        assert_eq!(and_ui16(4, 65534), 4);
+        assert_eq!(and_ui16(4, 65535), 4);
+        assert_eq!(and_ui16(1717, 4), 4);
+        assert_eq!(and_ui16(17988, 4), 4);
+        assert_eq!(and_ui16(65534, 4), 4);
+        assert_eq!(and_ui16(65535, 4), 4);
+        assert_eq!(and_ui16(1717, 65096), 1536);
+        assert_eq!(and_ui16(65096, 1717), 1536);
+        assert_eq!(and_ui16(1717, 17988), 1540);
+        assert_eq!(and_ui16(17988, 1717), 1540);
+        assert_eq!(and_ui16(1717, 65534), 1716);
+        assert_eq!(and_ui16(65534, 1717), 1716);
+        assert_eq!(and_ui16(1717, 1717), 1717);
+        assert_eq!(and_ui16(1717, 65535), 1717);
+        assert_eq!(and_ui16(65535, 1717), 1717);
+        assert_eq!(and_ui16(17988, 65096), 17984);
+        assert_eq!(and_ui16(65096, 17988), 17984);
+        assert_eq!(and_ui16(17988, 17988), 17988);
+        assert_eq!(and_ui16(17988, 65534), 17988);
+        assert_eq!(and_ui16(17988, 65535), 17988);
+        assert_eq!(and_ui16(65534, 17988), 17988);
+        assert_eq!(and_ui16(65535, 17988), 17988);
+        assert_eq!(and_ui16(65096, 65096), 65096);
+        assert_eq!(and_ui16(65096, 65534), 65096);
+        assert_eq!(and_ui16(65096, 65535), 65096);
+        assert_eq!(and_ui16(65534, 65096), 65096);
+        assert_eq!(and_ui16(65535, 65096), 65096);
+        assert_eq!(and_ui16(65534, 65534), 65534);
+        assert_eq!(and_ui16(65534, 65535), 65534);
+        assert_eq!(and_ui16(65535, 65534), 65534);
+        assert_eq!(and_ui16(65535, 65535), 65535);
+        assert_eq!(and_ui32(0, 0), 0);
+        assert_eq!(and_ui32(0, 1), 0);
+        assert_eq!(and_ui32(0, 2), 0);
+        assert_eq!(and_ui32(0, 3), 0);
+        assert_eq!(and_ui32(0, 4), 0);
+        assert_eq!(and_ui32(0, 2119154652), 0);
+        assert_eq!(and_ui32(0, 3002788344), 0);
+        assert_eq!(and_ui32(0, 3482297128), 0);
+        assert_eq!(and_ui32(0, 4294967294), 0);
+        assert_eq!(and_ui32(0, 4294967295), 0);
+        assert_eq!(and_ui32(1, 0), 0);
+        assert_eq!(and_ui32(1, 2), 0);
+        assert_eq!(and_ui32(1, 4), 0);
+        assert_eq!(and_ui32(1, 2119154652), 0);
+        assert_eq!(and_ui32(1, 3002788344), 0);
+        assert_eq!(and_ui32(1, 3482297128), 0);
+        assert_eq!(and_ui32(1, 4294967294), 0);
+        assert_eq!(and_ui32(2, 0), 0);
+        assert_eq!(and_ui32(2, 1), 0);
+        assert_eq!(and_ui32(2, 4), 0);
+        assert_eq!(and_ui32(2, 2119154652), 0);
+        assert_eq!(and_ui32(2, 3002788344), 0);
+        assert_eq!(and_ui32(2, 3482297128), 0);
+        assert_eq!(and_ui32(3, 0), 0);
+        assert_eq!(and_ui32(3, 4), 0);
+        assert_eq!(and_ui32(3, 2119154652), 0);
+        assert_eq!(and_ui32(3, 3002788344), 0);
+        assert_eq!(and_ui32(3, 3482297128), 0);
+        assert_eq!(and_ui32(4, 0), 0);
+        assert_eq!(and_ui32(4, 1), 0);
+        assert_eq!(and_ui32(4, 2), 0);
+        assert_eq!(and_ui32(4, 3), 0);
+        assert_eq!(and_ui32(4, 3002788344), 0);
+        assert_eq!(and_ui32(4, 3482297128), 0);
+        assert_eq!(and_ui32(2119154652, 0), 0);
+        assert_eq!(and_ui32(2119154652, 1), 0);
+        assert_eq!(and_ui32(2119154652, 2), 0);
+        assert_eq!(and_ui32(2119154652, 3), 0);
+        assert_eq!(and_ui32(3002788344, 0), 0);
+        assert_eq!(and_ui32(3002788344, 1), 0);
+        assert_eq!(and_ui32(3002788344, 2), 0);
+        assert_eq!(and_ui32(3002788344, 3), 0);
+        assert_eq!(and_ui32(3002788344, 4), 0);
+        assert_eq!(and_ui32(3482297128, 0), 0);
+        assert_eq!(and_ui32(3482297128, 1), 0);
+        assert_eq!(and_ui32(3482297128, 2), 0);
+        assert_eq!(and_ui32(3482297128, 3), 0);
+        assert_eq!(and_ui32(3482297128, 4), 0);
+        assert_eq!(and_ui32(4294967294, 0), 0);
+        assert_eq!(and_ui32(4294967294, 1), 0);
+        assert_eq!(and_ui32(4294967295, 0), 0);
+        assert_eq!(and_ui32(1, 1), 1);
+        assert_eq!(and_ui32(1, 3), 1);
+        assert_eq!(and_ui32(1, 4294967295), 1);
+        assert_eq!(and_ui32(3, 1), 1);
+        assert_eq!(and_ui32(4294967295, 1), 1);
+        assert_eq!(and_ui32(2, 2), 2);
+        assert_eq!(and_ui32(2, 3), 2);
+        assert_eq!(and_ui32(2, 4294967294), 2);
+        assert_eq!(and_ui32(2, 4294967295), 2);
+        assert_eq!(and_ui32(3, 2), 2);
+        assert_eq!(and_ui32(3, 4294967294), 2);
+        assert_eq!(and_ui32(4294967294, 2), 2);
+        assert_eq!(and_ui32(4294967294, 3), 2);
+        assert_eq!(and_ui32(4294967295, 2), 2);
+        assert_eq!(and_ui32(3, 3), 3);
+        assert_eq!(and_ui32(3, 4294967295), 3);
+        assert_eq!(and_ui32(4294967295, 3), 3);
+        assert_eq!(and_ui32(4, 4), 4);
+        assert_eq!(and_ui32(4, 2119154652), 4);
+        assert_eq!(and_ui32(4, 4294967294), 4);
+        assert_eq!(and_ui32(4, 4294967295), 4);
+        assert_eq!(and_ui32(2119154652, 4), 4);
+        assert_eq!(and_ui32(4294967294, 4), 4);
+        assert_eq!(and_ui32(4294967295, 4), 4);
+        assert_eq!(and_ui32(2119154652, 3002788344), 843753944);
+        assert_eq!(and_ui32(3002788344, 2119154652), 843753944);
+        assert_eq!(and_ui32(2119154652, 3482297128), 1309647624);
+        assert_eq!(and_ui32(3482297128, 2119154652), 1309647624);
+        assert_eq!(and_ui32(2119154652, 2119154652), 2119154652);
+        assert_eq!(and_ui32(2119154652, 4294967294), 2119154652);
+        assert_eq!(and_ui32(2119154652, 4294967295), 2119154652);
+        assert_eq!(and_ui32(4294967294, 2119154652), 2119154652);
+        assert_eq!(and_ui32(4294967295, 2119154652), 2119154652);
+        assert_eq!(and_ui32(3002788344, 3482297128), 2190123304);
+        assert_eq!(and_ui32(3482297128, 3002788344), 2190123304);
+        assert_eq!(and_ui32(3002788344, 3002788344), 3002788344);
+        assert_eq!(and_ui32(3002788344, 4294967294), 3002788344);
+        assert_eq!(and_ui32(3002788344, 4294967295), 3002788344);
+        assert_eq!(and_ui32(4294967294, 3002788344), 3002788344);
+        assert_eq!(and_ui32(4294967295, 3002788344), 3002788344);
+        assert_eq!(and_ui32(3482297128, 3482297128), 3482297128);
+        assert_eq!(and_ui32(3482297128, 4294967294), 3482297128);
+        assert_eq!(and_ui32(3482297128, 4294967295), 3482297128);
+        assert_eq!(and_ui32(4294967294, 3482297128), 3482297128);
+        assert_eq!(and_ui32(4294967295, 3482297128), 3482297128);
+        assert_eq!(and_ui32(4294967294, 4294967294), 4294967294);
+        assert_eq!(and_ui32(4294967294, 4294967295), 4294967294);
+        assert_eq!(and_ui32(4294967295, 4294967294), 4294967294);
+        assert_eq!(and_ui32(4294967295, 4294967295), 4294967295);
+        assert_eq!(and_ui64(0, 0), 0);
+        assert_eq!(and_ui64(0, 1), 0);
+        assert_eq!(and_ui64(0, 2), 0);
+        assert_eq!(and_ui64(0, 3), 0);
+        assert_eq!(and_ui64(0, 4), 0);
+        assert_eq!(and_ui64(0, 191084152064409600), 0);
+        assert_eq!(and_ui64(0, 11015955194427482112), 0);
+        assert_eq!(and_ui64(0, 16990600415051759616), 0);
+        assert_eq!(and_ui64(0, 18446744073709551614), 0);
+        assert_eq!(and_ui64(0, 18446744073709551615), 0);
+        assert_eq!(and_ui64(1, 0), 0);
+        assert_eq!(and_ui64(1, 2), 0);
+        assert_eq!(and_ui64(1, 4), 0);
+        assert_eq!(and_ui64(1, 191084152064409600), 0);
+        assert_eq!(and_ui64(1, 11015955194427482112), 0);
+        assert_eq!(and_ui64(1, 16990600415051759616), 0);
+        assert_eq!(and_ui64(1, 18446744073709551614), 0);
+        assert_eq!(and_ui64(2, 0), 0);
+        assert_eq!(and_ui64(2, 1), 0);
+        assert_eq!(and_ui64(2, 4), 0);
+        assert_eq!(and_ui64(2, 191084152064409600), 0);
+        assert_eq!(and_ui64(2, 11015955194427482112), 0);
+        assert_eq!(and_ui64(2, 16990600415051759616), 0);
+        assert_eq!(and_ui64(3, 0), 0);
+        assert_eq!(and_ui64(3, 4), 0);
+        assert_eq!(and_ui64(3, 191084152064409600), 0);
+        assert_eq!(and_ui64(3, 11015955194427482112), 0);
+        assert_eq!(and_ui64(3, 16990600415051759616), 0);
+        assert_eq!(and_ui64(4, 0), 0);
+        assert_eq!(and_ui64(4, 1), 0);
+        assert_eq!(and_ui64(4, 2), 0);
+        assert_eq!(and_ui64(4, 3), 0);
+        assert_eq!(and_ui64(4, 191084152064409600), 0);
+        assert_eq!(and_ui64(4, 11015955194427482112), 0);
+        assert_eq!(and_ui64(4, 16990600415051759616), 0);
+        assert_eq!(and_ui64(191084152064409600, 0), 0);
+        assert_eq!(and_ui64(191084152064409600, 1), 0);
+        assert_eq!(and_ui64(191084152064409600, 2), 0);
+        assert_eq!(and_ui64(191084152064409600, 3), 0);
+        assert_eq!(and_ui64(191084152064409600, 4), 0);
+        assert_eq!(and_ui64(11015955194427482112, 0), 0);
+        assert_eq!(and_ui64(11015955194427482112, 1), 0);
+        assert_eq!(and_ui64(11015955194427482112, 2), 0);
+        assert_eq!(and_ui64(11015955194427482112, 3), 0);
+        assert_eq!(and_ui64(11015955194427482112, 4), 0);
+        assert_eq!(and_ui64(16990600415051759616, 0), 0);
+        assert_eq!(and_ui64(16990600415051759616, 1), 0);
+        assert_eq!(and_ui64(16990600415051759616, 2), 0);
+        assert_eq!(and_ui64(16990600415051759616, 3), 0);
+        assert_eq!(and_ui64(16990600415051759616, 4), 0);
+        assert_eq!(and_ui64(18446744073709551614, 0), 0);
+        assert_eq!(and_ui64(18446744073709551614, 1), 0);
+        assert_eq!(and_ui64(18446744073709551615, 0), 0);
+        assert_eq!(and_ui64(1, 1), 1);
+        assert_eq!(and_ui64(1, 3), 1);
+        assert_eq!(and_ui64(1, 18446744073709551615), 1);
+        assert_eq!(and_ui64(3, 1), 1);
+        assert_eq!(and_ui64(18446744073709551615, 1), 1);
+        assert_eq!(and_ui64(2, 2), 2);
+        assert_eq!(and_ui64(2, 3), 2);
+        assert_eq!(and_ui64(2, 18446744073709551614), 2);
+        assert_eq!(and_ui64(2, 18446744073709551615), 2);
+        assert_eq!(and_ui64(3, 2), 2);
+        assert_eq!(and_ui64(3, 18446744073709551614), 2);
+        assert_eq!(and_ui64(18446744073709551614, 2), 2);
+        assert_eq!(and_ui64(18446744073709551614, 3), 2);
+        assert_eq!(and_ui64(18446744073709551615, 2), 2);
+        assert_eq!(and_ui64(3, 3), 3);
+        assert_eq!(and_ui64(3, 18446744073709551615), 3);
+        assert_eq!(and_ui64(18446744073709551615, 3), 3);
+        assert_eq!(and_ui64(4, 4), 4);
+        assert_eq!(and_ui64(4, 18446744073709551614), 4);
+        assert_eq!(and_ui64(4, 18446744073709551615), 4);
+        assert_eq!(and_ui64(18446744073709551614, 4), 4);
+        assert_eq!(and_ui64(18446744073709551615, 4), 4);
+        assert_eq!(
+            and_ui64(191084152064409600, 11015955194427482112),
+            45185538445017088
+        );
+        assert_eq!(
+            and_ui64(11015955194427482112, 191084152064409600),
+            45185538445017088
+        );
+        assert_eq!(
+            and_ui64(191084152064409600, 16990600415051759616),
+            180878484934066176
+        );
+        assert_eq!(
+            and_ui64(16990600415051759616, 191084152064409600),
+            180878484934066176
+        );
+        assert_eq!(
+            and_ui64(191084152064409600, 191084152064409600),
+            191084152064409600
+        );
+        assert_eq!(
+            and_ui64(191084152064409600, 18446744073709551614),
+            191084152064409600
+        );
+        assert_eq!(
+            and_ui64(191084152064409600, 18446744073709551615),
+            191084152064409600
+        );
+        assert_eq!(
+            and_ui64(18446744073709551614, 191084152064409600),
+            191084152064409600
+        );
+        assert_eq!(
+            and_ui64(18446744073709551615, 191084152064409600),
+            191084152064409600
+        );
+        assert_eq!(
+            and_ui64(11015955194427482112, 16990600415051759616),
+            9854025527415799808
+        );
+        assert_eq!(
+            and_ui64(16990600415051759616, 11015955194427482112),
+            9854025527415799808
+        );
+        assert_eq!(
+            and_ui64(11015955194427482112, 11015955194427482112),
+            11015955194427482112
+        );
+        assert_eq!(
+            and_ui64(11015955194427482112, 18446744073709551614),
+            11015955194427482112
+        );
+        assert_eq!(
+            and_ui64(11015955194427482112, 18446744073709551615),
+            11015955194427482112
+        );
+        assert_eq!(
+            and_ui64(18446744073709551614, 11015955194427482112),
+            11015955194427482112
+        );
+        assert_eq!(
+            and_ui64(18446744073709551615, 11015955194427482112),
+            11015955194427482112
+        );
+        assert_eq!(
+            and_ui64(16990600415051759616, 16990600415051759616),
+            16990600415051759616
+        );
+        assert_eq!(
+            and_ui64(16990600415051759616, 18446744073709551614),
+            16990600415051759616
+        );
+        assert_eq!(
+            and_ui64(16990600415051759616, 18446744073709551615),
+            16990600415051759616
+        );
+        assert_eq!(
+            and_ui64(18446744073709551614, 16990600415051759616),
+            16990600415051759616
+        );
+        assert_eq!(
+            and_ui64(18446744073709551615, 16990600415051759616),
+            16990600415051759616
+        );
+        assert_eq!(
+            and_ui64(18446744073709551614, 18446744073709551614),
+            18446744073709551614
+        );
+        assert_eq!(
+            and_ui64(18446744073709551614, 18446744073709551615),
+            18446744073709551614
+        );
+        assert_eq!(
+            and_ui64(18446744073709551615, 18446744073709551614),
+            18446744073709551614
+        );
+        assert_eq!(
+            and_ui64(18446744073709551615, 18446744073709551615),
+            18446744073709551615
+        );
+        assert_eq!(and_ui8(0, 0), 0);
+        assert_eq!(and_ui8(0, 1), 0);
+        assert_eq!(and_ui8(0, 2), 0);
+        assert_eq!(and_ui8(0, 3), 0);
+        assert_eq!(and_ui8(0, 4), 0);
+        assert_eq!(and_ui8(0, 72), 0);
+        assert_eq!(and_ui8(0, 100), 0);
+        assert_eq!(and_ui8(0, 162), 0);
+        assert_eq!(and_ui8(0, 254), 0);
+        assert_eq!(and_ui8(0, 255), 0);
+        assert_eq!(and_ui8(1, 0), 0);
+        assert_eq!(and_ui8(1, 2), 0);
+        assert_eq!(and_ui8(1, 4), 0);
+        assert_eq!(and_ui8(1, 72), 0);
+        assert_eq!(and_ui8(1, 100), 0);
+        assert_eq!(and_ui8(1, 162), 0);
+        assert_eq!(and_ui8(1, 254), 0);
+        assert_eq!(and_ui8(2, 0), 0);
+        assert_eq!(and_ui8(2, 1), 0);
+        assert_eq!(and_ui8(2, 4), 0);
+        assert_eq!(and_ui8(2, 72), 0);
+        assert_eq!(and_ui8(2, 100), 0);
+        assert_eq!(and_ui8(3, 0), 0);
+        assert_eq!(and_ui8(3, 4), 0);
+        assert_eq!(and_ui8(3, 72), 0);
+        assert_eq!(and_ui8(3, 100), 0);
+        assert_eq!(and_ui8(4, 0), 0);
+        assert_eq!(and_ui8(4, 1), 0);
+        assert_eq!(and_ui8(4, 2), 0);
+        assert_eq!(and_ui8(4, 3), 0);
+        assert_eq!(and_ui8(4, 72), 0);
+        assert_eq!(and_ui8(4, 162), 0);
+        assert_eq!(and_ui8(72, 0), 0);
+        assert_eq!(and_ui8(72, 1), 0);
+        assert_eq!(and_ui8(72, 2), 0);
+        assert_eq!(and_ui8(72, 3), 0);
+        assert_eq!(and_ui8(72, 4), 0);
+        assert_eq!(and_ui8(72, 162), 0);
+        assert_eq!(and_ui8(100, 0), 0);
+        assert_eq!(and_ui8(100, 1), 0);
+        assert_eq!(and_ui8(100, 2), 0);
+        assert_eq!(and_ui8(100, 3), 0);
+        assert_eq!(and_ui8(162, 0), 0);
+        assert_eq!(and_ui8(162, 1), 0);
+        assert_eq!(and_ui8(162, 4), 0);
+        assert_eq!(and_ui8(162, 72), 0);
+        assert_eq!(and_ui8(254, 0), 0);
+        assert_eq!(and_ui8(254, 1), 0);
+        assert_eq!(and_ui8(255, 0), 0);
+        assert_eq!(and_ui8(1, 1), 1);
+        assert_eq!(and_ui8(1, 3), 1);
+        assert_eq!(and_ui8(1, 255), 1);
+        assert_eq!(and_ui8(3, 1), 1);
+        assert_eq!(and_ui8(255, 1), 1);
+        assert_eq!(and_ui8(2, 2), 2);
+        assert_eq!(and_ui8(2, 3), 2);
+        assert_eq!(and_ui8(2, 162), 2);
+        assert_eq!(and_ui8(2, 254), 2);
+        assert_eq!(and_ui8(2, 255), 2);
+        assert_eq!(and_ui8(3, 2), 2);
+        assert_eq!(and_ui8(3, 162), 2);
+        assert_eq!(and_ui8(3, 254), 2);
+        assert_eq!(and_ui8(162, 2), 2);
+        assert_eq!(and_ui8(162, 3), 2);
+        assert_eq!(and_ui8(254, 2), 2);
+        assert_eq!(and_ui8(254, 3), 2);
+        assert_eq!(and_ui8(255, 2), 2);
+        assert_eq!(and_ui8(3, 3), 3);
+        assert_eq!(and_ui8(3, 255), 3);
+        assert_eq!(and_ui8(255, 3), 3);
+        assert_eq!(and_ui8(4, 4), 4);
+        assert_eq!(and_ui8(4, 100), 4);
+        assert_eq!(and_ui8(4, 254), 4);
+        assert_eq!(and_ui8(4, 255), 4);
+        assert_eq!(and_ui8(100, 4), 4);
+        assert_eq!(and_ui8(254, 4), 4);
+        assert_eq!(and_ui8(255, 4), 4);
+        assert_eq!(and_ui8(100, 162), 32);
+        assert_eq!(and_ui8(162, 100), 32);
+        assert_eq!(and_ui8(72, 100), 64);
+        assert_eq!(and_ui8(100, 72), 64);
+        assert_eq!(and_ui8(72, 72), 72);
+        assert_eq!(and_ui8(72, 254), 72);
+        assert_eq!(and_ui8(72, 255), 72);
+        assert_eq!(and_ui8(254, 72), 72);
+        assert_eq!(and_ui8(255, 72), 72);
+        assert_eq!(and_ui8(100, 100), 100);
+        assert_eq!(and_ui8(100, 254), 100);
+        assert_eq!(and_ui8(100, 255), 100);
+        assert_eq!(and_ui8(254, 100), 100);
+        assert_eq!(and_ui8(255, 100), 100);
+        assert_eq!(and_ui8(162, 162), 162);
+        assert_eq!(and_ui8(162, 254), 162);
+        assert_eq!(and_ui8(162, 255), 162);
+        assert_eq!(and_ui8(254, 162), 162);
+        assert_eq!(and_ui8(255, 162), 162);
+        assert_eq!(and_ui8(254, 254), 254);
+        assert_eq!(and_ui8(254, 255), 254);
+        assert_eq!(and_ui8(255, 254), 254);
+        assert_eq!(and_ui8(255, 255), 255);
+        assert_eq!(or_si16(-32768, -32768), -32768);
+        assert_eq!(or_si16(-32768, 0), -32768);
+        assert_eq!(or_si16(0, -32768), -32768);
+        assert_eq!(or_si16(-32768, -32767), -32767);
+        assert_eq!(or_si16(-32768, 1), -32767);
+        assert_eq!(or_si16(-32767, -32768), -32767);
+        assert_eq!(or_si16(-32767, -32767), -32767);
+        assert_eq!(or_si16(-32767, 0), -32767);
+        assert_eq!(or_si16(-32767, 1), -32767);
+        assert_eq!(or_si16(0, -32767), -32767);
+        assert_eq!(or_si16(1, -32768), -32767);
+        assert_eq!(or_si16(1, -32767), -32767);
+        assert_eq!(or_si16(-32768, 2), -32766);
+        assert_eq!(or_si16(2, -32768), -32766);
+        assert_eq!(or_si16(-32768, 3), -32765);
+        assert_eq!(or_si16(-32767, 2), -32765);
+        assert_eq!(or_si16(-32767, 3), -32765);
+        assert_eq!(or_si16(2, -32767), -32765);
+        assert_eq!(or_si16(3, -32768), -32765);
+        assert_eq!(or_si16(3, -32767), -32765);
+        assert_eq!(or_si16(-32768, 4), -32764);
+        assert_eq!(or_si16(4, -32768), -32764);
+        assert_eq!(or_si16(-32767, 4), -32763);
+        assert_eq!(or_si16(4, -32767), -32763);
+        assert_eq!(or_si16(-32768, -32547), -32547);
+        assert_eq!(or_si16(-32767, -32547), -32547);
+        assert_eq!(or_si16(-32547, -32768), -32547);
+        assert_eq!(or_si16(-32547, -32767), -32547);
+        assert_eq!(or_si16(-32547, -32547), -32547);
+        assert_eq!(or_si16(-32547, 0), -32547);
+        assert_eq!(or_si16(-32547, 1), -32547);
+        assert_eq!(or_si16(-32547, 4), -32547);
+        assert_eq!(or_si16(0, -32547), -32547);
+        assert_eq!(or_si16(1, -32547), -32547);
+        assert_eq!(or_si16(4, -32547), -32547);
+        assert_eq!(or_si16(-32547, 2), -32545);
+        assert_eq!(or_si16(-32547, 3), -32545);
+        assert_eq!(or_si16(2, -32547), -32545);
+        assert_eq!(or_si16(3, -32547), -32545);
+        assert_eq!(or_si16(-32768, 10486), -22282);
+        assert_eq!(or_si16(10486, -32768), -22282);
+        assert_eq!(or_si16(-32767, 10486), -22281);
+        assert_eq!(or_si16(10486, -32767), -22281);
+        assert_eq!(or_si16(-32547, 10486), -22273);
+        assert_eq!(or_si16(10486, -32547), -22273);
+        assert_eq!(or_si16(-32768, 16514), -16254);
+        assert_eq!(or_si16(16514, -32768), -16254);
+        assert_eq!(or_si16(-32767, 16514), -16253);
+        assert_eq!(or_si16(16514, -32767), -16253);
+        assert_eq!(or_si16(-32547, 16514), -16161);
+        assert_eq!(or_si16(16514, -32547), -16161);
+        assert_eq!(or_si16(-32768, 32766), -2);
+        assert_eq!(or_si16(32766, -32768), -2);
+        assert_eq!(or_si16(-32768, 32767), -1);
+        assert_eq!(or_si16(-32767, 32766), -1);
+        assert_eq!(or_si16(-32767, 32767), -1);
+        assert_eq!(or_si16(-32547, 32766), -1);
+        assert_eq!(or_si16(-32547, 32767), -1);
+        assert_eq!(or_si16(32766, -32767), -1);
+        assert_eq!(or_si16(32766, -32547), -1);
+        assert_eq!(or_si16(32767, -32768), -1);
+        assert_eq!(or_si16(32767, -32767), -1);
+        assert_eq!(or_si16(32767, -32547), -1);
+        assert_eq!(or_si16(0, 0), 0);
+        assert_eq!(or_si16(0, 1), 1);
+        assert_eq!(or_si16(1, 0), 1);
+        assert_eq!(or_si16(1, 1), 1);
+        assert_eq!(or_si16(0, 2), 2);
+        assert_eq!(or_si16(2, 0), 2);
+        assert_eq!(or_si16(2, 2), 2);
+        assert_eq!(or_si16(0, 3), 3);
+        assert_eq!(or_si16(1, 2), 3);
+        assert_eq!(or_si16(1, 3), 3);
+        assert_eq!(or_si16(2, 1), 3);
+        assert_eq!(or_si16(2, 3), 3);
+        assert_eq!(or_si16(3, 0), 3);
+        assert_eq!(or_si16(3, 1), 3);
+        assert_eq!(or_si16(3, 2), 3);
+        assert_eq!(or_si16(3, 3), 3);
+        assert_eq!(or_si16(0, 4), 4);
+        assert_eq!(or_si16(4, 0), 4);
+        assert_eq!(or_si16(4, 4), 4);
+        assert_eq!(or_si16(1, 4), 5);
+        assert_eq!(or_si16(4, 1), 5);
+        assert_eq!(or_si16(2, 4), 6);
+        assert_eq!(or_si16(4, 2), 6);
+        assert_eq!(or_si16(3, 4), 7);
+        assert_eq!(or_si16(4, 3), 7);
+        assert_eq!(or_si16(0, 10486), 10486);
+        assert_eq!(or_si16(2, 10486), 10486);
+        assert_eq!(or_si16(4, 10486), 10486);
+        assert_eq!(or_si16(10486, 0), 10486);
+        assert_eq!(or_si16(10486, 2), 10486);
+        assert_eq!(or_si16(10486, 4), 10486);
+        assert_eq!(or_si16(10486, 10486), 10486);
+        assert_eq!(or_si16(1, 10486), 10487);
+        assert_eq!(or_si16(3, 10486), 10487);
+        assert_eq!(or_si16(10486, 1), 10487);
+        assert_eq!(or_si16(10486, 3), 10487);
+        assert_eq!(or_si16(0, 16514), 16514);
+        assert_eq!(or_si16(2, 16514), 16514);
+        assert_eq!(or_si16(16514, 0), 16514);
+        assert_eq!(or_si16(16514, 2), 16514);
+        assert_eq!(or_si16(16514, 16514), 16514);
+        assert_eq!(or_si16(1, 16514), 16515);
+        assert_eq!(or_si16(3, 16514), 16515);
+        assert_eq!(or_si16(16514, 1), 16515);
+        assert_eq!(or_si16(16514, 3), 16515);
+        assert_eq!(or_si16(4, 16514), 16518);
+        assert_eq!(or_si16(16514, 4), 16518);
+        assert_eq!(or_si16(10486, 16514), 26870);
+        assert_eq!(or_si16(16514, 10486), 26870);
+        assert_eq!(or_si16(0, 32766), 32766);
+        assert_eq!(or_si16(2, 32766), 32766);
+        assert_eq!(or_si16(4, 32766), 32766);
+        assert_eq!(or_si16(10486, 32766), 32766);
+        assert_eq!(or_si16(16514, 32766), 32766);
+        assert_eq!(or_si16(32766, 0), 32766);
+        assert_eq!(or_si16(32766, 2), 32766);
+        assert_eq!(or_si16(32766, 4), 32766);
+        assert_eq!(or_si16(32766, 10486), 32766);
+        assert_eq!(or_si16(32766, 16514), 32766);
+        assert_eq!(or_si16(32766, 32766), 32766);
+        assert_eq!(or_si16(0, 32767), 32767);
+        assert_eq!(or_si16(1, 32766), 32767);
+        assert_eq!(or_si16(1, 32767), 32767);
+        assert_eq!(or_si16(2, 32767), 32767);
+        assert_eq!(or_si16(3, 32766), 32767);
+        assert_eq!(or_si16(3, 32767), 32767);
+        assert_eq!(or_si16(4, 32767), 32767);
+        assert_eq!(or_si16(10486, 32767), 32767);
+        assert_eq!(or_si16(16514, 32767), 32767);
+        assert_eq!(or_si16(32766, 1), 32767);
+        assert_eq!(or_si16(32766, 3), 32767);
+        assert_eq!(or_si16(32766, 32767), 32767);
+        assert_eq!(or_si16(32767, 0), 32767);
+        assert_eq!(or_si16(32767, 1), 32767);
+        assert_eq!(or_si16(32767, 2), 32767);
+        assert_eq!(or_si16(32767, 3), 32767);
+        assert_eq!(or_si16(32767, 4), 32767);
+        assert_eq!(or_si16(32767, 10486), 32767);
+        assert_eq!(or_si16(32767, 16514), 32767);
+        assert_eq!(or_si16(32767, 32766), 32767);
+        assert_eq!(or_si16(32767, 32767), 32767);
+        assert_eq!(or_si32(-2147483648, -2147483648), -2147483648);
+        assert_eq!(or_si32(-2147483648, 0), -2147483648);
+        assert_eq!(or_si32(0, -2147483648), -2147483648);
+        assert_eq!(or_si32(-2147483648, -2147483647), -2147483647);
+        assert_eq!(or_si32(-2147483648, 1), -2147483647);
+        assert_eq!(or_si32(-2147483647, -2147483648), -2147483647);
+        assert_eq!(or_si32(-2147483647, -2147483647), -2147483647);
+        assert_eq!(or_si32(-2147483647, 0), -2147483647);
+        assert_eq!(or_si32(-2147483647, 1), -2147483647);
+        assert_eq!(or_si32(0, -2147483647), -2147483647);
+        assert_eq!(or_si32(1, -2147483648), -2147483647);
+        assert_eq!(or_si32(1, -2147483647), -2147483647);
+        assert_eq!(or_si32(-2147483648, 2), -2147483646);
+        assert_eq!(or_si32(2, -2147483648), -2147483646);
+        assert_eq!(or_si32(-2147483648, 3), -2147483645);
+        assert_eq!(or_si32(-2147483647, 2), -2147483645);
+        assert_eq!(or_si32(-2147483647, 3), -2147483645);
+        assert_eq!(or_si32(2, -2147483647), -2147483645);
+        assert_eq!(or_si32(3, -2147483648), -2147483645);
+        assert_eq!(or_si32(3, -2147483647), -2147483645);
+        assert_eq!(or_si32(-2147483648, 4), -2147483644);
+        assert_eq!(or_si32(4, -2147483648), -2147483644);
+        assert_eq!(or_si32(-2147483647, 4), -2147483643);
+        assert_eq!(or_si32(4, -2147483647), -2147483643);
+        assert_eq!(or_si32(-2147483648, -1713183800), -1713183800);
+        assert_eq!(or_si32(-1713183800, -2147483648), -1713183800);
+        assert_eq!(or_si32(-1713183800, -1713183800), -1713183800);
+        assert_eq!(or_si32(-1713183800, 0), -1713183800);
+        assert_eq!(or_si32(0, -1713183800), -1713183800);
+        assert_eq!(or_si32(-2147483647, -1713183800), -1713183799);
+        assert_eq!(or_si32(-1713183800, -2147483647), -1713183799);
+        assert_eq!(or_si32(-1713183800, 1), -1713183799);
+        assert_eq!(or_si32(1, -1713183800), -1713183799);
+        assert_eq!(or_si32(-1713183800, 2), -1713183798);
+        assert_eq!(or_si32(2, -1713183800), -1713183798);
+        assert_eq!(or_si32(-1713183800, 3), -1713183797);
+        assert_eq!(or_si32(3, -1713183800), -1713183797);
+        assert_eq!(or_si32(-1713183800, 4), -1713183796);
+        assert_eq!(or_si32(4, -1713183800), -1713183796);
+        assert_eq!(or_si32(-2147483648, -1252582164), -1252582164);
+        assert_eq!(or_si32(-1252582164, -2147483648), -1252582164);
+        assert_eq!(or_si32(-1252582164, -1252582164), -1252582164);
+        assert_eq!(or_si32(-1252582164, 0), -1252582164);
+        assert_eq!(or_si32(-1252582164, 4), -1252582164);
+        assert_eq!(or_si32(0, -1252582164), -1252582164);
+        assert_eq!(or_si32(4, -1252582164), -1252582164);
+        assert_eq!(or_si32(-2147483647, -1252582164), -1252582163);
+        assert_eq!(or_si32(-1252582164, -2147483647), -1252582163);
+        assert_eq!(or_si32(-1252582164, 1), -1252582163);
+        assert_eq!(or_si32(1, -1252582164), -1252582163);
+        assert_eq!(or_si32(-1252582164, 2), -1252582162);
+        assert_eq!(or_si32(2, -1252582164), -1252582162);
+        assert_eq!(or_si32(-1252582164, 3), -1252582161);
+        assert_eq!(or_si32(3, -1252582164), -1252582161);
+        assert_eq!(or_si32(-1713183800, -1252582164), -1107820564);
+        assert_eq!(or_si32(-1252582164, -1713183800), -1107820564);
+        assert_eq!(or_si32(-2147483648, -1035405763), -1035405763);
+        assert_eq!(or_si32(-2147483647, -1035405763), -1035405763);
+        assert_eq!(or_si32(-1035405763, -2147483648), -1035405763);
+        assert_eq!(or_si32(-1035405763, -2147483647), -1035405763);
+        assert_eq!(or_si32(-1035405763, -1035405763), -1035405763);
+        assert_eq!(or_si32(-1035405763, 0), -1035405763);
+        assert_eq!(or_si32(-1035405763, 1), -1035405763);
+        assert_eq!(or_si32(-1035405763, 4), -1035405763);
+        assert_eq!(or_si32(0, -1035405763), -1035405763);
+        assert_eq!(or_si32(1, -1035405763), -1035405763);
+        assert_eq!(or_si32(4, -1035405763), -1035405763);
+        assert_eq!(or_si32(-1035405763, 2), -1035405761);
+        assert_eq!(or_si32(-1035405763, 3), -1035405761);
+        assert_eq!(or_si32(2, -1035405763), -1035405761);
+        assert_eq!(or_si32(3, -1035405763), -1035405761);
+        assert_eq!(or_si32(-1713183800, -1035405763), -605358083);
+        assert_eq!(or_si32(-1035405763, -1713183800), -605358083);
+        assert_eq!(or_si32(-1252582164, -1035405763), -144703747);
+        assert_eq!(or_si32(-1035405763, -1252582164), -144703747);
+        assert_eq!(or_si32(-2147483648, 2147483646), -2);
+        assert_eq!(or_si32(-1713183800, 2147483646), -2);
+        assert_eq!(or_si32(-1252582164, 2147483646), -2);
+        assert_eq!(or_si32(2147483646, -2147483648), -2);
+        assert_eq!(or_si32(2147483646, -1713183800), -2);
+        assert_eq!(or_si32(2147483646, -1252582164), -2);
+        assert_eq!(or_si32(-2147483648, 2147483647), -1);
+        assert_eq!(or_si32(-2147483647, 2147483646), -1);
+        assert_eq!(or_si32(-2147483647, 2147483647), -1);
+        assert_eq!(or_si32(-1713183800, 2147483647), -1);
+        assert_eq!(or_si32(-1252582164, 2147483647), -1);
+        assert_eq!(or_si32(-1035405763, 2147483646), -1);
+        assert_eq!(or_si32(-1035405763, 2147483647), -1);
+        assert_eq!(or_si32(2147483646, -2147483647), -1);
+        assert_eq!(or_si32(2147483646, -1035405763), -1);
+        assert_eq!(or_si32(2147483647, -2147483648), -1);
+        assert_eq!(or_si32(2147483647, -2147483647), -1);
+        assert_eq!(or_si32(2147483647, -1713183800), -1);
+        assert_eq!(or_si32(2147483647, -1252582164), -1);
+        assert_eq!(or_si32(2147483647, -1035405763), -1);
+        assert_eq!(or_si32(0, 0), 0);
+        assert_eq!(or_si32(0, 1), 1);
+        assert_eq!(or_si32(1, 0), 1);
+        assert_eq!(or_si32(1, 1), 1);
+        assert_eq!(or_si32(0, 2), 2);
+        assert_eq!(or_si32(2, 0), 2);
+        assert_eq!(or_si32(2, 2), 2);
+        assert_eq!(or_si32(0, 3), 3);
+        assert_eq!(or_si32(1, 2), 3);
+        assert_eq!(or_si32(1, 3), 3);
+        assert_eq!(or_si32(2, 1), 3);
+        assert_eq!(or_si32(2, 3), 3);
+        assert_eq!(or_si32(3, 0), 3);
+        assert_eq!(or_si32(3, 1), 3);
+        assert_eq!(or_si32(3, 2), 3);
+        assert_eq!(or_si32(3, 3), 3);
+        assert_eq!(or_si32(0, 4), 4);
+        assert_eq!(or_si32(4, 0), 4);
+        assert_eq!(or_si32(4, 4), 4);
+        assert_eq!(or_si32(1, 4), 5);
+        assert_eq!(or_si32(4, 1), 5);
+        assert_eq!(or_si32(2, 4), 6);
+        assert_eq!(or_si32(4, 2), 6);
+        assert_eq!(or_si32(3, 4), 7);
+        assert_eq!(or_si32(4, 3), 7);
+        assert_eq!(or_si32(0, 2147483646), 2147483646);
+        assert_eq!(or_si32(2, 2147483646), 2147483646);
+        assert_eq!(or_si32(4, 2147483646), 2147483646);
+        assert_eq!(or_si32(2147483646, 0), 2147483646);
+        assert_eq!(or_si32(2147483646, 2), 2147483646);
+        assert_eq!(or_si32(2147483646, 4), 2147483646);
+        assert_eq!(or_si32(2147483646, 2147483646), 2147483646);
+        assert_eq!(or_si32(0, 2147483647), 2147483647);
+        assert_eq!(or_si32(1, 2147483646), 2147483647);
+        assert_eq!(or_si32(1, 2147483647), 2147483647);
+        assert_eq!(or_si32(2, 2147483647), 2147483647);
+        assert_eq!(or_si32(3, 2147483646), 2147483647);
+        assert_eq!(or_si32(3, 2147483647), 2147483647);
+        assert_eq!(or_si32(4, 2147483647), 2147483647);
+        assert_eq!(or_si32(2147483646, 1), 2147483647);
+        assert_eq!(or_si32(2147483646, 3), 2147483647);
+        assert_eq!(or_si32(2147483646, 2147483647), 2147483647);
+        assert_eq!(or_si32(2147483647, 0), 2147483647);
+        assert_eq!(or_si32(2147483647, 1), 2147483647);
+        assert_eq!(or_si32(2147483647, 2), 2147483647);
+        assert_eq!(or_si32(2147483647, 3), 2147483647);
+        assert_eq!(or_si32(2147483647, 4), 2147483647);
+        assert_eq!(or_si32(2147483647, 2147483646), 2147483647);
+        assert_eq!(or_si32(2147483647, 2147483647), 2147483647);
+        assert_eq!(
+            or_si64(-9223372036854775808, -9223372036854775808),
+            -9223372036854775808
+        );
+        assert_eq!(or_si64(-9223372036854775808, 0), -9223372036854775808);
+        assert_eq!(or_si64(0, -9223372036854775808), -9223372036854775808);
+        assert_eq!(
+            or_si64(-9223372036854775808, -9223372036854775807),
+            -9223372036854775807
+        );
+        assert_eq!(or_si64(-9223372036854775808, 1), -9223372036854775807);
+        assert_eq!(
+            or_si64(-9223372036854775807, -9223372036854775808),
+            -9223372036854775807
+        );
+        assert_eq!(
+            or_si64(-9223372036854775807, -9223372036854775807),
+            -9223372036854775807
+        );
+        assert_eq!(or_si64(-9223372036854775807, 0), -9223372036854775807);
+        assert_eq!(or_si64(-9223372036854775807, 1), -9223372036854775807);
+        assert_eq!(or_si64(0, -9223372036854775807), -9223372036854775807);
+        assert_eq!(or_si64(1, -9223372036854775808), -9223372036854775807);
+        assert_eq!(or_si64(1, -9223372036854775807), -9223372036854775807);
+        assert_eq!(or_si64(-9223372036854775808, 2), -9223372036854775806);
+        assert_eq!(or_si64(2, -9223372036854775808), -9223372036854775806);
+        assert_eq!(or_si64(-9223372036854775808, 3), -9223372036854775805);
+        assert_eq!(or_si64(-9223372036854775807, 2), -9223372036854775805);
+        assert_eq!(or_si64(-9223372036854775807, 3), -9223372036854775805);
+        assert_eq!(or_si64(2, -9223372036854775807), -9223372036854775805);
+        assert_eq!(or_si64(3, -9223372036854775808), -9223372036854775805);
+        assert_eq!(or_si64(3, -9223372036854775807), -9223372036854775805);
+        assert_eq!(or_si64(-9223372036854775808, 4), -9223372036854775804);
+        assert_eq!(or_si64(4, -9223372036854775808), -9223372036854775804);
+        assert_eq!(or_si64(-9223372036854775807, 4), -9223372036854775803);
+        assert_eq!(or_si64(4, -9223372036854775807), -9223372036854775803);
+        assert_eq!(
+            or_si64(-9223372036854775808, 5577148965131116544),
+            -3646223071723659264
+        );
+        assert_eq!(
+            or_si64(5577148965131116544, -9223372036854775808),
+            -3646223071723659264
+        );
+        assert_eq!(
+            or_si64(-9223372036854775807, 5577148965131116544),
+            -3646223071723659263
+        );
+        assert_eq!(
+            or_si64(5577148965131116544, -9223372036854775807),
+            -3646223071723659263
+        );
+        assert_eq!(
+            or_si64(-9223372036854775808, -1741927215160008704),
+            -1741927215160008704
+        );
+        assert_eq!(
+            or_si64(-1741927215160008704, -9223372036854775808),
+            -1741927215160008704
+        );
+        assert_eq!(
+            or_si64(-1741927215160008704, -1741927215160008704),
+            -1741927215160008704
+        );
+        assert_eq!(or_si64(-1741927215160008704, 0), -1741927215160008704);
+        assert_eq!(or_si64(0, -1741927215160008704), -1741927215160008704);
+        assert_eq!(
+            or_si64(-9223372036854775807, -1741927215160008704),
+            -1741927215160008703
+        );
+        assert_eq!(
+            or_si64(-1741927215160008704, -9223372036854775807),
+            -1741927215160008703
+        );
+        assert_eq!(or_si64(-1741927215160008704, 1), -1741927215160008703);
+        assert_eq!(or_si64(1, -1741927215160008704), -1741927215160008703);
+        assert_eq!(or_si64(-1741927215160008704, 2), -1741927215160008702);
+        assert_eq!(or_si64(2, -1741927215160008704), -1741927215160008702);
+        assert_eq!(or_si64(-1741927215160008704, 3), -1741927215160008701);
+        assert_eq!(or_si64(3, -1741927215160008704), -1741927215160008701);
+        assert_eq!(or_si64(-1741927215160008704, 4), -1741927215160008700);
+        assert_eq!(or_si64(4, -1741927215160008704), -1741927215160008700);
+        assert_eq!(
+            or_si64(-9223372036854775808, -1328271339354574848),
+            -1328271339354574848
+        );
+        assert_eq!(
+            or_si64(-1328271339354574848, -9223372036854775808),
+            -1328271339354574848
+        );
+        assert_eq!(
+            or_si64(-1328271339354574848, -1328271339354574848),
+            -1328271339354574848
+        );
+        assert_eq!(or_si64(-1328271339354574848, 0), -1328271339354574848);
+        assert_eq!(or_si64(0, -1328271339354574848), -1328271339354574848);
+        assert_eq!(
+            or_si64(-9223372036854775807, -1328271339354574848),
+            -1328271339354574847
+        );
+        assert_eq!(
+            or_si64(-1328271339354574848, -9223372036854775807),
+            -1328271339354574847
+        );
+        assert_eq!(or_si64(-1328271339354574848, 1), -1328271339354574847);
+        assert_eq!(or_si64(1, -1328271339354574848), -1328271339354574847);
+        assert_eq!(or_si64(-1328271339354574848, 2), -1328271339354574846);
+        assert_eq!(or_si64(2, -1328271339354574848), -1328271339354574846);
+        assert_eq!(or_si64(-1328271339354574848, 3), -1328271339354574845);
+        assert_eq!(or_si64(3, -1328271339354574848), -1328271339354574845);
+        assert_eq!(or_si64(-1328271339354574848, 4), -1328271339354574844);
+        assert_eq!(or_si64(4, -1328271339354574848), -1328271339354574844);
+        assert_eq!(
+            or_si64(-1328271339354574848, 5577148965131116544),
+            -1299557394519166976
+        );
+        assert_eq!(
+            or_si64(5577148965131116544, -1328271339354574848),
+            -1299557394519166976
+        );
+        assert_eq!(
+            or_si64(-1741927215160008704, -1328271339354574848),
+            -1165466462517891072
+        );
+        assert_eq!(
+            or_si64(-1328271339354574848, -1741927215160008704),
+            -1165466462517891072
+        );
+        assert_eq!(
+            or_si64(-1741927215160008704, 5577148965131116544),
+            -1155332255525117952
+        );
+        assert_eq!(
+            or_si64(5577148965131116544, -1741927215160008704),
+            -1155332255525117952
+        );
+        assert_eq!(or_si64(-9223372036854775808, 9223372036854775806), -2);
+        assert_eq!(or_si64(-1741927215160008704, 9223372036854775806), -2);
+        assert_eq!(or_si64(-1328271339354574848, 9223372036854775806), -2);
+        assert_eq!(or_si64(9223372036854775806, -9223372036854775808), -2);
+        assert_eq!(or_si64(9223372036854775806, -1741927215160008704), -2);
+        assert_eq!(or_si64(9223372036854775806, -1328271339354574848), -2);
+        assert_eq!(or_si64(-9223372036854775808, 9223372036854775807), -1);
+        assert_eq!(or_si64(-9223372036854775807, 9223372036854775806), -1);
+        assert_eq!(or_si64(-9223372036854775807, 9223372036854775807), -1);
+        assert_eq!(or_si64(-1741927215160008704, 9223372036854775807), -1);
+        assert_eq!(or_si64(-1328271339354574848, 9223372036854775807), -1);
+        assert_eq!(or_si64(9223372036854775806, -9223372036854775807), -1);
+        assert_eq!(or_si64(9223372036854775807, -9223372036854775808), -1);
+        assert_eq!(or_si64(9223372036854775807, -9223372036854775807), -1);
+        assert_eq!(or_si64(9223372036854775807, -1741927215160008704), -1);
+        assert_eq!(or_si64(9223372036854775807, -1328271339354574848), -1);
+        assert_eq!(or_si64(0, 0), 0);
+        assert_eq!(or_si64(0, 1), 1);
+        assert_eq!(or_si64(1, 0), 1);
+        assert_eq!(or_si64(1, 1), 1);
+        assert_eq!(or_si64(0, 2), 2);
+        assert_eq!(or_si64(2, 0), 2);
+        assert_eq!(or_si64(2, 2), 2);
+        assert_eq!(or_si64(0, 3), 3);
+        assert_eq!(or_si64(1, 2), 3);
+        assert_eq!(or_si64(1, 3), 3);
+        assert_eq!(or_si64(2, 1), 3);
+        assert_eq!(or_si64(2, 3), 3);
+        assert_eq!(or_si64(3, 0), 3);
+        assert_eq!(or_si64(3, 1), 3);
+        assert_eq!(or_si64(3, 2), 3);
+        assert_eq!(or_si64(3, 3), 3);
+        assert_eq!(or_si64(0, 4), 4);
+        assert_eq!(or_si64(4, 0), 4);
+        assert_eq!(or_si64(4, 4), 4);
+        assert_eq!(or_si64(1, 4), 5);
+        assert_eq!(or_si64(4, 1), 5);
+        assert_eq!(or_si64(2, 4), 6);
+        assert_eq!(or_si64(4, 2), 6);
+        assert_eq!(or_si64(3, 4), 7);
+        assert_eq!(or_si64(4, 3), 7);
+        assert_eq!(or_si64(0, 5577148965131116544), 5577148965131116544);
+        assert_eq!(or_si64(5577148965131116544, 0), 5577148965131116544);
+        assert_eq!(
+            or_si64(5577148965131116544, 5577148965131116544),
+            5577148965131116544
+        );
+        assert_eq!(or_si64(1, 5577148965131116544), 5577148965131116545);
+        assert_eq!(or_si64(5577148965131116544, 1), 5577148965131116545);
+        assert_eq!(or_si64(2, 5577148965131116544), 5577148965131116546);
+        assert_eq!(or_si64(5577148965131116544, 2), 5577148965131116546);
+        assert_eq!(or_si64(3, 5577148965131116544), 5577148965131116547);
+        assert_eq!(or_si64(5577148965131116544, 3), 5577148965131116547);
+        assert_eq!(or_si64(4, 5577148965131116544), 5577148965131116548);
+        assert_eq!(or_si64(5577148965131116544, 4), 5577148965131116548);
+        assert_eq!(or_si64(0, 9223372036854775806), 9223372036854775806);
+        assert_eq!(or_si64(2, 9223372036854775806), 9223372036854775806);
+        assert_eq!(or_si64(4, 9223372036854775806), 9223372036854775806);
+        assert_eq!(
+            or_si64(5577148965131116544, 9223372036854775806),
+            9223372036854775806
+        );
+        assert_eq!(or_si64(9223372036854775806, 0), 9223372036854775806);
+        assert_eq!(or_si64(9223372036854775806, 2), 9223372036854775806);
+        assert_eq!(or_si64(9223372036854775806, 4), 9223372036854775806);
+        assert_eq!(
+            or_si64(9223372036854775806, 5577148965131116544),
+            9223372036854775806
+        );
+        assert_eq!(
+            or_si64(9223372036854775806, 9223372036854775806),
+            9223372036854775806
+        );
+        assert_eq!(or_si64(0, 9223372036854775807), 9223372036854775807);
+        assert_eq!(or_si64(1, 9223372036854775806), 9223372036854775807);
+        assert_eq!(or_si64(1, 9223372036854775807), 9223372036854775807);
+        assert_eq!(or_si64(2, 9223372036854775807), 9223372036854775807);
+        assert_eq!(or_si64(3, 9223372036854775806), 9223372036854775807);
+        assert_eq!(or_si64(3, 9223372036854775807), 9223372036854775807);
+        assert_eq!(or_si64(4, 9223372036854775807), 9223372036854775807);
+        assert_eq!(
+            or_si64(5577148965131116544, 9223372036854775807),
+            9223372036854775807
+        );
+        assert_eq!(or_si64(9223372036854775806, 1), 9223372036854775807);
+        assert_eq!(or_si64(9223372036854775806, 3), 9223372036854775807);
+        assert_eq!(
+            or_si64(9223372036854775806, 9223372036854775807),
+            9223372036854775807
+        );
+        assert_eq!(or_si64(9223372036854775807, 0), 9223372036854775807);
+        assert_eq!(or_si64(9223372036854775807, 1), 9223372036854775807);
+        assert_eq!(or_si64(9223372036854775807, 2), 9223372036854775807);
+        assert_eq!(or_si64(9223372036854775807, 3), 9223372036854775807);
+        assert_eq!(or_si64(9223372036854775807, 4), 9223372036854775807);
+        assert_eq!(
+            or_si64(9223372036854775807, 5577148965131116544),
+            9223372036854775807
+        );
+        assert_eq!(
+            or_si64(9223372036854775807, 9223372036854775806),
+            9223372036854775807
+        );
+        assert_eq!(
+            or_si64(9223372036854775807, 9223372036854775807),
+            9223372036854775807
+        );
+        assert_eq!(or_si8(-128, -128), -128);
+        assert_eq!(or_si8(-128, 0), -128);
+        assert_eq!(or_si8(0, -128), -128);
+        assert_eq!(or_si8(-128, -127), -127);
+        assert_eq!(or_si8(-128, 1), -127);
+        assert_eq!(or_si8(-127, -128), -127);
+        assert_eq!(or_si8(-127, -127), -127);
+        assert_eq!(or_si8(-127, 0), -127);
+        assert_eq!(or_si8(-127, 1), -127);
+        assert_eq!(or_si8(0, -127), -127);
+        assert_eq!(or_si8(1, -128), -127);
+        assert_eq!(or_si8(1, -127), -127);
+        assert_eq!(or_si8(-128, 2), -126);
+        assert_eq!(or_si8(2, -128), -126);
+        assert_eq!(or_si8(-128, 3), -125);
+        assert_eq!(or_si8(-127, 2), -125);
+        assert_eq!(or_si8(-127, 3), -125);
+        assert_eq!(or_si8(2, -127), -125);
+        assert_eq!(or_si8(3, -128), -125);
+        assert_eq!(or_si8(3, -127), -125);
+        assert_eq!(or_si8(-128, 4), -124);
+        assert_eq!(or_si8(4, -128), -124);
+        assert_eq!(or_si8(-127, 4), -123);
+        assert_eq!(or_si8(4, -127), -123);
+        assert_eq!(or_si8(-128, 16), -112);
+        assert_eq!(or_si8(16, -128), -112);
+        assert_eq!(or_si8(-127, 16), -111);
+        assert_eq!(or_si8(16, -127), -111);
+        assert_eq!(or_si8(-128, 126), -2);
+        assert_eq!(or_si8(126, -128), -2);
+        assert_eq!(or_si8(-128, 127), -1);
+        assert_eq!(or_si8(-127, 126), -1);
+        assert_eq!(or_si8(-127, 127), -1);
+        assert_eq!(or_si8(126, -127), -1);
+        assert_eq!(or_si8(127, -128), -1);
+        assert_eq!(or_si8(127, -127), -1);
+        assert_eq!(or_si8(0, 0), 0);
+        assert_eq!(or_si8(0, 1), 1);
+        assert_eq!(or_si8(1, 0), 1);
+        assert_eq!(or_si8(1, 1), 1);
+        assert_eq!(or_si8(0, 2), 2);
+        assert_eq!(or_si8(2, 0), 2);
+        assert_eq!(or_si8(2, 2), 2);
+        assert_eq!(or_si8(0, 3), 3);
+        assert_eq!(or_si8(1, 2), 3);
+        assert_eq!(or_si8(1, 3), 3);
+        assert_eq!(or_si8(2, 1), 3);
+        assert_eq!(or_si8(2, 3), 3);
+        assert_eq!(or_si8(3, 0), 3);
+        assert_eq!(or_si8(3, 1), 3);
+        assert_eq!(or_si8(3, 2), 3);
+        assert_eq!(or_si8(3, 3), 3);
+        assert_eq!(or_si8(0, 4), 4);
+        assert_eq!(or_si8(4, 0), 4);
+        assert_eq!(or_si8(4, 4), 4);
+        assert_eq!(or_si8(1, 4), 5);
+        assert_eq!(or_si8(4, 1), 5);
+        assert_eq!(or_si8(2, 4), 6);
+        assert_eq!(or_si8(4, 2), 6);
+        assert_eq!(or_si8(3, 4), 7);
+        assert_eq!(or_si8(4, 3), 7);
+        assert_eq!(or_si8(0, 16), 16);
+        assert_eq!(or_si8(16, 0), 16);
+        assert_eq!(or_si8(16, 16), 16);
+        assert_eq!(or_si8(1, 16), 17);
+        assert_eq!(or_si8(16, 1), 17);
+        assert_eq!(or_si8(2, 16), 18);
+        assert_eq!(or_si8(16, 2), 18);
+        assert_eq!(or_si8(3, 16), 19);
+        assert_eq!(or_si8(16, 3), 19);
+        assert_eq!(or_si8(4, 16), 20);
+        assert_eq!(or_si8(16, 4), 20);
+        assert_eq!(or_si8(0, 126), 126);
+        assert_eq!(or_si8(2, 126), 126);
+        assert_eq!(or_si8(4, 126), 126);
+        assert_eq!(or_si8(16, 126), 126);
+        assert_eq!(or_si8(126, 0), 126);
+        assert_eq!(or_si8(126, 2), 126);
+        assert_eq!(or_si8(126, 4), 126);
+        assert_eq!(or_si8(126, 16), 126);
+        assert_eq!(or_si8(126, 126), 126);
+        assert_eq!(or_si8(0, 127), 127);
+        assert_eq!(or_si8(1, 126), 127);
+        assert_eq!(or_si8(1, 127), 127);
+        assert_eq!(or_si8(2, 127), 127);
+        assert_eq!(or_si8(3, 126), 127);
+        assert_eq!(or_si8(3, 127), 127);
+        assert_eq!(or_si8(4, 127), 127);
+        assert_eq!(or_si8(16, 127), 127);
+        assert_eq!(or_si8(126, 1), 127);
+        assert_eq!(or_si8(126, 3), 127);
+        assert_eq!(or_si8(126, 127), 127);
+        assert_eq!(or_si8(127, 0), 127);
+        assert_eq!(or_si8(127, 1), 127);
+        assert_eq!(or_si8(127, 2), 127);
+        assert_eq!(or_si8(127, 3), 127);
+        assert_eq!(or_si8(127, 4), 127);
+        assert_eq!(or_si8(127, 16), 127);
+        assert_eq!(or_si8(127, 126), 127);
+        assert_eq!(or_si8(127, 127), 127);
+        assert_eq!(or_ui16(0, 0), 0);
+        assert_eq!(or_ui16(0, 1), 1);
+        assert_eq!(or_ui16(1, 0), 1);
+        assert_eq!(or_ui16(1, 1), 1);
+        assert_eq!(or_ui16(0, 2), 2);
+        assert_eq!(or_ui16(2, 0), 2);
+        assert_eq!(or_ui16(2, 2), 2);
+        assert_eq!(or_ui16(0, 3), 3);
+        assert_eq!(or_ui16(1, 2), 3);
+        assert_eq!(or_ui16(1, 3), 3);
+        assert_eq!(or_ui16(2, 1), 3);
+        assert_eq!(or_ui16(2, 3), 3);
+        assert_eq!(or_ui16(3, 0), 3);
+        assert_eq!(or_ui16(3, 1), 3);
+        assert_eq!(or_ui16(3, 2), 3);
+        assert_eq!(or_ui16(3, 3), 3);
+        assert_eq!(or_ui16(0, 4), 4);
+        assert_eq!(or_ui16(4, 0), 4);
+        assert_eq!(or_ui16(4, 4), 4);
+        assert_eq!(or_ui16(1, 4), 5);
+        assert_eq!(or_ui16(4, 1), 5);
+        assert_eq!(or_ui16(2, 4), 6);
+        assert_eq!(or_ui16(4, 2), 6);
+        assert_eq!(or_ui16(3, 4), 7);
+        assert_eq!(or_ui16(4, 3), 7);
+        assert_eq!(or_ui16(0, 1717), 1717);
+        assert_eq!(or_ui16(1, 1717), 1717);
+        assert_eq!(or_ui16(4, 1717), 1717);
+        assert_eq!(or_ui16(1717, 0), 1717);
+        assert_eq!(or_ui16(1717, 1), 1717);
+        assert_eq!(or_ui16(1717, 4), 1717);
+        assert_eq!(or_ui16(1717, 1717), 1717);
+        assert_eq!(or_ui16(2, 1717), 1719);
+        assert_eq!(or_ui16(3, 1717), 1719);
+        assert_eq!(or_ui16(1717, 2), 1719);
+        assert_eq!(or_ui16(1717, 3), 1719);
+        assert_eq!(or_ui16(0, 17988), 17988);
+        assert_eq!(or_ui16(4, 17988), 17988);
+        assert_eq!(or_ui16(17988, 0), 17988);
+        assert_eq!(or_ui16(17988, 4), 17988);
+        assert_eq!(or_ui16(17988, 17988), 17988);
+        assert_eq!(or_ui16(1, 17988), 17989);
+        assert_eq!(or_ui16(17988, 1), 17989);
+        assert_eq!(or_ui16(2, 17988), 17990);
+        assert_eq!(or_ui16(17988, 2), 17990);
+        assert_eq!(or_ui16(3, 17988), 17991);
+        assert_eq!(or_ui16(17988, 3), 17991);
+        assert_eq!(or_ui16(1717, 17988), 18165);
+        assert_eq!(or_ui16(17988, 1717), 18165);
+        assert_eq!(or_ui16(0, 65096), 65096);
+        assert_eq!(or_ui16(65096, 0), 65096);
+        assert_eq!(or_ui16(65096, 65096), 65096);
+        assert_eq!(or_ui16(1, 65096), 65097);
+        assert_eq!(or_ui16(65096, 1), 65097);
+        assert_eq!(or_ui16(2, 65096), 65098);
+        assert_eq!(or_ui16(65096, 2), 65098);
+        assert_eq!(or_ui16(3, 65096), 65099);
+        assert_eq!(or_ui16(65096, 3), 65099);
+        assert_eq!(or_ui16(4, 65096), 65100);
+        assert_eq!(or_ui16(17988, 65096), 65100);
+        assert_eq!(or_ui16(65096, 4), 65100);
+        assert_eq!(or_ui16(65096, 17988), 65100);
+        assert_eq!(or_ui16(1717, 65096), 65277);
+        assert_eq!(or_ui16(65096, 1717), 65277);
+        assert_eq!(or_ui16(0, 65534), 65534);
+        assert_eq!(or_ui16(2, 65534), 65534);
+        assert_eq!(or_ui16(4, 65534), 65534);
+        assert_eq!(or_ui16(17988, 65534), 65534);
+        assert_eq!(or_ui16(65096, 65534), 65534);
+        assert_eq!(or_ui16(65534, 0), 65534);
+        assert_eq!(or_ui16(65534, 2), 65534);
+        assert_eq!(or_ui16(65534, 4), 65534);
+        assert_eq!(or_ui16(65534, 17988), 65534);
+        assert_eq!(or_ui16(65534, 65096), 65534);
+        assert_eq!(or_ui16(65534, 65534), 65534);
+        assert_eq!(or_ui16(0, 65535), 65535);
+        assert_eq!(or_ui16(1, 65534), 65535);
+        assert_eq!(or_ui16(1, 65535), 65535);
+        assert_eq!(or_ui16(2, 65535), 65535);
+        assert_eq!(or_ui16(3, 65534), 65535);
+        assert_eq!(or_ui16(3, 65535), 65535);
+        assert_eq!(or_ui16(4, 65535), 65535);
+        assert_eq!(or_ui16(1717, 65534), 65535);
+        assert_eq!(or_ui16(1717, 65535), 65535);
+        assert_eq!(or_ui16(17988, 65535), 65535);
+        assert_eq!(or_ui16(65096, 65535), 65535);
+        assert_eq!(or_ui16(65534, 1), 65535);
+        assert_eq!(or_ui16(65534, 3), 65535);
+        assert_eq!(or_ui16(65534, 1717), 65535);
+        assert_eq!(or_ui16(65534, 65535), 65535);
+        assert_eq!(or_ui16(65535, 0), 65535);
+        assert_eq!(or_ui16(65535, 1), 65535);
+        assert_eq!(or_ui16(65535, 2), 65535);
+        assert_eq!(or_ui16(65535, 3), 65535);
+        assert_eq!(or_ui16(65535, 4), 65535);
+        assert_eq!(or_ui16(65535, 1717), 65535);
+        assert_eq!(or_ui16(65535, 17988), 65535);
+        assert_eq!(or_ui16(65535, 65096), 65535);
+        assert_eq!(or_ui16(65535, 65534), 65535);
+        assert_eq!(or_ui16(65535, 65535), 65535);
+        assert_eq!(or_ui32(0, 0), 0);
+        assert_eq!(or_ui32(0, 1), 1);
+        assert_eq!(or_ui32(1, 0), 1);
+        assert_eq!(or_ui32(1, 1), 1);
+        assert_eq!(or_ui32(0, 2), 2);
+        assert_eq!(or_ui32(2, 0), 2);
+        assert_eq!(or_ui32(2, 2), 2);
+        assert_eq!(or_ui32(0, 3), 3);
+        assert_eq!(or_ui32(1, 2), 3);
+        assert_eq!(or_ui32(1, 3), 3);
+        assert_eq!(or_ui32(2, 1), 3);
+        assert_eq!(or_ui32(2, 3), 3);
+        assert_eq!(or_ui32(3, 0), 3);
+        assert_eq!(or_ui32(3, 1), 3);
+        assert_eq!(or_ui32(3, 2), 3);
+        assert_eq!(or_ui32(3, 3), 3);
+        assert_eq!(or_ui32(0, 4), 4);
+        assert_eq!(or_ui32(4, 0), 4);
+        assert_eq!(or_ui32(4, 4), 4);
+        assert_eq!(or_ui32(1, 4), 5);
+        assert_eq!(or_ui32(4, 1), 5);
+        assert_eq!(or_ui32(2, 4), 6);
+        assert_eq!(or_ui32(4, 2), 6);
+        assert_eq!(or_ui32(3, 4), 7);
+        assert_eq!(or_ui32(4, 3), 7);
+        assert_eq!(or_ui32(0, 2119154652), 2119154652);
+        assert_eq!(or_ui32(4, 2119154652), 2119154652);
+        assert_eq!(or_ui32(2119154652, 0), 2119154652);
+        assert_eq!(or_ui32(2119154652, 4), 2119154652);
+        assert_eq!(or_ui32(2119154652, 2119154652), 2119154652);
+        assert_eq!(or_ui32(1, 2119154652), 2119154653);
+        assert_eq!(or_ui32(2119154652, 1), 2119154653);
+        assert_eq!(or_ui32(2, 2119154652), 2119154654);
+        assert_eq!(or_ui32(2119154652, 2), 2119154654);
+        assert_eq!(or_ui32(3, 2119154652), 2119154655);
+        assert_eq!(or_ui32(2119154652, 3), 2119154655);
+        assert_eq!(or_ui32(0, 3002788344), 3002788344);
+        assert_eq!(or_ui32(3002788344, 0), 3002788344);
+        assert_eq!(or_ui32(3002788344, 3002788344), 3002788344);
+        assert_eq!(or_ui32(1, 3002788344), 3002788345);
+        assert_eq!(or_ui32(3002788344, 1), 3002788345);
+        assert_eq!(or_ui32(2, 3002788344), 3002788346);
+        assert_eq!(or_ui32(3002788344, 2), 3002788346);
+        assert_eq!(or_ui32(3, 3002788344), 3002788347);
+        assert_eq!(or_ui32(3002788344, 3), 3002788347);
+        assert_eq!(or_ui32(4, 3002788344), 3002788348);
+        assert_eq!(or_ui32(3002788344, 4), 3002788348);
+        assert_eq!(or_ui32(0, 3482297128), 3482297128);
+        assert_eq!(or_ui32(3482297128, 0), 3482297128);
+        assert_eq!(or_ui32(3482297128, 3482297128), 3482297128);
+        assert_eq!(or_ui32(1, 3482297128), 3482297129);
+        assert_eq!(or_ui32(3482297128, 1), 3482297129);
+        assert_eq!(or_ui32(2, 3482297128), 3482297130);
+        assert_eq!(or_ui32(3482297128, 2), 3482297130);
+        assert_eq!(or_ui32(3, 3482297128), 3482297131);
+        assert_eq!(or_ui32(3482297128, 3), 3482297131);
+        assert_eq!(or_ui32(4, 3482297128), 3482297132);
+        assert_eq!(or_ui32(3482297128, 4), 3482297132);
+        assert_eq!(or_ui32(2119154652, 3002788344), 4278189052);
+        assert_eq!(or_ui32(3002788344, 2119154652), 4278189052);
+        assert_eq!(or_ui32(2119154652, 3482297128), 4291804156);
+        assert_eq!(or_ui32(3482297128, 2119154652), 4291804156);
+        assert_eq!(or_ui32(3002788344, 3482297128), 4294962168);
+        assert_eq!(or_ui32(3482297128, 3002788344), 4294962168);
+        assert_eq!(or_ui32(0, 4294967294), 4294967294);
+        assert_eq!(or_ui32(2, 4294967294), 4294967294);
+        assert_eq!(or_ui32(4, 4294967294), 4294967294);
+        assert_eq!(or_ui32(2119154652, 4294967294), 4294967294);
+        assert_eq!(or_ui32(3002788344, 4294967294), 4294967294);
+        assert_eq!(or_ui32(3482297128, 4294967294), 4294967294);
+        assert_eq!(or_ui32(4294967294, 0), 4294967294);
+        assert_eq!(or_ui32(4294967294, 2), 4294967294);
+        assert_eq!(or_ui32(4294967294, 4), 4294967294);
+        assert_eq!(or_ui32(4294967294, 2119154652), 4294967294);
+        assert_eq!(or_ui32(4294967294, 3002788344), 4294967294);
+        assert_eq!(or_ui32(4294967294, 3482297128), 4294967294);
+        assert_eq!(or_ui32(4294967294, 4294967294), 4294967294);
+        assert_eq!(or_ui32(0, 4294967295), 4294967295);
+        assert_eq!(or_ui32(1, 4294967294), 4294967295);
+        assert_eq!(or_ui32(1, 4294967295), 4294967295);
+        assert_eq!(or_ui32(2, 4294967295), 4294967295);
+        assert_eq!(or_ui32(3, 4294967294), 4294967295);
+        assert_eq!(or_ui32(3, 4294967295), 4294967295);
+        assert_eq!(or_ui32(4, 4294967295), 4294967295);
+        assert_eq!(or_ui32(2119154652, 4294967295), 4294967295);
+        assert_eq!(or_ui32(3002788344, 4294967295), 4294967295);
+        assert_eq!(or_ui32(3482297128, 4294967295), 4294967295);
+        assert_eq!(or_ui32(4294967294, 1), 4294967295);
+        assert_eq!(or_ui32(4294967294, 3), 4294967295);
+        assert_eq!(or_ui32(4294967294, 4294967295), 4294967295);
+        assert_eq!(or_ui32(4294967295, 0), 4294967295);
+        assert_eq!(or_ui32(4294967295, 1), 4294967295);
+        assert_eq!(or_ui32(4294967295, 2), 4294967295);
+        assert_eq!(or_ui32(4294967295, 3), 4294967295);
+        assert_eq!(or_ui32(4294967295, 4), 4294967295);
+        assert_eq!(or_ui32(4294967295, 2119154652), 4294967295);
+        assert_eq!(or_ui32(4294967295, 3002788344), 4294967295);
+        assert_eq!(or_ui32(4294967295, 3482297128), 4294967295);
+        assert_eq!(or_ui32(4294967295, 4294967294), 4294967295);
+        assert_eq!(or_ui32(4294967295, 4294967295), 4294967295);
+        assert_eq!(or_ui64(0, 0), 0);
+        assert_eq!(or_ui64(0, 1), 1);
+        assert_eq!(or_ui64(1, 0), 1);
+        assert_eq!(or_ui64(1, 1), 1);
+        assert_eq!(or_ui64(0, 2), 2);
+        assert_eq!(or_ui64(2, 0), 2);
+        assert_eq!(or_ui64(2, 2), 2);
+        assert_eq!(or_ui64(0, 3), 3);
+        assert_eq!(or_ui64(1, 2), 3);
+        assert_eq!(or_ui64(1, 3), 3);
+        assert_eq!(or_ui64(2, 1), 3);
+        assert_eq!(or_ui64(2, 3), 3);
+        assert_eq!(or_ui64(3, 0), 3);
+        assert_eq!(or_ui64(3, 1), 3);
+        assert_eq!(or_ui64(3, 2), 3);
+        assert_eq!(or_ui64(3, 3), 3);
+        assert_eq!(or_ui64(0, 4), 4);
+        assert_eq!(or_ui64(4, 0), 4);
+        assert_eq!(or_ui64(4, 4), 4);
+        assert_eq!(or_ui64(1, 4), 5);
+        assert_eq!(or_ui64(4, 1), 5);
+        assert_eq!(or_ui64(2, 4), 6);
+        assert_eq!(or_ui64(4, 2), 6);
+        assert_eq!(or_ui64(3, 4), 7);
+        assert_eq!(or_ui64(4, 3), 7);
+        assert_eq!(or_ui64(0, 191084152064409600), 191084152064409600);
+        assert_eq!(or_ui64(191084152064409600, 0), 191084152064409600);
+        assert_eq!(
+            or_ui64(191084152064409600, 191084152064409600),
+            191084152064409600
+        );
+        assert_eq!(or_ui64(1, 191084152064409600), 191084152064409601);
+        assert_eq!(or_ui64(191084152064409600, 1), 191084152064409601);
+        assert_eq!(or_ui64(2, 191084152064409600), 191084152064409602);
+        assert_eq!(or_ui64(191084152064409600, 2), 191084152064409602);
+        assert_eq!(or_ui64(3, 191084152064409600), 191084152064409603);
+        assert_eq!(or_ui64(191084152064409600, 3), 191084152064409603);
+        assert_eq!(or_ui64(4, 191084152064409600), 191084152064409604);
+        assert_eq!(or_ui64(191084152064409600, 4), 191084152064409604);
+        assert_eq!(or_ui64(0, 11015955194427482112), 11015955194427482112);
+        assert_eq!(or_ui64(11015955194427482112, 0), 11015955194427482112);
+        assert_eq!(
+            or_ui64(11015955194427482112, 11015955194427482112),
+            11015955194427482112
+        );
+        assert_eq!(or_ui64(1, 11015955194427482112), 11015955194427482113);
+        assert_eq!(or_ui64(11015955194427482112, 1), 11015955194427482113);
+        assert_eq!(or_ui64(2, 11015955194427482112), 11015955194427482114);
+        assert_eq!(or_ui64(11015955194427482112, 2), 11015955194427482114);
+        assert_eq!(or_ui64(3, 11015955194427482112), 11015955194427482115);
+        assert_eq!(or_ui64(11015955194427482112, 3), 11015955194427482115);
+        assert_eq!(or_ui64(4, 11015955194427482112), 11015955194427482116);
+        assert_eq!(or_ui64(11015955194427482112, 4), 11015955194427482116);
+        assert_eq!(
+            or_ui64(191084152064409600, 11015955194427482112),
+            11161853808046874624
+        );
+        assert_eq!(
+            or_ui64(11015955194427482112, 191084152064409600),
+            11161853808046874624
+        );
+        assert_eq!(or_ui64(0, 16990600415051759616), 16990600415051759616);
+        assert_eq!(or_ui64(16990600415051759616, 0), 16990600415051759616);
+        assert_eq!(
+            or_ui64(16990600415051759616, 16990600415051759616),
+            16990600415051759616
+        );
+        assert_eq!(or_ui64(1, 16990600415051759616), 16990600415051759617);
+        assert_eq!(or_ui64(16990600415051759616, 1), 16990600415051759617);
+        assert_eq!(or_ui64(2, 16990600415051759616), 16990600415051759618);
+        assert_eq!(or_ui64(16990600415051759616, 2), 16990600415051759618);
+        assert_eq!(or_ui64(3, 16990600415051759616), 16990600415051759619);
+        assert_eq!(or_ui64(16990600415051759616, 3), 16990600415051759619);
+        assert_eq!(or_ui64(4, 16990600415051759616), 16990600415051759620);
+        assert_eq!(or_ui64(16990600415051759616, 4), 16990600415051759620);
+        assert_eq!(
+            or_ui64(191084152064409600, 16990600415051759616),
+            17000806082182103040
+        );
+        assert_eq!(
+            or_ui64(16990600415051759616, 191084152064409600),
+            17000806082182103040
+        );
+        assert_eq!(
+            or_ui64(11015955194427482112, 16990600415051759616),
+            18152530082063441920
+        );
+        assert_eq!(
+            or_ui64(16990600415051759616, 11015955194427482112),
+            18152530082063441920
+        );
+        assert_eq!(or_ui64(0, 18446744073709551614), 18446744073709551614);
+        assert_eq!(or_ui64(2, 18446744073709551614), 18446744073709551614);
+        assert_eq!(or_ui64(4, 18446744073709551614), 18446744073709551614);
+        assert_eq!(
+            or_ui64(191084152064409600, 18446744073709551614),
+            18446744073709551614
+        );
+        assert_eq!(
+            or_ui64(11015955194427482112, 18446744073709551614),
+            18446744073709551614
+        );
+        assert_eq!(
+            or_ui64(16990600415051759616, 18446744073709551614),
+            18446744073709551614
+        );
+        assert_eq!(or_ui64(18446744073709551614, 0), 18446744073709551614);
+        assert_eq!(or_ui64(18446744073709551614, 2), 18446744073709551614);
+        assert_eq!(or_ui64(18446744073709551614, 4), 18446744073709551614);
+        assert_eq!(
+            or_ui64(18446744073709551614, 191084152064409600),
+            18446744073709551614
+        );
+        assert_eq!(
+            or_ui64(18446744073709551614, 11015955194427482112),
+            18446744073709551614
+        );
+        assert_eq!(
+            or_ui64(18446744073709551614, 16990600415051759616),
+            18446744073709551614
+        );
+        assert_eq!(
+            or_ui64(18446744073709551614, 18446744073709551614),
+            18446744073709551614
+        );
+        assert_eq!(or_ui64(0, 18446744073709551615), 18446744073709551615);
+        assert_eq!(or_ui64(1, 18446744073709551614), 18446744073709551615);
+        assert_eq!(or_ui64(1, 18446744073709551615), 18446744073709551615);
+        assert_eq!(or_ui64(2, 18446744073709551615), 18446744073709551615);
+        assert_eq!(or_ui64(3, 18446744073709551614), 18446744073709551615);
+        assert_eq!(or_ui64(3, 18446744073709551615), 18446744073709551615);
+        assert_eq!(or_ui64(4, 18446744073709551615), 18446744073709551615);
+        assert_eq!(
+            or_ui64(191084152064409600, 18446744073709551615),
+            18446744073709551615
+        );
+        assert_eq!(
+            or_ui64(11015955194427482112, 18446744073709551615),
+            18446744073709551615
+        );
+        assert_eq!(
+            or_ui64(16990600415051759616, 18446744073709551615),
+            18446744073709551615
+        );
+        assert_eq!(or_ui64(18446744073709551614, 1), 18446744073709551615);
+        assert_eq!(or_ui64(18446744073709551614, 3), 18446744073709551615);
+        assert_eq!(
+            or_ui64(18446744073709551614, 18446744073709551615),
+            18446744073709551615
+        );
+        assert_eq!(or_ui64(18446744073709551615, 0), 18446744073709551615);
+        assert_eq!(or_ui64(18446744073709551615, 1), 18446744073709551615);
+        assert_eq!(or_ui64(18446744073709551615, 2), 18446744073709551615);
+        assert_eq!(or_ui64(18446744073709551615, 3), 18446744073709551615);
+        assert_eq!(or_ui64(18446744073709551615, 4), 18446744073709551615);
+        assert_eq!(
+            or_ui64(18446744073709551615, 191084152064409600),
+            18446744073709551615
+        );
+        assert_eq!(
+            or_ui64(18446744073709551615, 11015955194427482112),
+            18446744073709551615
+        );
+        assert_eq!(
+            or_ui64(18446744073709551615, 16990600415051759616),
+            18446744073709551615
+        );
+        assert_eq!(
+            or_ui64(18446744073709551615, 18446744073709551614),
+            18446744073709551615
+        );
+        assert_eq!(
+            or_ui64(18446744073709551615, 18446744073709551615),
+            18446744073709551615
+        );
+        assert_eq!(or_ui8(0, 0), 0);
+        assert_eq!(or_ui8(0, 1), 1);
+        assert_eq!(or_ui8(1, 0), 1);
+        assert_eq!(or_ui8(1, 1), 1);
+        assert_eq!(or_ui8(0, 2), 2);
+        assert_eq!(or_ui8(2, 0), 2);
+        assert_eq!(or_ui8(2, 2), 2);
+        assert_eq!(or_ui8(0, 3), 3);
+        assert_eq!(or_ui8(1, 2), 3);
+        assert_eq!(or_ui8(1, 3), 3);
+        assert_eq!(or_ui8(2, 1), 3);
+        assert_eq!(or_ui8(2, 3), 3);
+        assert_eq!(or_ui8(3, 0), 3);
+        assert_eq!(or_ui8(3, 1), 3);
+        assert_eq!(or_ui8(3, 2), 3);
+        assert_eq!(or_ui8(3, 3), 3);
+        assert_eq!(or_ui8(0, 4), 4);
+        assert_eq!(or_ui8(4, 0), 4);
+        assert_eq!(or_ui8(4, 4), 4);
+        assert_eq!(or_ui8(1, 4), 5);
+        assert_eq!(or_ui8(4, 1), 5);
+        assert_eq!(or_ui8(2, 4), 6);
+        assert_eq!(or_ui8(4, 2), 6);
+        assert_eq!(or_ui8(3, 4), 7);
+        assert_eq!(or_ui8(4, 3), 7);
+        assert_eq!(or_ui8(0, 72), 72);
+        assert_eq!(or_ui8(72, 0), 72);
+        assert_eq!(or_ui8(72, 72), 72);
+        assert_eq!(or_ui8(1, 72), 73);
+        assert_eq!(or_ui8(72, 1), 73);
+        assert_eq!(or_ui8(2, 72), 74);
+        assert_eq!(or_ui8(72, 2), 74);
+        assert_eq!(or_ui8(3, 72), 75);
+        assert_eq!(or_ui8(72, 3), 75);
+        assert_eq!(or_ui8(4, 72), 76);
+        assert_eq!(or_ui8(72, 4), 76);
+        assert_eq!(or_ui8(0, 100), 100);
+        assert_eq!(or_ui8(4, 100), 100);
+        assert_eq!(or_ui8(100, 0), 100);
+        assert_eq!(or_ui8(100, 4), 100);
+        assert_eq!(or_ui8(100, 100), 100);
+        assert_eq!(or_ui8(1, 100), 101);
+        assert_eq!(or_ui8(100, 1), 101);
+        assert_eq!(or_ui8(2, 100), 102);
+        assert_eq!(or_ui8(100, 2), 102);
+        assert_eq!(or_ui8(3, 100), 103);
+        assert_eq!(or_ui8(100, 3), 103);
+        assert_eq!(or_ui8(72, 100), 108);
+        assert_eq!(or_ui8(100, 72), 108);
+        assert_eq!(or_ui8(0, 162), 162);
+        assert_eq!(or_ui8(2, 162), 162);
+        assert_eq!(or_ui8(162, 0), 162);
+        assert_eq!(or_ui8(162, 2), 162);
+        assert_eq!(or_ui8(162, 162), 162);
+        assert_eq!(or_ui8(1, 162), 163);
+        assert_eq!(or_ui8(3, 162), 163);
+        assert_eq!(or_ui8(162, 1), 163);
+        assert_eq!(or_ui8(162, 3), 163);
+        assert_eq!(or_ui8(4, 162), 166);
+        assert_eq!(or_ui8(162, 4), 166);
+        assert_eq!(or_ui8(100, 162), 230);
+        assert_eq!(or_ui8(162, 100), 230);
+        assert_eq!(or_ui8(72, 162), 234);
+        assert_eq!(or_ui8(162, 72), 234);
+        assert_eq!(or_ui8(0, 254), 254);
+        assert_eq!(or_ui8(2, 254), 254);
+        assert_eq!(or_ui8(4, 254), 254);
+        assert_eq!(or_ui8(72, 254), 254);
+        assert_eq!(or_ui8(100, 254), 254);
+        assert_eq!(or_ui8(162, 254), 254);
+        assert_eq!(or_ui8(254, 0), 254);
+        assert_eq!(or_ui8(254, 2), 254);
+        assert_eq!(or_ui8(254, 4), 254);
+        assert_eq!(or_ui8(254, 72), 254);
+        assert_eq!(or_ui8(254, 100), 254);
+        assert_eq!(or_ui8(254, 162), 254);
+        assert_eq!(or_ui8(254, 254), 254);
+        assert_eq!(or_ui8(0, 255), 255);
+        assert_eq!(or_ui8(1, 254), 255);
+        assert_eq!(or_ui8(1, 255), 255);
+        assert_eq!(or_ui8(2, 255), 255);
+        assert_eq!(or_ui8(3, 254), 255);
+        assert_eq!(or_ui8(3, 255), 255);
+        assert_eq!(or_ui8(4, 255), 255);
+        assert_eq!(or_ui8(72, 255), 255);
+        assert_eq!(or_ui8(100, 255), 255);
+        assert_eq!(or_ui8(162, 255), 255);
+        assert_eq!(or_ui8(254, 1), 255);
+        assert_eq!(or_ui8(254, 3), 255);
+        assert_eq!(or_ui8(254, 255), 255);
+        assert_eq!(or_ui8(255, 0), 255);
+        assert_eq!(or_ui8(255, 1), 255);
+        assert_eq!(or_ui8(255, 2), 255);
+        assert_eq!(or_ui8(255, 3), 255);
+        assert_eq!(or_ui8(255, 4), 255);
+        assert_eq!(or_ui8(255, 72), 255);
+        assert_eq!(or_ui8(255, 100), 255);
+        assert_eq!(or_ui8(255, 162), 255);
+        assert_eq!(or_ui8(255, 254), 255);
+        assert_eq!(or_ui8(255, 255), 255);
+        assert_eq!(xor_si16(-32768, 0), -32768);
+        assert_eq!(xor_si16(-32767, 1), -32768);
+        assert_eq!(xor_si16(0, -32768), -32768);
+        assert_eq!(xor_si16(1, -32767), -32768);
+        assert_eq!(xor_si16(-32768, 1), -32767);
+        assert_eq!(xor_si16(-32767, 0), -32767);
+        assert_eq!(xor_si16(0, -32767), -32767);
+        assert_eq!(xor_si16(1, -32768), -32767);
+        assert_eq!(xor_si16(-32768, 2), -32766);
+        assert_eq!(xor_si16(-32767, 3), -32766);
+        assert_eq!(xor_si16(2, -32768), -32766);
+        assert_eq!(xor_si16(3, -32767), -32766);
+        assert_eq!(xor_si16(-32768, 3), -32765);
+        assert_eq!(xor_si16(-32767, 2), -32765);
+        assert_eq!(xor_si16(2, -32767), -32765);
+        assert_eq!(xor_si16(3, -32768), -32765);
+        assert_eq!(xor_si16(-32768, 4), -32764);
+        assert_eq!(xor_si16(4, -32768), -32764);
+        assert_eq!(xor_si16(-32767, 4), -32763);
+        assert_eq!(xor_si16(4, -32767), -32763);
+        assert_eq!(xor_si16(-32547, 4), -32551);
+        assert_eq!(xor_si16(4, -32547), -32551);
+        assert_eq!(xor_si16(-32547, 1), -32548);
+        assert_eq!(xor_si16(1, -32547), -32548);
+        assert_eq!(xor_si16(-32547, 0), -32547);
+        assert_eq!(xor_si16(0, -32547), -32547);
+        assert_eq!(xor_si16(-32547, 3), -32546);
+        assert_eq!(xor_si16(3, -32547), -32546);
+        assert_eq!(xor_si16(-32547, 2), -32545);
+        assert_eq!(xor_si16(2, -32547), -32545);
+        assert_eq!(xor_si16(-32547, 10486), -22485);
+        assert_eq!(xor_si16(10486, -32547), -22485);
+        assert_eq!(xor_si16(-32768, 10486), -22282);
+        assert_eq!(xor_si16(10486, -32768), -22282);
+        assert_eq!(xor_si16(-32767, 10486), -22281);
+        assert_eq!(xor_si16(10486, -32767), -22281);
+        assert_eq!(xor_si16(-32547, 16514), -16289);
+        assert_eq!(xor_si16(16514, -32547), -16289);
+        assert_eq!(xor_si16(-32768, 16514), -16254);
+        assert_eq!(xor_si16(16514, -32768), -16254);
+        assert_eq!(xor_si16(-32767, 16514), -16253);
+        assert_eq!(xor_si16(16514, -32767), -16253);
+        assert_eq!(xor_si16(-32547, 32767), -222);
+        assert_eq!(xor_si16(32767, -32547), -222);
+        assert_eq!(xor_si16(-32547, 32766), -221);
+        assert_eq!(xor_si16(32766, -32547), -221);
+        assert_eq!(xor_si16(-32768, 32766), -2);
+        assert_eq!(xor_si16(-32767, 32767), -2);
+        assert_eq!(xor_si16(32766, -32768), -2);
+        assert_eq!(xor_si16(32767, -32767), -2);
+        assert_eq!(xor_si16(-32768, 32767), -1);
+        assert_eq!(xor_si16(-32767, 32766), -1);
+        assert_eq!(xor_si16(32766, -32767), -1);
+        assert_eq!(xor_si16(32767, -32768), -1);
+        assert_eq!(xor_si16(-32768, -32768), 0);
+        assert_eq!(xor_si16(-32767, -32767), 0);
+        assert_eq!(xor_si16(-32547, -32547), 0);
+        assert_eq!(xor_si16(0, 0), 0);
+        assert_eq!(xor_si16(1, 1), 0);
+        assert_eq!(xor_si16(2, 2), 0);
+        assert_eq!(xor_si16(3, 3), 0);
+        assert_eq!(xor_si16(4, 4), 0);
+        assert_eq!(xor_si16(10486, 10486), 0);
+        assert_eq!(xor_si16(16514, 16514), 0);
+        assert_eq!(xor_si16(32766, 32766), 0);
+        assert_eq!(xor_si16(32767, 32767), 0);
+        assert_eq!(xor_si16(-32768, -32767), 1);
+        assert_eq!(xor_si16(-32767, -32768), 1);
+        assert_eq!(xor_si16(0, 1), 1);
+        assert_eq!(xor_si16(1, 0), 1);
+        assert_eq!(xor_si16(2, 3), 1);
+        assert_eq!(xor_si16(3, 2), 1);
+        assert_eq!(xor_si16(32766, 32767), 1);
+        assert_eq!(xor_si16(32767, 32766), 1);
+        assert_eq!(xor_si16(0, 2), 2);
+        assert_eq!(xor_si16(1, 3), 2);
+        assert_eq!(xor_si16(2, 0), 2);
+        assert_eq!(xor_si16(3, 1), 2);
+        assert_eq!(xor_si16(0, 3), 3);
+        assert_eq!(xor_si16(1, 2), 3);
+        assert_eq!(xor_si16(2, 1), 3);
+        assert_eq!(xor_si16(3, 0), 3);
+        assert_eq!(xor_si16(0, 4), 4);
+        assert_eq!(xor_si16(4, 0), 4);
+        assert_eq!(xor_si16(1, 4), 5);
+        assert_eq!(xor_si16(4, 1), 5);
+        assert_eq!(xor_si16(2, 4), 6);
+        assert_eq!(xor_si16(4, 2), 6);
+        assert_eq!(xor_si16(3, 4), 7);
+        assert_eq!(xor_si16(4, 3), 7);
+        assert_eq!(xor_si16(-32767, -32547), 220);
+        assert_eq!(xor_si16(-32547, -32767), 220);
+        assert_eq!(xor_si16(-32768, -32547), 221);
+        assert_eq!(xor_si16(-32547, -32768), 221);
+        assert_eq!(xor_si16(4, 10486), 10482);
+        assert_eq!(xor_si16(10486, 4), 10482);
+        assert_eq!(xor_si16(2, 10486), 10484);
+        assert_eq!(xor_si16(10486, 2), 10484);
+        assert_eq!(xor_si16(3, 10486), 10485);
+        assert_eq!(xor_si16(10486, 3), 10485);
+        assert_eq!(xor_si16(0, 10486), 10486);
+        assert_eq!(xor_si16(10486, 0), 10486);
+        assert_eq!(xor_si16(1, 10486), 10487);
+        assert_eq!(xor_si16(10486, 1), 10487);
+        assert_eq!(xor_si16(16514, 32766), 16252);
+        assert_eq!(xor_si16(32766, 16514), 16252);
+        assert_eq!(xor_si16(16514, 32767), 16253);
+        assert_eq!(xor_si16(32767, 16514), 16253);
+        assert_eq!(xor_si16(2, 16514), 16512);
+        assert_eq!(xor_si16(16514, 2), 16512);
+        assert_eq!(xor_si16(3, 16514), 16513);
+        assert_eq!(xor_si16(16514, 3), 16513);
+        assert_eq!(xor_si16(0, 16514), 16514);
+        assert_eq!(xor_si16(16514, 0), 16514);
+        assert_eq!(xor_si16(1, 16514), 16515);
+        assert_eq!(xor_si16(16514, 1), 16515);
+        assert_eq!(xor_si16(4, 16514), 16518);
+        assert_eq!(xor_si16(16514, 4), 16518);
+        assert_eq!(xor_si16(10486, 32766), 22280);
+        assert_eq!(xor_si16(32766, 10486), 22280);
+        assert_eq!(xor_si16(10486, 32767), 22281);
+        assert_eq!(xor_si16(32767, 10486), 22281);
+        assert_eq!(xor_si16(10486, 16514), 26740);
+        assert_eq!(xor_si16(16514, 10486), 26740);
+        assert_eq!(xor_si16(4, 32766), 32762);
+        assert_eq!(xor_si16(32766, 4), 32762);
+        assert_eq!(xor_si16(4, 32767), 32763);
+        assert_eq!(xor_si16(32767, 4), 32763);
+        assert_eq!(xor_si16(2, 32766), 32764);
+        assert_eq!(xor_si16(3, 32767), 32764);
+        assert_eq!(xor_si16(32766, 2), 32764);
+        assert_eq!(xor_si16(32767, 3), 32764);
+        assert_eq!(xor_si16(2, 32767), 32765);
+        assert_eq!(xor_si16(3, 32766), 32765);
+        assert_eq!(xor_si16(32766, 3), 32765);
+        assert_eq!(xor_si16(32767, 2), 32765);
+        assert_eq!(xor_si16(0, 32766), 32766);
+        assert_eq!(xor_si16(1, 32767), 32766);
+        assert_eq!(xor_si16(32766, 0), 32766);
+        assert_eq!(xor_si16(32767, 1), 32766);
+        assert_eq!(xor_si16(0, 32767), 32767);
+        assert_eq!(xor_si16(1, 32766), 32767);
+        assert_eq!(xor_si16(32766, 1), 32767);
+        assert_eq!(xor_si16(32767, 0), 32767);
+        assert_eq!(xor_si32(-2147483648, 0), -2147483648);
+        assert_eq!(xor_si32(-2147483647, 1), -2147483648);
+        assert_eq!(xor_si32(0, -2147483648), -2147483648);
+        assert_eq!(xor_si32(1, -2147483647), -2147483648);
+        assert_eq!(xor_si32(-2147483648, 1), -2147483647);
+        assert_eq!(xor_si32(-2147483647, 0), -2147483647);
+        assert_eq!(xor_si32(0, -2147483647), -2147483647);
+        assert_eq!(xor_si32(1, -2147483648), -2147483647);
+        assert_eq!(xor_si32(-2147483648, 2), -2147483646);
+        assert_eq!(xor_si32(-2147483647, 3), -2147483646);
+        assert_eq!(xor_si32(2, -2147483648), -2147483646);
+        assert_eq!(xor_si32(3, -2147483647), -2147483646);
+        assert_eq!(xor_si32(-2147483648, 3), -2147483645);
+        assert_eq!(xor_si32(-2147483647, 2), -2147483645);
+        assert_eq!(xor_si32(2, -2147483647), -2147483645);
+        assert_eq!(xor_si32(3, -2147483648), -2147483645);
+        assert_eq!(xor_si32(-2147483648, 4), -2147483644);
+        assert_eq!(xor_si32(4, -2147483648), -2147483644);
+        assert_eq!(xor_si32(-2147483647, 4), -2147483643);
+        assert_eq!(xor_si32(4, -2147483647), -2147483643);
+        assert_eq!(xor_si32(-1713183800, 0), -1713183800);
+        assert_eq!(xor_si32(0, -1713183800), -1713183800);
+        assert_eq!(xor_si32(-1713183800, 1), -1713183799);
+        assert_eq!(xor_si32(1, -1713183800), -1713183799);
+        assert_eq!(xor_si32(-1713183800, 2), -1713183798);
+        assert_eq!(xor_si32(2, -1713183800), -1713183798);
+        assert_eq!(xor_si32(-1713183800, 3), -1713183797);
+        assert_eq!(xor_si32(3, -1713183800), -1713183797);
+        assert_eq!(xor_si32(-1713183800, 4), -1713183796);
+        assert_eq!(xor_si32(4, -1713183800), -1713183796);
+        assert_eq!(xor_si32(-1252582164, 4), -1252582168);
+        assert_eq!(xor_si32(4, -1252582164), -1252582168);
+        assert_eq!(xor_si32(-1252582164, 0), -1252582164);
+        assert_eq!(xor_si32(0, -1252582164), -1252582164);
+        assert_eq!(xor_si32(-1252582164, 1), -1252582163);
+        assert_eq!(xor_si32(1, -1252582164), -1252582163);
+        assert_eq!(xor_si32(-1252582164, 2), -1252582162);
+        assert_eq!(xor_si32(2, -1252582164), -1252582162);
+        assert_eq!(xor_si32(-1252582164, 3), -1252582161);
+        assert_eq!(xor_si32(3, -1252582164), -1252582161);
+        assert_eq!(xor_si32(-1035405763, 2147483647), -1112077886);
+        assert_eq!(xor_si32(2147483647, -1035405763), -1112077886);
+        assert_eq!(xor_si32(-1035405763, 2147483646), -1112077885);
+        assert_eq!(xor_si32(2147483646, -1035405763), -1112077885);
+        assert_eq!(xor_si32(-1035405763, 4), -1035405767);
+        assert_eq!(xor_si32(4, -1035405763), -1035405767);
+        assert_eq!(xor_si32(-1035405763, 1), -1035405764);
+        assert_eq!(xor_si32(1, -1035405763), -1035405764);
+        assert_eq!(xor_si32(-1035405763, 0), -1035405763);
+        assert_eq!(xor_si32(0, -1035405763), -1035405763);
+        assert_eq!(xor_si32(-1035405763, 3), -1035405762);
+        assert_eq!(xor_si32(3, -1035405763), -1035405762);
+        assert_eq!(xor_si32(-1035405763, 2), -1035405761);
+        assert_eq!(xor_si32(2, -1035405763), -1035405761);
+        assert_eq!(xor_si32(-1252582164, 2147483646), -894901486);
+        assert_eq!(xor_si32(2147483646, -1252582164), -894901486);
+        assert_eq!(xor_si32(-1252582164, 2147483647), -894901485);
+        assert_eq!(xor_si32(2147483647, -1252582164), -894901485);
+        assert_eq!(xor_si32(-1713183800, 2147483646), -434299850);
+        assert_eq!(xor_si32(2147483646, -1713183800), -434299850);
+        assert_eq!(xor_si32(-1713183800, 2147483647), -434299849);
+        assert_eq!(xor_si32(2147483647, -1713183800), -434299849);
+        assert_eq!(xor_si32(-2147483648, 2147483646), -2);
+        assert_eq!(xor_si32(-2147483647, 2147483647), -2);
+        assert_eq!(xor_si32(2147483646, -2147483648), -2);
+        assert_eq!(xor_si32(2147483647, -2147483647), -2);
+        assert_eq!(xor_si32(-2147483648, 2147483647), -1);
+        assert_eq!(xor_si32(-2147483647, 2147483646), -1);
+        assert_eq!(xor_si32(2147483646, -2147483647), -1);
+        assert_eq!(xor_si32(2147483647, -2147483648), -1);
+        assert_eq!(xor_si32(-2147483648, -2147483648), 0);
+        assert_eq!(xor_si32(-2147483647, -2147483647), 0);
+        assert_eq!(xor_si32(-1713183800, -1713183800), 0);
+        assert_eq!(xor_si32(-1252582164, -1252582164), 0);
+        assert_eq!(xor_si32(-1035405763, -1035405763), 0);
+        assert_eq!(xor_si32(0, 0), 0);
+        assert_eq!(xor_si32(1, 1), 0);
+        assert_eq!(xor_si32(2, 2), 0);
+        assert_eq!(xor_si32(3, 3), 0);
+        assert_eq!(xor_si32(4, 4), 0);
+        assert_eq!(xor_si32(2147483646, 2147483646), 0);
+        assert_eq!(xor_si32(2147483647, 2147483647), 0);
+        assert_eq!(xor_si32(-2147483648, -2147483647), 1);
+        assert_eq!(xor_si32(-2147483647, -2147483648), 1);
+        assert_eq!(xor_si32(0, 1), 1);
+        assert_eq!(xor_si32(1, 0), 1);
+        assert_eq!(xor_si32(2, 3), 1);
+        assert_eq!(xor_si32(3, 2), 1);
+        assert_eq!(xor_si32(2147483646, 2147483647), 1);
+        assert_eq!(xor_si32(2147483647, 2147483646), 1);
+        assert_eq!(xor_si32(0, 2), 2);
+        assert_eq!(xor_si32(1, 3), 2);
+        assert_eq!(xor_si32(2, 0), 2);
+        assert_eq!(xor_si32(3, 1), 2);
+        assert_eq!(xor_si32(0, 3), 3);
+        assert_eq!(xor_si32(1, 2), 3);
+        assert_eq!(xor_si32(2, 1), 3);
+        assert_eq!(xor_si32(3, 0), 3);
+        assert_eq!(xor_si32(0, 4), 4);
+        assert_eq!(xor_si32(4, 0), 4);
+        assert_eq!(xor_si32(1, 4), 5);
+        assert_eq!(xor_si32(4, 1), 5);
+        assert_eq!(xor_si32(2, 4), 6);
+        assert_eq!(xor_si32(4, 2), 6);
+        assert_eq!(xor_si32(3, 4), 7);
+        assert_eq!(xor_si32(4, 3), 7);
+        assert_eq!(xor_si32(-2147483648, -1713183800), 434299848);
+        assert_eq!(xor_si32(-1713183800, -2147483648), 434299848);
+        assert_eq!(xor_si32(-2147483647, -1713183800), 434299849);
+        assert_eq!(xor_si32(-1713183800, -2147483647), 434299849);
+        assert_eq!(xor_si32(-1713183800, -1252582164), 750124836);
+        assert_eq!(xor_si32(-1252582164, -1713183800), 750124836);
+        assert_eq!(xor_si32(-2147483648, -1252582164), 894901484);
+        assert_eq!(xor_si32(-1252582164, -2147483648), 894901484);
+        assert_eq!(xor_si32(-2147483647, -1252582164), 894901485);
+        assert_eq!(xor_si32(-1252582164, -2147483647), 894901485);
+        assert_eq!(xor_si32(-2147483647, -1035405763), 1112077884);
+        assert_eq!(xor_si32(-1035405763, -2147483647), 1112077884);
+        assert_eq!(xor_si32(-2147483648, -1035405763), 1112077885);
+        assert_eq!(xor_si32(-1035405763, -2147483648), 1112077885);
+        assert_eq!(xor_si32(-1713183800, -1035405763), 1537873397);
+        assert_eq!(xor_si32(-1035405763, -1713183800), 1537873397);
+        assert_eq!(xor_si32(-1252582164, -1035405763), 1998580433);
+        assert_eq!(xor_si32(-1035405763, -1252582164), 1998580433);
+        assert_eq!(xor_si32(4, 2147483646), 2147483642);
+        assert_eq!(xor_si32(2147483646, 4), 2147483642);
+        assert_eq!(xor_si32(4, 2147483647), 2147483643);
+        assert_eq!(xor_si32(2147483647, 4), 2147483643);
+        assert_eq!(xor_si32(2, 2147483646), 2147483644);
+        assert_eq!(xor_si32(3, 2147483647), 2147483644);
+        assert_eq!(xor_si32(2147483646, 2), 2147483644);
+        assert_eq!(xor_si32(2147483647, 3), 2147483644);
+        assert_eq!(xor_si32(2, 2147483647), 2147483645);
+        assert_eq!(xor_si32(3, 2147483646), 2147483645);
+        assert_eq!(xor_si32(2147483646, 3), 2147483645);
+        assert_eq!(xor_si32(2147483647, 2), 2147483645);
+        assert_eq!(xor_si32(0, 2147483646), 2147483646);
+        assert_eq!(xor_si32(1, 2147483647), 2147483646);
+        assert_eq!(xor_si32(2147483646, 0), 2147483646);
+        assert_eq!(xor_si32(2147483647, 1), 2147483646);
+        assert_eq!(xor_si32(0, 2147483647), 2147483647);
+        assert_eq!(xor_si32(1, 2147483646), 2147483647);
+        assert_eq!(xor_si32(2147483646, 1), 2147483647);
+        assert_eq!(xor_si32(2147483647, 0), 2147483647);
+        assert_eq!(xor_si64(-9223372036854775808, 0), -9223372036854775808);
+        assert_eq!(xor_si64(-9223372036854775807, 1), -9223372036854775808);
+        assert_eq!(xor_si64(0, -9223372036854775808), -9223372036854775808);
+        assert_eq!(xor_si64(1, -9223372036854775807), -9223372036854775808);
+        assert_eq!(xor_si64(-9223372036854775808, 1), -9223372036854775807);
+        assert_eq!(xor_si64(-9223372036854775807, 0), -9223372036854775807);
+        assert_eq!(xor_si64(0, -9223372036854775807), -9223372036854775807);
+        assert_eq!(xor_si64(1, -9223372036854775808), -9223372036854775807);
+        assert_eq!(xor_si64(-9223372036854775808, 2), -9223372036854775806);
+        assert_eq!(xor_si64(-9223372036854775807, 3), -9223372036854775806);
+        assert_eq!(xor_si64(2, -9223372036854775808), -9223372036854775806);
+        assert_eq!(xor_si64(3, -9223372036854775807), -9223372036854775806);
+        assert_eq!(xor_si64(-9223372036854775808, 3), -9223372036854775805);
+        assert_eq!(xor_si64(-9223372036854775807, 2), -9223372036854775805);
+        assert_eq!(xor_si64(2, -9223372036854775807), -9223372036854775805);
+        assert_eq!(xor_si64(3, -9223372036854775808), -9223372036854775805);
+        assert_eq!(xor_si64(-9223372036854775808, 4), -9223372036854775804);
+        assert_eq!(xor_si64(4, -9223372036854775808), -9223372036854775804);
+        assert_eq!(xor_si64(-9223372036854775807, 4), -9223372036854775803);
+        assert_eq!(xor_si64(4, -9223372036854775807), -9223372036854775803);
+        assert_eq!(
+            xor_si64(-1328271339354574848, 9223372036854775806),
+            -7895100697500200962
+        );
+        assert_eq!(
+            xor_si64(9223372036854775806, -1328271339354574848),
+            -7895100697500200962
+        );
+        assert_eq!(
+            xor_si64(-1328271339354574848, 9223372036854775807),
+            -7895100697500200961
+        );
+        assert_eq!(
+            xor_si64(9223372036854775807, -1328271339354574848),
+            -7895100697500200961
+        );
+        assert_eq!(
+            xor_si64(-1741927215160008704, 9223372036854775806),
+            -7481444821694767106
+        );
+        assert_eq!(
+            xor_si64(9223372036854775806, -1741927215160008704),
+            -7481444821694767106
+        );
+        assert_eq!(
+            xor_si64(-1741927215160008704, 9223372036854775807),
+            -7481444821694767105
+        );
+        assert_eq!(
+            xor_si64(9223372036854775807, -1741927215160008704),
+            -7481444821694767105
+        );
+        assert_eq!(
+            xor_si64(-1328271339354574848, 5577148965131116544),
+            -6847992414814875648
+        );
+        assert_eq!(
+            xor_si64(5577148965131116544, -1328271339354574848),
+            -6847992414814875648
+        );
+        assert_eq!(
+            xor_si64(-1741927215160008704, 5577148965131116544),
+            -6145886261021343744
+        );
+        assert_eq!(
+            xor_si64(5577148965131116544, -1741927215160008704),
+            -6145886261021343744
+        );
+        assert_eq!(
+            xor_si64(-9223372036854775808, 5577148965131116544),
+            -3646223071723659264
+        );
+        assert_eq!(
+            xor_si64(5577148965131116544, -9223372036854775808),
+            -3646223071723659264
+        );
+        assert_eq!(
+            xor_si64(-9223372036854775807, 5577148965131116544),
+            -3646223071723659263
+        );
+        assert_eq!(
+            xor_si64(5577148965131116544, -9223372036854775807),
+            -3646223071723659263
+        );
+        assert_eq!(xor_si64(-1741927215160008704, 0), -1741927215160008704);
+        assert_eq!(xor_si64(0, -1741927215160008704), -1741927215160008704);
+        assert_eq!(xor_si64(-1741927215160008704, 1), -1741927215160008703);
+        assert_eq!(xor_si64(1, -1741927215160008704), -1741927215160008703);
+        assert_eq!(xor_si64(-1741927215160008704, 2), -1741927215160008702);
+        assert_eq!(xor_si64(2, -1741927215160008704), -1741927215160008702);
+        assert_eq!(xor_si64(-1741927215160008704, 3), -1741927215160008701);
+        assert_eq!(xor_si64(3, -1741927215160008704), -1741927215160008701);
+        assert_eq!(xor_si64(-1741927215160008704, 4), -1741927215160008700);
+        assert_eq!(xor_si64(4, -1741927215160008704), -1741927215160008700);
+        assert_eq!(xor_si64(-1328271339354574848, 0), -1328271339354574848);
+        assert_eq!(xor_si64(0, -1328271339354574848), -1328271339354574848);
+        assert_eq!(xor_si64(-1328271339354574848, 1), -1328271339354574847);
+        assert_eq!(xor_si64(1, -1328271339354574848), -1328271339354574847);
+        assert_eq!(xor_si64(-1328271339354574848, 2), -1328271339354574846);
+        assert_eq!(xor_si64(2, -1328271339354574848), -1328271339354574846);
+        assert_eq!(xor_si64(-1328271339354574848, 3), -1328271339354574845);
+        assert_eq!(xor_si64(3, -1328271339354574848), -1328271339354574845);
+        assert_eq!(xor_si64(-1328271339354574848, 4), -1328271339354574844);
+        assert_eq!(xor_si64(4, -1328271339354574848), -1328271339354574844);
+        assert_eq!(xor_si64(-9223372036854775808, 9223372036854775806), -2);
+        assert_eq!(xor_si64(-9223372036854775807, 9223372036854775807), -2);
+        assert_eq!(xor_si64(9223372036854775806, -9223372036854775808), -2);
+        assert_eq!(xor_si64(9223372036854775807, -9223372036854775807), -2);
+        assert_eq!(xor_si64(-9223372036854775808, 9223372036854775807), -1);
+        assert_eq!(xor_si64(-9223372036854775807, 9223372036854775806), -1);
+        assert_eq!(xor_si64(9223372036854775806, -9223372036854775807), -1);
+        assert_eq!(xor_si64(9223372036854775807, -9223372036854775808), -1);
+        assert_eq!(xor_si64(-9223372036854775808, -9223372036854775808), 0);
+        assert_eq!(xor_si64(-9223372036854775807, -9223372036854775807), 0);
+        assert_eq!(xor_si64(-1741927215160008704, -1741927215160008704), 0);
+        assert_eq!(xor_si64(-1328271339354574848, -1328271339354574848), 0);
+        assert_eq!(xor_si64(0, 0), 0);
+        assert_eq!(xor_si64(1, 1), 0);
+        assert_eq!(xor_si64(2, 2), 0);
+        assert_eq!(xor_si64(3, 3), 0);
+        assert_eq!(xor_si64(4, 4), 0);
+        assert_eq!(xor_si64(5577148965131116544, 5577148965131116544), 0);
+        assert_eq!(xor_si64(9223372036854775806, 9223372036854775806), 0);
+        assert_eq!(xor_si64(9223372036854775807, 9223372036854775807), 0);
+        assert_eq!(xor_si64(-9223372036854775808, -9223372036854775807), 1);
+        assert_eq!(xor_si64(-9223372036854775807, -9223372036854775808), 1);
+        assert_eq!(xor_si64(0, 1), 1);
+        assert_eq!(xor_si64(1, 0), 1);
+        assert_eq!(xor_si64(2, 3), 1);
+        assert_eq!(xor_si64(3, 2), 1);
+        assert_eq!(xor_si64(9223372036854775806, 9223372036854775807), 1);
+        assert_eq!(xor_si64(9223372036854775807, 9223372036854775806), 1);
+        assert_eq!(xor_si64(0, 2), 2);
+        assert_eq!(xor_si64(1, 3), 2);
+        assert_eq!(xor_si64(2, 0), 2);
+        assert_eq!(xor_si64(3, 1), 2);
+        assert_eq!(xor_si64(0, 3), 3);
+        assert_eq!(xor_si64(1, 2), 3);
+        assert_eq!(xor_si64(2, 1), 3);
+        assert_eq!(xor_si64(3, 0), 3);
+        assert_eq!(xor_si64(0, 4), 4);
+        assert_eq!(xor_si64(4, 0), 4);
+        assert_eq!(xor_si64(1, 4), 5);
+        assert_eq!(xor_si64(4, 1), 5);
+        assert_eq!(xor_si64(2, 4), 6);
+        assert_eq!(xor_si64(4, 2), 6);
+        assert_eq!(xor_si64(3, 4), 7);
+        assert_eq!(xor_si64(4, 3), 7);
+        assert_eq!(
+            xor_si64(-1741927215160008704, -1328271339354574848),
+            739265629478801408
+        );
+        assert_eq!(
+            xor_si64(-1328271339354574848, -1741927215160008704),
+            739265629478801408
+        );
+        assert_eq!(
+            xor_si64(5577148965131116544, 9223372036854775806),
+            3646223071723659262
+        );
+        assert_eq!(
+            xor_si64(9223372036854775806, 5577148965131116544),
+            3646223071723659262
+        );
+        assert_eq!(
+            xor_si64(5577148965131116544, 9223372036854775807),
+            3646223071723659263
+        );
+        assert_eq!(
+            xor_si64(9223372036854775807, 5577148965131116544),
+            3646223071723659263
+        );
+        assert_eq!(xor_si64(0, 5577148965131116544), 5577148965131116544);
+        assert_eq!(xor_si64(5577148965131116544, 0), 5577148965131116544);
+        assert_eq!(xor_si64(1, 5577148965131116544), 5577148965131116545);
+        assert_eq!(xor_si64(5577148965131116544, 1), 5577148965131116545);
+        assert_eq!(xor_si64(2, 5577148965131116544), 5577148965131116546);
+        assert_eq!(xor_si64(5577148965131116544, 2), 5577148965131116546);
+        assert_eq!(xor_si64(3, 5577148965131116544), 5577148965131116547);
+        assert_eq!(xor_si64(5577148965131116544, 3), 5577148965131116547);
+        assert_eq!(xor_si64(4, 5577148965131116544), 5577148965131116548);
+        assert_eq!(xor_si64(5577148965131116544, 4), 5577148965131116548);
+        assert_eq!(
+            xor_si64(-9223372036854775808, -1741927215160008704),
+            7481444821694767104
+        );
+        assert_eq!(
+            xor_si64(-1741927215160008704, -9223372036854775808),
+            7481444821694767104
+        );
+        assert_eq!(
+            xor_si64(-9223372036854775807, -1741927215160008704),
+            7481444821694767105
+        );
+        assert_eq!(
+            xor_si64(-1741927215160008704, -9223372036854775807),
+            7481444821694767105
+        );
+        assert_eq!(
+            xor_si64(-9223372036854775808, -1328271339354574848),
+            7895100697500200960
+        );
+        assert_eq!(
+            xor_si64(-1328271339354574848, -9223372036854775808),
+            7895100697500200960
+        );
+        assert_eq!(
+            xor_si64(-9223372036854775807, -1328271339354574848),
+            7895100697500200961
+        );
+        assert_eq!(
+            xor_si64(-1328271339354574848, -9223372036854775807),
+            7895100697500200961
+        );
+        assert_eq!(xor_si64(4, 9223372036854775806), 9223372036854775802);
+        assert_eq!(xor_si64(9223372036854775806, 4), 9223372036854775802);
+        assert_eq!(xor_si64(4, 9223372036854775807), 9223372036854775803);
+        assert_eq!(xor_si64(9223372036854775807, 4), 9223372036854775803);
+        assert_eq!(xor_si64(2, 9223372036854775806), 9223372036854775804);
+        assert_eq!(xor_si64(3, 9223372036854775807), 9223372036854775804);
+        assert_eq!(xor_si64(9223372036854775806, 2), 9223372036854775804);
+        assert_eq!(xor_si64(9223372036854775807, 3), 9223372036854775804);
+        assert_eq!(xor_si64(2, 9223372036854775807), 9223372036854775805);
+        assert_eq!(xor_si64(3, 9223372036854775806), 9223372036854775805);
+        assert_eq!(xor_si64(9223372036854775806, 3), 9223372036854775805);
+        assert_eq!(xor_si64(9223372036854775807, 2), 9223372036854775805);
+        assert_eq!(xor_si64(0, 9223372036854775806), 9223372036854775806);
+        assert_eq!(xor_si64(1, 9223372036854775807), 9223372036854775806);
+        assert_eq!(xor_si64(9223372036854775806, 0), 9223372036854775806);
+        assert_eq!(xor_si64(9223372036854775807, 1), 9223372036854775806);
+        assert_eq!(xor_si64(0, 9223372036854775807), 9223372036854775807);
+        assert_eq!(xor_si64(1, 9223372036854775806), 9223372036854775807);
+        assert_eq!(xor_si64(9223372036854775806, 1), 9223372036854775807);
+        assert_eq!(xor_si64(9223372036854775807, 0), 9223372036854775807);
+        assert_eq!(xor_si8(-128, 0), -128);
+        assert_eq!(xor_si8(-127, 1), -128);
+        assert_eq!(xor_si8(0, -128), -128);
+        assert_eq!(xor_si8(1, -127), -128);
+        assert_eq!(xor_si8(-128, 1), -127);
+        assert_eq!(xor_si8(-127, 0), -127);
+        assert_eq!(xor_si8(0, -127), -127);
+        assert_eq!(xor_si8(1, -128), -127);
+        assert_eq!(xor_si8(-128, 2), -126);
+        assert_eq!(xor_si8(-127, 3), -126);
+        assert_eq!(xor_si8(2, -128), -126);
+        assert_eq!(xor_si8(3, -127), -126);
+        assert_eq!(xor_si8(-128, 3), -125);
+        assert_eq!(xor_si8(-127, 2), -125);
+        assert_eq!(xor_si8(2, -127), -125);
+        assert_eq!(xor_si8(3, -128), -125);
+        assert_eq!(xor_si8(-128, 4), -124);
+        assert_eq!(xor_si8(4, -128), -124);
+        assert_eq!(xor_si8(-127, 4), -123);
+        assert_eq!(xor_si8(4, -127), -123);
+        assert_eq!(xor_si8(-128, 16), -112);
+        assert_eq!(xor_si8(16, -128), -112);
+        assert_eq!(xor_si8(-127, 16), -111);
+        assert_eq!(xor_si8(16, -127), -111);
+        assert_eq!(xor_si8(-128, 126), -2);
+        assert_eq!(xor_si8(-127, 127), -2);
+        assert_eq!(xor_si8(126, -128), -2);
+        assert_eq!(xor_si8(127, -127), -2);
+        assert_eq!(xor_si8(-128, 127), -1);
+        assert_eq!(xor_si8(-127, 126), -1);
+        assert_eq!(xor_si8(126, -127), -1);
+        assert_eq!(xor_si8(127, -128), -1);
+        assert_eq!(xor_si8(-128, -128), 0);
+        assert_eq!(xor_si8(-127, -127), 0);
+        assert_eq!(xor_si8(0, 0), 0);
+        assert_eq!(xor_si8(1, 1), 0);
+        assert_eq!(xor_si8(2, 2), 0);
+        assert_eq!(xor_si8(3, 3), 0);
+        assert_eq!(xor_si8(4, 4), 0);
+        assert_eq!(xor_si8(16, 16), 0);
+        assert_eq!(xor_si8(126, 126), 0);
+        assert_eq!(xor_si8(127, 127), 0);
+        assert_eq!(xor_si8(-128, -127), 1);
+        assert_eq!(xor_si8(-127, -128), 1);
+        assert_eq!(xor_si8(0, 1), 1);
+        assert_eq!(xor_si8(1, 0), 1);
+        assert_eq!(xor_si8(2, 3), 1);
+        assert_eq!(xor_si8(3, 2), 1);
+        assert_eq!(xor_si8(126, 127), 1);
+        assert_eq!(xor_si8(127, 126), 1);
+        assert_eq!(xor_si8(0, 2), 2);
+        assert_eq!(xor_si8(1, 3), 2);
+        assert_eq!(xor_si8(2, 0), 2);
+        assert_eq!(xor_si8(3, 1), 2);
+        assert_eq!(xor_si8(0, 3), 3);
+        assert_eq!(xor_si8(1, 2), 3);
+        assert_eq!(xor_si8(2, 1), 3);
+        assert_eq!(xor_si8(3, 0), 3);
+        assert_eq!(xor_si8(0, 4), 4);
+        assert_eq!(xor_si8(4, 0), 4);
+        assert_eq!(xor_si8(1, 4), 5);
+        assert_eq!(xor_si8(4, 1), 5);
+        assert_eq!(xor_si8(2, 4), 6);
+        assert_eq!(xor_si8(4, 2), 6);
+        assert_eq!(xor_si8(3, 4), 7);
+        assert_eq!(xor_si8(4, 3), 7);
+        assert_eq!(xor_si8(0, 16), 16);
+        assert_eq!(xor_si8(16, 0), 16);
+        assert_eq!(xor_si8(1, 16), 17);
+        assert_eq!(xor_si8(16, 1), 17);
+        assert_eq!(xor_si8(2, 16), 18);
+        assert_eq!(xor_si8(16, 2), 18);
+        assert_eq!(xor_si8(3, 16), 19);
+        assert_eq!(xor_si8(16, 3), 19);
+        assert_eq!(xor_si8(4, 16), 20);
+        assert_eq!(xor_si8(16, 4), 20);
+        assert_eq!(xor_si8(16, 126), 110);
+        assert_eq!(xor_si8(126, 16), 110);
+        assert_eq!(xor_si8(16, 127), 111);
+        assert_eq!(xor_si8(127, 16), 111);
+        assert_eq!(xor_si8(4, 126), 122);
+        assert_eq!(xor_si8(126, 4), 122);
+        assert_eq!(xor_si8(4, 127), 123);
+        assert_eq!(xor_si8(127, 4), 123);
+        assert_eq!(xor_si8(2, 126), 124);
+        assert_eq!(xor_si8(3, 127), 124);
+        assert_eq!(xor_si8(126, 2), 124);
+        assert_eq!(xor_si8(127, 3), 124);
+        assert_eq!(xor_si8(2, 127), 125);
+        assert_eq!(xor_si8(3, 126), 125);
+        assert_eq!(xor_si8(126, 3), 125);
+        assert_eq!(xor_si8(127, 2), 125);
+        assert_eq!(xor_si8(0, 126), 126);
+        assert_eq!(xor_si8(1, 127), 126);
+        assert_eq!(xor_si8(126, 0), 126);
+        assert_eq!(xor_si8(127, 1), 126);
+        assert_eq!(xor_si8(0, 127), 127);
+        assert_eq!(xor_si8(1, 126), 127);
+        assert_eq!(xor_si8(126, 1), 127);
+        assert_eq!(xor_si8(127, 0), 127);
+        assert_eq!(xor_ui16(0, 0), 0);
+        assert_eq!(xor_ui16(1, 1), 0);
+        assert_eq!(xor_ui16(2, 2), 0);
+        assert_eq!(xor_ui16(3, 3), 0);
+        assert_eq!(xor_ui16(4, 4), 0);
+        assert_eq!(xor_ui16(1717, 1717), 0);
+        assert_eq!(xor_ui16(17988, 17988), 0);
+        assert_eq!(xor_ui16(65096, 65096), 0);
+        assert_eq!(xor_ui16(65534, 65534), 0);
+        assert_eq!(xor_ui16(65535, 65535), 0);
+        assert_eq!(xor_ui16(0, 1), 1);
+        assert_eq!(xor_ui16(1, 0), 1);
+        assert_eq!(xor_ui16(2, 3), 1);
+        assert_eq!(xor_ui16(3, 2), 1);
+        assert_eq!(xor_ui16(65534, 65535), 1);
+        assert_eq!(xor_ui16(65535, 65534), 1);
+        assert_eq!(xor_ui16(0, 2), 2);
+        assert_eq!(xor_ui16(1, 3), 2);
+        assert_eq!(xor_ui16(2, 0), 2);
+        assert_eq!(xor_ui16(3, 1), 2);
+        assert_eq!(xor_ui16(0, 3), 3);
+        assert_eq!(xor_ui16(1, 2), 3);
+        assert_eq!(xor_ui16(2, 1), 3);
+        assert_eq!(xor_ui16(3, 0), 3);
+        assert_eq!(xor_ui16(0, 4), 4);
+        assert_eq!(xor_ui16(4, 0), 4);
+        assert_eq!(xor_ui16(1, 4), 5);
+        assert_eq!(xor_ui16(4, 1), 5);
+        assert_eq!(xor_ui16(2, 4), 6);
+        assert_eq!(xor_ui16(4, 2), 6);
+        assert_eq!(xor_ui16(3, 4), 7);
+        assert_eq!(xor_ui16(4, 3), 7);
+        assert_eq!(xor_ui16(65096, 65534), 438);
+        assert_eq!(xor_ui16(65534, 65096), 438);
+        assert_eq!(xor_ui16(65096, 65535), 439);
+        assert_eq!(xor_ui16(65535, 65096), 439);
+        assert_eq!(xor_ui16(4, 1717), 1713);
+        assert_eq!(xor_ui16(1717, 4), 1713);
+        assert_eq!(xor_ui16(1, 1717), 1716);
+        assert_eq!(xor_ui16(1717, 1), 1716);
+        assert_eq!(xor_ui16(0, 1717), 1717);
+        assert_eq!(xor_ui16(1717, 0), 1717);
+        assert_eq!(xor_ui16(3, 1717), 1718);
+        assert_eq!(xor_ui16(1717, 3), 1718);
+        assert_eq!(xor_ui16(2, 1717), 1719);
+        assert_eq!(xor_ui16(1717, 2), 1719);
+        assert_eq!(xor_ui16(1717, 17988), 16625);
+        assert_eq!(xor_ui16(17988, 1717), 16625);
+        assert_eq!(xor_ui16(4, 17988), 17984);
+        assert_eq!(xor_ui16(17988, 4), 17984);
+        assert_eq!(xor_ui16(0, 17988), 17988);
+        assert_eq!(xor_ui16(17988, 0), 17988);
+        assert_eq!(xor_ui16(1, 17988), 17989);
+        assert_eq!(xor_ui16(17988, 1), 17989);
+        assert_eq!(xor_ui16(2, 17988), 17990);
+        assert_eq!(xor_ui16(17988, 2), 17990);
+        assert_eq!(xor_ui16(3, 17988), 17991);
+        assert_eq!(xor_ui16(17988, 3), 17991);
+        assert_eq!(xor_ui16(17988, 65096), 47116);
+        assert_eq!(xor_ui16(65096, 17988), 47116);
+        assert_eq!(xor_ui16(17988, 65534), 47546);
+        assert_eq!(xor_ui16(65534, 17988), 47546);
+        assert_eq!(xor_ui16(17988, 65535), 47547);
+        assert_eq!(xor_ui16(65535, 17988), 47547);
+        assert_eq!(xor_ui16(1717, 65096), 63741);
+        assert_eq!(xor_ui16(65096, 1717), 63741);
+        assert_eq!(xor_ui16(1717, 65535), 63818);
+        assert_eq!(xor_ui16(65535, 1717), 63818);
+        assert_eq!(xor_ui16(1717, 65534), 63819);
+        assert_eq!(xor_ui16(65534, 1717), 63819);
+        assert_eq!(xor_ui16(0, 65096), 65096);
+        assert_eq!(xor_ui16(65096, 0), 65096);
+        assert_eq!(xor_ui16(1, 65096), 65097);
+        assert_eq!(xor_ui16(65096, 1), 65097);
+        assert_eq!(xor_ui16(2, 65096), 65098);
+        assert_eq!(xor_ui16(65096, 2), 65098);
+        assert_eq!(xor_ui16(3, 65096), 65099);
+        assert_eq!(xor_ui16(65096, 3), 65099);
+        assert_eq!(xor_ui16(4, 65096), 65100);
+        assert_eq!(xor_ui16(65096, 4), 65100);
+        assert_eq!(xor_ui16(4, 65534), 65530);
+        assert_eq!(xor_ui16(65534, 4), 65530);
+        assert_eq!(xor_ui16(4, 65535), 65531);
+        assert_eq!(xor_ui16(65535, 4), 65531);
+        assert_eq!(xor_ui16(2, 65534), 65532);
+        assert_eq!(xor_ui16(3, 65535), 65532);
+        assert_eq!(xor_ui16(65534, 2), 65532);
+        assert_eq!(xor_ui16(65535, 3), 65532);
+        assert_eq!(xor_ui16(2, 65535), 65533);
+        assert_eq!(xor_ui16(3, 65534), 65533);
+        assert_eq!(xor_ui16(65534, 3), 65533);
+        assert_eq!(xor_ui16(65535, 2), 65533);
+        assert_eq!(xor_ui16(0, 65534), 65534);
+        assert_eq!(xor_ui16(1, 65535), 65534);
+        assert_eq!(xor_ui16(65534, 0), 65534);
+        assert_eq!(xor_ui16(65535, 1), 65534);
+        assert_eq!(xor_ui16(0, 65535), 65535);
+        assert_eq!(xor_ui16(1, 65534), 65535);
+        assert_eq!(xor_ui16(65534, 1), 65535);
+        assert_eq!(xor_ui16(65535, 0), 65535);
+        assert_eq!(xor_ui32(0, 0), 0);
+        assert_eq!(xor_ui32(1, 1), 0);
+        assert_eq!(xor_ui32(2, 2), 0);
+        assert_eq!(xor_ui32(3, 3), 0);
+        assert_eq!(xor_ui32(4, 4), 0);
+        assert_eq!(xor_ui32(2119154652, 2119154652), 0);
+        assert_eq!(xor_ui32(3002788344, 3002788344), 0);
+        assert_eq!(xor_ui32(3482297128, 3482297128), 0);
+        assert_eq!(xor_ui32(4294967294, 4294967294), 0);
+        assert_eq!(xor_ui32(4294967295, 4294967295), 0);
+        assert_eq!(xor_ui32(0, 1), 1);
+        assert_eq!(xor_ui32(1, 0), 1);
+        assert_eq!(xor_ui32(2, 3), 1);
+        assert_eq!(xor_ui32(3, 2), 1);
+        assert_eq!(xor_ui32(4294967294, 4294967295), 1);
+        assert_eq!(xor_ui32(4294967295, 4294967294), 1);
+        assert_eq!(xor_ui32(0, 2), 2);
+        assert_eq!(xor_ui32(1, 3), 2);
+        assert_eq!(xor_ui32(2, 0), 2);
+        assert_eq!(xor_ui32(3, 1), 2);
+        assert_eq!(xor_ui32(0, 3), 3);
+        assert_eq!(xor_ui32(1, 2), 3);
+        assert_eq!(xor_ui32(2, 1), 3);
+        assert_eq!(xor_ui32(3, 0), 3);
+        assert_eq!(xor_ui32(0, 4), 4);
+        assert_eq!(xor_ui32(4, 0), 4);
+        assert_eq!(xor_ui32(1, 4), 5);
+        assert_eq!(xor_ui32(4, 1), 5);
+        assert_eq!(xor_ui32(2, 4), 6);
+        assert_eq!(xor_ui32(4, 2), 6);
+        assert_eq!(xor_ui32(3, 4), 7);
+        assert_eq!(xor_ui32(4, 3), 7);
+        assert_eq!(xor_ui32(3482297128, 4294967294), 812670166);
+        assert_eq!(xor_ui32(4294967294, 3482297128), 812670166);
+        assert_eq!(xor_ui32(3482297128, 4294967295), 812670167);
+        assert_eq!(xor_ui32(4294967295, 3482297128), 812670167);
+        assert_eq!(xor_ui32(3002788344, 4294967294), 1292178950);
+        assert_eq!(xor_ui32(4294967294, 3002788344), 1292178950);
+        assert_eq!(xor_ui32(3002788344, 4294967295), 1292178951);
+        assert_eq!(xor_ui32(4294967295, 3002788344), 1292178951);
+        assert_eq!(xor_ui32(3002788344, 3482297128), 2104838864);
+        assert_eq!(xor_ui32(3482297128, 3002788344), 2104838864);
+        assert_eq!(xor_ui32(4, 2119154652), 2119154648);
+        assert_eq!(xor_ui32(2119154652, 4), 2119154648);
+        assert_eq!(xor_ui32(0, 2119154652), 2119154652);
+        assert_eq!(xor_ui32(2119154652, 0), 2119154652);
+        assert_eq!(xor_ui32(1, 2119154652), 2119154653);
+        assert_eq!(xor_ui32(2119154652, 1), 2119154653);
+        assert_eq!(xor_ui32(2, 2119154652), 2119154654);
+        assert_eq!(xor_ui32(2119154652, 2), 2119154654);
+        assert_eq!(xor_ui32(3, 2119154652), 2119154655);
+        assert_eq!(xor_ui32(2119154652, 3), 2119154655);
+        assert_eq!(xor_ui32(2119154652, 4294967294), 2175812642);
+        assert_eq!(xor_ui32(4294967294, 2119154652), 2175812642);
+        assert_eq!(xor_ui32(2119154652, 4294967295), 2175812643);
+        assert_eq!(xor_ui32(4294967295, 2119154652), 2175812643);
+        assert_eq!(xor_ui32(2119154652, 3482297128), 2982156532);
+        assert_eq!(xor_ui32(3482297128, 2119154652), 2982156532);
+        assert_eq!(xor_ui32(0, 3002788344), 3002788344);
+        assert_eq!(xor_ui32(3002788344, 0), 3002788344);
+        assert_eq!(xor_ui32(1, 3002788344), 3002788345);
+        assert_eq!(xor_ui32(3002788344, 1), 3002788345);
+        assert_eq!(xor_ui32(2, 3002788344), 3002788346);
+        assert_eq!(xor_ui32(3002788344, 2), 3002788346);
+        assert_eq!(xor_ui32(3, 3002788344), 3002788347);
+        assert_eq!(xor_ui32(3002788344, 3), 3002788347);
+        assert_eq!(xor_ui32(4, 3002788344), 3002788348);
+        assert_eq!(xor_ui32(3002788344, 4), 3002788348);
+        assert_eq!(xor_ui32(2119154652, 3002788344), 3434435108);
+        assert_eq!(xor_ui32(3002788344, 2119154652), 3434435108);
+        assert_eq!(xor_ui32(0, 3482297128), 3482297128);
+        assert_eq!(xor_ui32(3482297128, 0), 3482297128);
+        assert_eq!(xor_ui32(1, 3482297128), 3482297129);
+        assert_eq!(xor_ui32(3482297128, 1), 3482297129);
+        assert_eq!(xor_ui32(2, 3482297128), 3482297130);
+        assert_eq!(xor_ui32(3482297128, 2), 3482297130);
+        assert_eq!(xor_ui32(3, 3482297128), 3482297131);
+        assert_eq!(xor_ui32(3482297128, 3), 3482297131);
+        assert_eq!(xor_ui32(4, 3482297128), 3482297132);
+        assert_eq!(xor_ui32(3482297128, 4), 3482297132);
+        assert_eq!(xor_ui32(4, 4294967294), 4294967290);
+        assert_eq!(xor_ui32(4294967294, 4), 4294967290);
+        assert_eq!(xor_ui32(4, 4294967295), 4294967291);
+        assert_eq!(xor_ui32(4294967295, 4), 4294967291);
+        assert_eq!(xor_ui32(2, 4294967294), 4294967292);
+        assert_eq!(xor_ui32(3, 4294967295), 4294967292);
+        assert_eq!(xor_ui32(4294967294, 2), 4294967292);
+        assert_eq!(xor_ui32(4294967295, 3), 4294967292);
+        assert_eq!(xor_ui32(2, 4294967295), 4294967293);
+        assert_eq!(xor_ui32(3, 4294967294), 4294967293);
+        assert_eq!(xor_ui32(4294967294, 3), 4294967293);
+        assert_eq!(xor_ui32(4294967295, 2), 4294967293);
+        assert_eq!(xor_ui32(0, 4294967294), 4294967294);
+        assert_eq!(xor_ui32(1, 4294967295), 4294967294);
+        assert_eq!(xor_ui32(4294967294, 0), 4294967294);
+        assert_eq!(xor_ui32(4294967295, 1), 4294967294);
+        assert_eq!(xor_ui32(0, 4294967295), 4294967295);
+        assert_eq!(xor_ui32(1, 4294967294), 4294967295);
+        assert_eq!(xor_ui32(4294967294, 1), 4294967295);
+        assert_eq!(xor_ui32(4294967295, 0), 4294967295);
+        assert_eq!(xor_ui64(0, 0), 0);
+        assert_eq!(xor_ui64(1, 1), 0);
+        assert_eq!(xor_ui64(2, 2), 0);
+        assert_eq!(xor_ui64(3, 3), 0);
+        assert_eq!(xor_ui64(4, 4), 0);
+        assert_eq!(xor_ui64(191084152064409600, 191084152064409600), 0);
+        assert_eq!(xor_ui64(11015955194427482112, 11015955194427482112), 0);
+        assert_eq!(xor_ui64(16990600415051759616, 16990600415051759616), 0);
+        assert_eq!(xor_ui64(18446744073709551614, 18446744073709551614), 0);
+        assert_eq!(xor_ui64(18446744073709551615, 18446744073709551615), 0);
+        assert_eq!(xor_ui64(0, 1), 1);
+        assert_eq!(xor_ui64(1, 0), 1);
+        assert_eq!(xor_ui64(2, 3), 1);
+        assert_eq!(xor_ui64(3, 2), 1);
+        assert_eq!(xor_ui64(18446744073709551614, 18446744073709551615), 1);
+        assert_eq!(xor_ui64(18446744073709551615, 18446744073709551614), 1);
+        assert_eq!(xor_ui64(0, 2), 2);
+        assert_eq!(xor_ui64(1, 3), 2);
+        assert_eq!(xor_ui64(2, 0), 2);
+        assert_eq!(xor_ui64(3, 1), 2);
+        assert_eq!(xor_ui64(0, 3), 3);
+        assert_eq!(xor_ui64(1, 2), 3);
+        assert_eq!(xor_ui64(2, 1), 3);
+        assert_eq!(xor_ui64(3, 0), 3);
+        assert_eq!(xor_ui64(0, 4), 4);
+        assert_eq!(xor_ui64(4, 0), 4);
+        assert_eq!(xor_ui64(1, 4), 5);
+        assert_eq!(xor_ui64(4, 1), 5);
+        assert_eq!(xor_ui64(2, 4), 6);
+        assert_eq!(xor_ui64(4, 2), 6);
+        assert_eq!(xor_ui64(3, 4), 7);
+        assert_eq!(xor_ui64(4, 3), 7);
+        assert_eq!(xor_ui64(0, 191084152064409600), 191084152064409600);
+        assert_eq!(xor_ui64(191084152064409600, 0), 191084152064409600);
+        assert_eq!(xor_ui64(1, 191084152064409600), 191084152064409601);
+        assert_eq!(xor_ui64(191084152064409600, 1), 191084152064409601);
+        assert_eq!(xor_ui64(2, 191084152064409600), 191084152064409602);
+        assert_eq!(xor_ui64(191084152064409600, 2), 191084152064409602);
+        assert_eq!(xor_ui64(3, 191084152064409600), 191084152064409603);
+        assert_eq!(xor_ui64(191084152064409600, 3), 191084152064409603);
+        assert_eq!(xor_ui64(4, 191084152064409600), 191084152064409604);
+        assert_eq!(xor_ui64(191084152064409600, 4), 191084152064409604);
+        assert_eq!(
+            xor_ui64(16990600415051759616, 18446744073709551614),
+            1456143658657791998
+        );
+        assert_eq!(
+            xor_ui64(18446744073709551614, 16990600415051759616),
+            1456143658657791998
+        );
+        assert_eq!(
+            xor_ui64(16990600415051759616, 18446744073709551615),
+            1456143658657791999
+        );
+        assert_eq!(
+            xor_ui64(18446744073709551615, 16990600415051759616),
+            1456143658657791999
+        );
+        assert_eq!(
+            xor_ui64(11015955194427482112, 18446744073709551614),
+            7430788879282069502
+        );
+        assert_eq!(
+            xor_ui64(18446744073709551614, 11015955194427482112),
+            7430788879282069502
+        );
+        assert_eq!(
+            xor_ui64(11015955194427482112, 18446744073709551615),
+            7430788879282069503
+        );
+        assert_eq!(
+            xor_ui64(18446744073709551615, 11015955194427482112),
+            7430788879282069503
+        );
+        assert_eq!(
+            xor_ui64(11015955194427482112, 16990600415051759616),
+            8298504554647642112
+        );
+        assert_eq!(
+            xor_ui64(16990600415051759616, 11015955194427482112),
+            8298504554647642112
+        );
+        assert_eq!(xor_ui64(0, 11015955194427482112), 11015955194427482112);
+        assert_eq!(xor_ui64(11015955194427482112, 0), 11015955194427482112);
+        assert_eq!(xor_ui64(1, 11015955194427482112), 11015955194427482113);
+        assert_eq!(xor_ui64(11015955194427482112, 1), 11015955194427482113);
+        assert_eq!(xor_ui64(2, 11015955194427482112), 11015955194427482114);
+        assert_eq!(xor_ui64(11015955194427482112, 2), 11015955194427482114);
+        assert_eq!(xor_ui64(3, 11015955194427482112), 11015955194427482115);
+        assert_eq!(xor_ui64(11015955194427482112, 3), 11015955194427482115);
+        assert_eq!(xor_ui64(4, 11015955194427482112), 11015955194427482116);
+        assert_eq!(xor_ui64(11015955194427482112, 4), 11015955194427482116);
+        assert_eq!(
+            xor_ui64(191084152064409600, 11015955194427482112),
+            11116668269601857536
+        );
+        assert_eq!(
+            xor_ui64(11015955194427482112, 191084152064409600),
+            11116668269601857536
+        );
+        assert_eq!(
+            xor_ui64(191084152064409600, 16990600415051759616),
+            16819927597248036864
+        );
+        assert_eq!(
+            xor_ui64(16990600415051759616, 191084152064409600),
+            16819927597248036864
+        );
+        assert_eq!(xor_ui64(0, 16990600415051759616), 16990600415051759616);
+        assert_eq!(xor_ui64(16990600415051759616, 0), 16990600415051759616);
+        assert_eq!(xor_ui64(1, 16990600415051759616), 16990600415051759617);
+        assert_eq!(xor_ui64(16990600415051759616, 1), 16990600415051759617);
+        assert_eq!(xor_ui64(2, 16990600415051759616), 16990600415051759618);
+        assert_eq!(xor_ui64(16990600415051759616, 2), 16990600415051759618);
+        assert_eq!(xor_ui64(3, 16990600415051759616), 16990600415051759619);
+        assert_eq!(xor_ui64(16990600415051759616, 3), 16990600415051759619);
+        assert_eq!(xor_ui64(4, 16990600415051759616), 16990600415051759620);
+        assert_eq!(xor_ui64(16990600415051759616, 4), 16990600415051759620);
+        assert_eq!(
+            xor_ui64(191084152064409600, 18446744073709551614),
+            18255659921645142014
+        );
+        assert_eq!(
+            xor_ui64(18446744073709551614, 191084152064409600),
+            18255659921645142014
+        );
+        assert_eq!(
+            xor_ui64(191084152064409600, 18446744073709551615),
+            18255659921645142015
+        );
+        assert_eq!(
+            xor_ui64(18446744073709551615, 191084152064409600),
+            18255659921645142015
+        );
+        assert_eq!(xor_ui64(4, 18446744073709551614), 18446744073709551610);
+        assert_eq!(xor_ui64(18446744073709551614, 4), 18446744073709551610);
+        assert_eq!(xor_ui64(4, 18446744073709551615), 18446744073709551611);
+        assert_eq!(xor_ui64(18446744073709551615, 4), 18446744073709551611);
+        assert_eq!(xor_ui64(2, 18446744073709551614), 18446744073709551612);
+        assert_eq!(xor_ui64(3, 18446744073709551615), 18446744073709551612);
+        assert_eq!(xor_ui64(18446744073709551614, 2), 18446744073709551612);
+        assert_eq!(xor_ui64(18446744073709551615, 3), 18446744073709551612);
+        assert_eq!(xor_ui64(2, 18446744073709551615), 18446744073709551613);
+        assert_eq!(xor_ui64(3, 18446744073709551614), 18446744073709551613);
+        assert_eq!(xor_ui64(18446744073709551614, 3), 18446744073709551613);
+        assert_eq!(xor_ui64(18446744073709551615, 2), 18446744073709551613);
+        assert_eq!(xor_ui64(0, 18446744073709551614), 18446744073709551614);
+        assert_eq!(xor_ui64(1, 18446744073709551615), 18446744073709551614);
+        assert_eq!(xor_ui64(18446744073709551614, 0), 18446744073709551614);
+        assert_eq!(xor_ui64(18446744073709551615, 1), 18446744073709551614);
+        assert_eq!(xor_ui64(0, 18446744073709551615), 18446744073709551615);
+        assert_eq!(xor_ui64(1, 18446744073709551614), 18446744073709551615);
+        assert_eq!(xor_ui64(18446744073709551614, 1), 18446744073709551615);
+        assert_eq!(xor_ui64(18446744073709551615, 0), 18446744073709551615);
+        assert_eq!(xor_ui8(0, 0), 0);
+        assert_eq!(xor_ui8(1, 1), 0);
+        assert_eq!(xor_ui8(2, 2), 0);
+        assert_eq!(xor_ui8(3, 3), 0);
+        assert_eq!(xor_ui8(4, 4), 0);
+        assert_eq!(xor_ui8(72, 72), 0);
+        assert_eq!(xor_ui8(100, 100), 0);
+        assert_eq!(xor_ui8(162, 162), 0);
+        assert_eq!(xor_ui8(254, 254), 0);
+        assert_eq!(xor_ui8(255, 255), 0);
+        assert_eq!(xor_ui8(0, 1), 1);
+        assert_eq!(xor_ui8(1, 0), 1);
+        assert_eq!(xor_ui8(2, 3), 1);
+        assert_eq!(xor_ui8(3, 2), 1);
+        assert_eq!(xor_ui8(254, 255), 1);
+        assert_eq!(xor_ui8(255, 254), 1);
+        assert_eq!(xor_ui8(0, 2), 2);
+        assert_eq!(xor_ui8(1, 3), 2);
+        assert_eq!(xor_ui8(2, 0), 2);
+        assert_eq!(xor_ui8(3, 1), 2);
+        assert_eq!(xor_ui8(0, 3), 3);
+        assert_eq!(xor_ui8(1, 2), 3);
+        assert_eq!(xor_ui8(2, 1), 3);
+        assert_eq!(xor_ui8(3, 0), 3);
+        assert_eq!(xor_ui8(0, 4), 4);
+        assert_eq!(xor_ui8(4, 0), 4);
+        assert_eq!(xor_ui8(1, 4), 5);
+        assert_eq!(xor_ui8(4, 1), 5);
+        assert_eq!(xor_ui8(2, 4), 6);
+        assert_eq!(xor_ui8(4, 2), 6);
+        assert_eq!(xor_ui8(3, 4), 7);
+        assert_eq!(xor_ui8(4, 3), 7);
+        assert_eq!(xor_ui8(72, 100), 44);
+        assert_eq!(xor_ui8(100, 72), 44);
+        assert_eq!(xor_ui8(0, 72), 72);
+        assert_eq!(xor_ui8(72, 0), 72);
+        assert_eq!(xor_ui8(1, 72), 73);
+        assert_eq!(xor_ui8(72, 1), 73);
+        assert_eq!(xor_ui8(2, 72), 74);
+        assert_eq!(xor_ui8(72, 2), 74);
+        assert_eq!(xor_ui8(3, 72), 75);
+        assert_eq!(xor_ui8(72, 3), 75);
+        assert_eq!(xor_ui8(4, 72), 76);
+        assert_eq!(xor_ui8(72, 4), 76);
+        assert_eq!(xor_ui8(162, 254), 92);
+        assert_eq!(xor_ui8(254, 162), 92);
+        assert_eq!(xor_ui8(162, 255), 93);
+        assert_eq!(xor_ui8(255, 162), 93);
+        assert_eq!(xor_ui8(4, 100), 96);
+        assert_eq!(xor_ui8(100, 4), 96);
+        assert_eq!(xor_ui8(0, 100), 100);
+        assert_eq!(xor_ui8(100, 0), 100);
+        assert_eq!(xor_ui8(1, 100), 101);
+        assert_eq!(xor_ui8(100, 1), 101);
+        assert_eq!(xor_ui8(2, 100), 102);
+        assert_eq!(xor_ui8(100, 2), 102);
+        assert_eq!(xor_ui8(3, 100), 103);
+        assert_eq!(xor_ui8(100, 3), 103);
+        assert_eq!(xor_ui8(100, 254), 154);
+        assert_eq!(xor_ui8(254, 100), 154);
+        assert_eq!(xor_ui8(100, 255), 155);
+        assert_eq!(xor_ui8(255, 100), 155);
+        assert_eq!(xor_ui8(2, 162), 160);
+        assert_eq!(xor_ui8(162, 2), 160);
+        assert_eq!(xor_ui8(3, 162), 161);
+        assert_eq!(xor_ui8(162, 3), 161);
+        assert_eq!(xor_ui8(0, 162), 162);
+        assert_eq!(xor_ui8(162, 0), 162);
+        assert_eq!(xor_ui8(1, 162), 163);
+        assert_eq!(xor_ui8(162, 1), 163);
+        assert_eq!(xor_ui8(4, 162), 166);
+        assert_eq!(xor_ui8(162, 4), 166);
+        assert_eq!(xor_ui8(72, 254), 182);
+        assert_eq!(xor_ui8(254, 72), 182);
+        assert_eq!(xor_ui8(72, 255), 183);
+        assert_eq!(xor_ui8(255, 72), 183);
+        assert_eq!(xor_ui8(100, 162), 198);
+        assert_eq!(xor_ui8(162, 100), 198);
+        assert_eq!(xor_ui8(72, 162), 234);
+        assert_eq!(xor_ui8(162, 72), 234);
+        assert_eq!(xor_ui8(4, 254), 250);
+        assert_eq!(xor_ui8(254, 4), 250);
+        assert_eq!(xor_ui8(4, 255), 251);
+        assert_eq!(xor_ui8(255, 4), 251);
+        assert_eq!(xor_ui8(2, 254), 252);
+        assert_eq!(xor_ui8(3, 255), 252);
+        assert_eq!(xor_ui8(254, 2), 252);
+        assert_eq!(xor_ui8(255, 3), 252);
+        assert_eq!(xor_ui8(2, 255), 253);
+        assert_eq!(xor_ui8(3, 254), 253);
+        assert_eq!(xor_ui8(254, 3), 253);
+        assert_eq!(xor_ui8(255, 2), 253);
+        assert_eq!(xor_ui8(0, 254), 254);
+        assert_eq!(xor_ui8(1, 255), 254);
+        assert_eq!(xor_ui8(254, 0), 254);
+        assert_eq!(xor_ui8(255, 1), 254);
+        assert_eq!(xor_ui8(0, 255), 255);
+        assert_eq!(xor_ui8(1, 254), 255);
+        assert_eq!(xor_ui8(254, 1), 255);
+        assert_eq!(xor_ui8(255, 0), 255);
+    }
 }
diff --git a/arc-mlir/src/tests/arc-to-rust/int-tensor-arith.mlir.rust-tests b/arc-mlir/src/tests/arc-to-rust/int-tensor-arith.mlir.rust-tests
deleted file mode 100644
index 97fad3675..000000000
--- a/arc-mlir/src/tests/arc-to-rust/int-tensor-arith.mlir.rust-tests
+++ /dev/null
@@ -1,209 +0,0 @@
-#[cfg(test)]
-mod tests {
-    use crate::arctorustinttensorarith::*;
-    use ndarray::{Array,Dim,Ix};
-    use std::rc::Rc;
-
-    #[rewrite(main)]
-    #[test]
-    fn testu8() {
-	let a:Rc<Array<u8, Dim<[Ix; 2]>>> =
-	    Rc::new(Array::from_shape_vec((2, 2),
-					  vec![5, 6, 7, 8]).unwrap());
-	let b:Rc<Array<u8, Dim<[Ix; 2]>>> =
-	    Rc::new(Array::from_shape_vec((2, 2),
-					  vec![1, 2, 3, 4]).unwrap());
-	assert_eq!(*addi_tensor2x2xui8(Rc::clone(&a),
-					      Rc::clone(&b)),
-		   &*a + &*b);
-	assert_eq!(*subi_tensor2x2xui8(Rc::clone(&a),
-					      Rc::clone(&b)),
-		   &*a - &*b);
-	assert_eq!(*muli_tensor2x2xui8(Rc::clone(&a),
-					      Rc::clone(&b)),
-		   &*a * &*b);
-	assert_eq!(*divi_tensor2x2xui8(Rc::clone(&a),
-					      Rc::clone(&b)),
-		   &*a / &*b);
-	assert_eq!(*remi_tensor2x2xui8(Rc::clone(&a),
-					      Rc::clone(&b)),
-		   &*a % &*b);
-    }
-    #[rewrite(main)]
-    #[test]
-    fn tests8() {
-	let a:Rc<Array<i8, Dim<[Ix; 2]>>> =
-	    Rc::new(Array::from_shape_vec((2, 2),
-					  vec![5, 6, 7, 8]).unwrap());
-	let b:Rc<Array<i8, Dim<[Ix; 2]>>> =
-	    Rc::new(Array::from_shape_vec((2, 2),
-					  vec![1, 2, 3, 4]).unwrap());
-	assert_eq!(*addi_tensor2x2xsi8(Rc::clone(&a),
-					      Rc::clone(&b)),
-		   &*a + &*b);
-	assert_eq!(*subi_tensor2x2xsi8(Rc::clone(&a),
-					      Rc::clone(&b)),
-		   &*a - &*b);
-	assert_eq!(*muli_tensor2x2xsi8(Rc::clone(&a),
-					      Rc::clone(&b)),
-		   &*a * &*b);
-	assert_eq!(*divi_tensor2x2xsi8(Rc::clone(&a),
-					       Rc::clone(&b)),
-		   &*a / &*b);
-	assert_eq!(*remi_tensor2x2xsi8(Rc::clone(&a),
-					      Rc::clone(&b)),
-		   &*a % &*b);
-    }
-
-    #[rewrite(main)]
-    #[test]
-    fn testu16() {
-	let a:Rc<Array<u16, Dim<[Ix; 2]>>> =
-	    Rc::new(Array::from_shape_vec((2, 2),
-					  vec![5, 6, 7, 8]).unwrap());
-	let b:Rc<Array<u16, Dim<[Ix; 2]>>> =
-	    Rc::new(Array::from_shape_vec((2, 2),
-					  vec![1, 2, 3, 4]).unwrap());
-	assert_eq!(*addi_tensor2x2xui16(Rc::clone(&a),
-					       Rc::clone(&b)),
-		   &*a + &*b);
-	assert_eq!(*subi_tensor2x2xui16(Rc::clone(&a),
-					       Rc::clone(&b)),
-		   &*a - &*b);
-	assert_eq!(*muli_tensor2x2xui16(Rc::clone(&a),
-					       Rc::clone(&b)),
-		   &*a * &*b);
-	assert_eq!(*divi_tensor2x2xui16(Rc::clone(&a),
-					       Rc::clone(&b)),
-		   &*a / &*b);
-	assert_eq!(*remi_tensor2x2xui16(Rc::clone(&a),
-					       Rc::clone(&b)),
-		   &*a % &*b);
-    }
-    #[rewrite(main)]
-    #[test]
-    fn tests16() {
-	let a:Rc<Array<i16, Dim<[Ix; 2]>>> =
-	    Rc::new(Array::from_shape_vec((2, 2),
-					  vec![5, 6, 7, 8]).unwrap());
-	let b:Rc<Array<i16, Dim<[Ix; 2]>>> =
-	    Rc::new(Array::from_shape_vec((2, 2),
-					  vec![1, 2, 3, 4]).unwrap());
-	assert_eq!(*addi_tensor2x2xsi16(Rc::clone(&a),
-					       Rc::clone(&b)),
-		   &*a + &*b);
-	assert_eq!(*subi_tensor2x2xsi16(Rc::clone(&a),
-					       Rc::clone(&b)),
-		   &*a - &*b);
-	assert_eq!(*muli_tensor2x2xsi16(Rc::clone(&a),
-					       Rc::clone(&b)),
-		   &*a * &*b);
-	assert_eq!(*divi_tensor2x2xsi16(Rc::clone(&a),
-					       Rc::clone(&b)),
-		   &*a / &*b);
-	assert_eq!(*remi_tensor2x2xsi16(Rc::clone(&a),
-					       Rc::clone(&b)),
-		   &*a % &*b);
-    }
-    #[rewrite(main)]
-    #[test]
-    fn testu32() {
-	let a:Rc<Array<u32, Dim<[Ix; 2]>>> =
-	    Rc::new(Array::from_shape_vec((2, 2),
-					  vec![5, 6, 7, 8]).unwrap());
-	let b:Rc<Array<u32, Dim<[Ix; 2]>>> =
-	    Rc::new(Array::from_shape_vec((2, 2),
-					  vec![1, 2, 3, 4]).unwrap());
-	assert_eq!(*addi_tensor2x2xui32(Rc::clone(&a),
-					       Rc::clone(&b)),
-		   &*a + &*b);
-	assert_eq!(*subi_tensor2x2xui32(Rc::clone(&a),
-					       Rc::clone(&b)),
-		   &*a - &*b);
-	assert_eq!(*muli_tensor2x2xui32(Rc::clone(&a),
-					       Rc::clone(&b)),
-		   &*a * &*b);
-	assert_eq!(*divi_tensor2x2xui32(Rc::clone(&a),
-					       Rc::clone(&b)),
-		   &*a / &*b);
-	assert_eq!(*remi_tensor2x2xui32(Rc::clone(&a),
-					       Rc::clone(&b)),
-		   &*a % &*b);
-    }
-    #[rewrite(main)]
-    #[test]
-    fn tests32() {
-	let a:Rc<Array<i32, Dim<[Ix; 2]>>> =
-	    Rc::new(Array::from_shape_vec((2, 2),
-					  vec![5, 6, 7, 8]).unwrap());
-	let b:Rc<Array<i32, Dim<[Ix; 2]>>> =
-	    Rc::new(Array::from_shape_vec((2, 2),
-					  vec![1, 2, 3, 4]).unwrap());
-	assert_eq!(*addi_tensor2x2xsi32(Rc::clone(&a),
-					       Rc::clone(&b)),
-		   &*a + &*b);
-	assert_eq!(*subi_tensor2x2xsi32(Rc::clone(&a),
-					       Rc::clone(&b)),
-		   &*a - &*b);
-	assert_eq!(*muli_tensor2x2xsi32(Rc::clone(&a),
-					       Rc::clone(&b)),
-		   &*a * &*b);
-	assert_eq!(*divi_tensor2x2xsi32(Rc::clone(&a),
-					       Rc::clone(&b)),
-		   &*a / &*b);
-	assert_eq!(*remi_tensor2x2xsi32(Rc::clone(&a),
-					       Rc::clone(&b)),
-		   &*a % &*b);
-    }
-
-    #[rewrite(main)]
-    #[test]
-    fn testu64() {
-	let a:Rc<Array<u64, Dim<[Ix; 2]>>> =
-	    Rc::new(Array::from_shape_vec((2, 2),
-					  vec![5, 6, 7, 8]).unwrap());
-	let b:Rc<Array<u64, Dim<[Ix; 2]>>> =
-	    Rc::new(Array::from_shape_vec((2, 2),
-					  vec![1, 2, 3, 4]).unwrap());
-	assert_eq!(*addi_tensor2x2xui64(Rc::clone(&a),
-					       Rc::clone(&b)),
-		   &*a + &*b);
-	assert_eq!(*subi_tensor2x2xui64(Rc::clone(&a),
-					       Rc::clone(&b)),
-		   &*a - &*b);
-	assert_eq!(*muli_tensor2x2xui64(Rc::clone(&a),
-					       Rc::clone(&b)),
-		   &*a * &*b);
-	assert_eq!(*divi_tensor2x2xui64(Rc::clone(&a),
-					       Rc::clone(&b)),
-		   &*a / &*b);
-	assert_eq!(*remi_tensor2x2xui64(Rc::clone(&a),
-					       Rc::clone(&b)),
-		   &*a % &*b);
-    }
-    #[rewrite(main)]
-    #[test]
-    fn tests64() {
-	let a:Rc<Array<i64, Dim<[Ix; 2]>>> =
-	    Rc::new(Array::from_shape_vec((2, 2),
-					  vec![5, 6, 7, 8]).unwrap());
-	let b:Rc<Array<i64, Dim<[Ix; 2]>>> =
-	    Rc::new(Array::from_shape_vec((2, 2),
-					  vec![1, 2, 3, 4]).unwrap());
-	assert_eq!(*addi_tensor2x2xsi64(Rc::clone(&a),
-					       Rc::clone(&b)),
-		   &*a + &*b);
-	assert_eq!(*subi_tensor2x2xsi64(Rc::clone(&a),
-					       Rc::clone(&b)),
-		   &*a - &*b);
-	assert_eq!(*muli_tensor2x2xsi64(Rc::clone(&a),
-					       Rc::clone(&b)),
-		   &*a * &*b);
-	assert_eq!(*divi_tensor2x2xsi64(Rc::clone(&a),
-					       Rc::clone(&b)),
-		   &*a / &*b);
-	assert_eq!(*remi_tensor2x2xsi64(Rc::clone(&a),
-					       Rc::clone(&b)),
-		   &*a % &*b);
-    }
-}
diff --git a/arc-mlir/src/tests/arc-to-rust/loops.mlir b/arc-mlir/src/tests/arc-to-rust/loops.mlir
index 619904b1a..e07c2c877 100644
--- a/arc-mlir/src/tests/arc-to-rust/loops.mlir
+++ b/arc-mlir/src/tests/arc-to-rust/loops.mlir
@@ -4,7 +4,7 @@
 
 module @arctorustloops {
 
-  func.func @a_while_loop(%first : ui64, %limit : ui64, %accum : ui64) -> ui64 attributes { rust.declare } {
+  func.func @a_while_loop(%first : ui64, %limit : ui64, %accum : ui64) -> ui64 {
        %res_cnt, %res_sum = scf.while (%arg1 = %first, %sum = %accum) : (ui64, ui64) -> (ui64, ui64) {
          %condition = arc.cmpi "lt", %arg1, %limit : ui64
          scf.condition(%condition) %arg1, %sum : ui64, ui64
@@ -18,7 +18,7 @@ module @arctorustloops {
        return %res_sum : ui64
   }
 
-  func.func @a_while_loop_with_a_break_in_before(%first : ui64, %limit : ui64, %accum : ui64) -> ui64 attributes { rust.declare } {
+  func.func @a_while_loop_with_a_break_in_before(%first : ui64, %limit : ui64, %accum : ui64) -> ui64 {
        %res_cnt, %res_sum = scf.while (%arg1 = %first, %sum = %accum) : (ui64, ui64) -> (ui64, ui64) {
          %condition = arc.cmpi "lt", %arg1, %limit : ui64
 
@@ -41,7 +41,7 @@ module @arctorustloops {
        return %res_sum : ui64
   }
 
-  func.func @a_while_loop_with_a_break_in_after(%first : ui64, %limit : ui64, %accum : ui64) -> ui64 attributes { rust.declare } {
+  func.func @a_while_loop_with_a_break_in_after(%first : ui64, %limit : ui64, %accum : ui64) -> ui64 {
        %res_cnt, %res_sum = scf.while (%arg1 = %first, %sum = %accum) : (ui64, ui64) -> (ui64, ui64) {
          %condition = arc.cmpi "lt", %arg1, %limit : ui64
          scf.condition(%condition) %arg1, %sum : ui64, ui64
@@ -64,7 +64,7 @@ module @arctorustloops {
        return %res_sum : ui64
   }
 
-  func.func @a_while_loop_with_a_return_in_before(%first : ui64, %limit : ui64, %accum : ui64) -> ui64 attributes { rust.declare } {
+  func.func @a_while_loop_with_a_return_in_before(%first : ui64, %limit : ui64, %accum : ui64) -> ui64 {
        %res_cnt, %res_sum = scf.while (%arg1 = %first, %sum = %accum) : (ui64, ui64) -> (ui64, ui64) {
          %condition = arc.cmpi "lt", %arg1, %limit : ui64
 
@@ -87,7 +87,7 @@ module @arctorustloops {
        return %res_sum : ui64
   }
 
-  func.func @a_while_loop_with_a_return_in_after(%first : ui64, %limit : ui64, %accum : ui64) -> ui64 attributes { rust.declare } {
+  func.func @a_while_loop_with_a_return_in_after(%first : ui64, %limit : ui64, %accum : ui64) -> ui64 {
        %res_cnt, %res_sum = scf.while (%arg1 = %first, %sum = %accum) : (ui64, ui64) -> (ui64, ui64) {
          %condition = arc.cmpi "lt", %arg1, %limit : ui64
          scf.condition(%condition) %arg1, %sum : ui64, ui64
diff --git a/arc-mlir/src/tests/arc-to-rust/loops.mlir.rust-tests b/arc-mlir/src/tests/arc-to-rust/loops.mlir.rust-tests
index dd696cd25..f65d2a10f 100644
--- a/arc-mlir/src/tests/arc-to-rust/loops.mlir.rust-tests
+++ b/arc-mlir/src/tests/arc-to-rust/loops.mlir.rust-tests
@@ -1,15 +1,14 @@
 #[cfg(test)]
 mod tests {
-  use super::*;
-  use crate::arctorustloops::*;
-  use hexf::*;
-  #[rewrite(main)]
-  #[test]
-  fn it_works() {
-    assert_eq!(call!(a_while_loop(0, 5, 3)), 13);
-    assert_eq!(call!(a_while_loop_with_a_break_in_before(0, 5, 1)), 2);
-    assert_eq!(call!(a_while_loop_with_a_break_in_after(0, 10, 3)), 4);
-    assert_eq!(call!(a_while_loop_with_a_return_in_before(0, 5, 1)), 2);
-    assert_eq!(call!(a_while_loop_with_a_return_in_after(0, 10, 3)), 4);
-  }
+    use super::*;
+    use crate::arctorustloops::*;
+    use hexf::*;
+    #[test]
+    fn it_works() {
+        assert_eq!(a_while_loop(0, 5, 3), 13);
+        assert_eq!(a_while_loop_with_a_break_in_before(0, 5, 1), 2);
+        assert_eq!(a_while_loop_with_a_break_in_after(0, 10, 3), 4);
+        assert_eq!(a_while_loop_with_a_return_in_before(0, 5, 1), 2);
+        assert_eq!(a_while_loop_with_a_return_in_after(0, 10, 3), 4);
+    }
 }
diff --git a/arc-mlir/src/tests/arc-to-rust/panic.mlir b/arc-mlir/src/tests/arc-to-rust/panic.mlir
index 62b64a5b4..365054b34 100644
--- a/arc-mlir/src/tests/arc-to-rust/panic.mlir
+++ b/arc-mlir/src/tests/arc-to-rust/panic.mlir
@@ -12,5 +12,4 @@ module @toplevel {
     arc.panic("foo")
     return
   }
-
 }
diff --git a/arc-mlir/src/tests/arc-to-rust/select.mlir.rust-tests b/arc-mlir/src/tests/arc-to-rust/select.mlir.rust-tests
index 7c0635b02..0b51a9a8d 100644
--- a/arc-mlir/src/tests/arc-to-rust/select.mlir.rust-tests
+++ b/arc-mlir/src/tests/arc-to-rust/select.mlir.rust-tests
@@ -1,10 +1,9 @@
 #[cfg(test)]
 mod tests {
-  use crate::arctorustifs::*;
-  #[rewrite(main)]
-  #[test]
-  fn test() {
-    assert_eq!(call!(test_0(true, 3, 4)), 3);
-    assert_eq!(call!(test_0(false, 3, 4)), 4);
-  }
+    use crate::arctorustifs::*;
+    #[test]
+    fn test() {
+        assert_eq!(test_0(true, 3, 4), 3);
+        assert_eq!(test_0(false, 3, 4), 4);
+    }
 }
diff --git a/arc-mlir/src/tests/arc-to-rust/simple.mlir b/arc-mlir/src/tests/arc-to-rust/simple.mlir
index 4ef8703c0..999c79704 100644
--- a/arc-mlir/src/tests/arc-to-rust/simple.mlir
+++ b/arc-mlir/src/tests/arc-to-rust/simple.mlir
@@ -19,42 +19,34 @@ module @arctorustsimple {
     %b = arith.constant 0 : i1
     return %b : i1
   }
-
   func.func @return_ui8() -> ui8 {
     %b = arc.constant 255 : ui8
     return %b : ui8
   }
-
   func.func @return_ui16() -> ui16 {
     %b = arc.constant 65535 : ui16
     return %b : ui16
   }
-
   func.func @return_ui32() -> ui32 {
     %b = arc.constant 4294967295 : ui32
     return %b : ui32
   }
-
   func.func @return_ui64() -> ui64 {
     %b = arc.constant 18446744073709551615 : ui64
     return %b : ui64
   }
-
   func.func @return_si8() -> si8 {
     %b = arc.constant -128 : si8
     return %b : si8
   }
-
   func.func @return_si16() -> si16 {
     %b = arc.constant -32768 : si16
     return %b : si16
   }
-
   func.func @return_si32() -> si32 {
     %b = arc.constant -2147483648 : si32
     return %b : si32
   }
-
   func.func @return_si64() -> si64 {
     %b = arc.constant -9223372036854775808 : si64
     return %b : si64
diff --git a/arc-mlir/src/tests/arc-to-rust/simple.mlir.rust-tests b/arc-mlir/src/tests/arc-to-rust/simple.mlir.rust-tests
index 553db1c4f..0759ba92a 100644
--- a/arc-mlir/src/tests/arc-to-rust/simple.mlir.rust-tests
+++ b/arc-mlir/src/tests/arc-to-rust/simple.mlir.rust-tests
@@ -1,23 +1,22 @@
 #[cfg(test)]
 mod tests {
-  use crate::arctorustsimple::*;
-  use hexf::*;
-  #[rewrite(main)]
-  #[test]
-  fn it_works() {
-    assert_eq!(call!(returnf64()), hexf::hexf64!("0x1.91eb851eb851fp1"));
-    assert_eq!(call!(returnf32()), hexf::hexf32!("0x1.62e48ep-1"));
-    assert_eq!(call!(return_true()), true);
-    assert_eq!(call!(return_false()), false);
+    use crate::arctorustsimple::*;
+    use hexf::*;
+    #[test]
+    fn it_works() {
+        assert_eq!(returnf64(), hexf::hexf64!("0x1.91eb851eb851fp1"));
+        assert_eq!(returnf32(), hexf::hexf32!("0x1.62e48ep-1"));
+        assert_eq!(return_true(), true);
+        assert_eq!(return_false(), false);
 
-    assert_eq!(call!(return_ui8()), 0xFF);
-    assert_eq!(call!(return_ui16()), 0xFFFF);
-    assert_eq!(call!(return_ui32()), 0xFFFFFFFF);
-    assert_eq!(call!(return_ui64()), 0xFFFFFFFFFFFFFFFF);
+        assert_eq!(return_ui8(), 0xFF);
+        assert_eq!(return_ui16(), 0xFFFF);
+        assert_eq!(return_ui32(), 0xFFFFFFFF);
+        assert_eq!(return_ui64(), 0xFFFFFFFFFFFFFFFF);
 
-    assert_eq!(call!(return_si8()), -128);
-    assert_eq!(call!(return_si16()), -32768);
-    assert_eq!(call!(return_si32()), -2147483648);
-    assert_eq!(call!(return_si64()), -9223372036854775808);
-  }
+        assert_eq!(return_si8(), -128);
+        assert_eq!(return_si16(), -32768);
+        assert_eq!(return_si32(), -2147483648);
+        assert_eq!(return_si64(), -9223372036854775808);
+    }
 }
diff --git a/arc-mlir/src/tests/arc-to-rust/spawn.mlir b/arc-mlir/src/tests/arc-to-rust/spawn.mlir
deleted file mode 100644
index ca40a398d..000000000
--- a/arc-mlir/src/tests/arc-to-rust/spawn.mlir
+++ /dev/null
@@ -1,32 +0,0 @@
-// RUN: arc-mlir %s | arc-mlir
-// RUN: arc-mlir -canonicalize %s | arc-mlir
-// RUN: arc-mlir -canonicalize -arc-to-rust %s | FileCheck %s
-module @arctorustspawn {
-
-  func.func @id(%in : !arc.stream.source<si32>,
-                %out : !arc.stream.sink<si32>) -> ()
-    attributes {
-      arc.is_task,
-      rust.async,
-      rust.annotation = "#[rewrite(nonpersistent)]"
-    } {
-      scf.while () : () -> () {
-        %condition = arith.constant 1 : i1
-        scf.condition(%condition)
-      } do {
-        ^bb0():
-        %x = "arc.receive"(%in) : (!arc.stream.source<si32>) -> si32
-        "arc.send"(%x, %out) : (si32, !arc.stream.sink<si32>) -> ()
-        scf.yield
-      }
-      return
-    }
-
-    func.func @main(%in : !arc.stream.source<si32>,
-                    %out : !arc.stream.sink<si32>) {
-       arc.spawn @id(%in, %out) : (!arc.stream.source<si32>,
-                                   !arc.stream.sink<si32>) -> ()
-// CHECK: "rust.spawn"(%arg0, %arg1) {callee = @id} : (!rust<<i32>>, !rust<<i32>>) -> ()
-       return
-    }
-}
diff --git a/arc-mlir/src/tests/arc-to-rust/structs.mlir b/arc-mlir/src/tests/arc-to-rust/structs.mlir
index db82e5316..e4d4f74d8 100644
--- a/arc-mlir/src/tests/arc-to-rust/structs.mlir
+++ b/arc-mlir/src/tests/arc-to-rust/structs.mlir
@@ -72,7 +72,6 @@ module @arctoruststructs {
     %s = arc.make_struct(%b : si32) : !arc.struct<a : si32>
     %r0 = arc.make_struct(%a, %s : si32, !arc.struct<a : si32>) : !arc.struct<a : si32, b : !arc.struct<a : si32>>
     %r1 = arc.make_struct(%a, %s : si32, !arc.struct<a : si32>) : !arc.struct<a : si32, b : !arc.struct<a : si32>>
-
     return %a : si32
   }
 
@@ -95,6 +94,4 @@ module @arctoruststructs {
     %r = arc.make_struct(%a : si32) : !arc.struct<<a : si32>>
     return %r : !arc.struct<<a : si32>>
   }
-
-
 }
diff --git a/arc-mlir/src/tests/arc-to-rust/structs.mlir.rust-tests b/arc-mlir/src/tests/arc-to-rust/structs.mlir.rust-tests
index d43a89feb..f850d0e48 100644
--- a/arc-mlir/src/tests/arc-to-rust/structs.mlir.rust-tests
+++ b/arc-mlir/src/tests/arc-to-rust/structs.mlir.rust-tests
@@ -1,15 +1,14 @@
 // Empty
 #[cfg(test)]
 mod tests {
-  use crate::arctoruststructs::*;
-  #[rewrite(main)]
-  #[test]
-  fn it_works() {
-    assert_eq!(call!(ok3()).a, 4);
-    assert_eq!(call!(ok4()).a, 4);
-    assert_eq!(call!(ok5()).a, 4);
-    assert_eq!(call!(ok5()).b.a, 3);
-    assert_eq!(call!(ok6()), 4);
-    assert_eq!(call!(ok7()), 3);
-  }
+    use crate::arctoruststructs::*;
+    #[test]
+    fn it_works() {
+        assert_eq!(ok3().a, 4);
+        assert_eq!(ok4().a, 4);
+        assert_eq!(ok5().a, 4);
+        assert_eq!(ok5().b.a, 3);
+        assert_eq!(ok6(), 4);
+        assert_eq!(ok7(), 3);
+    }
 }
diff --git a/arc-mlir/src/tests/arc-to-rust/tensors.mlir.rust-tests b/arc-mlir/src/tests/arc-to-rust/tensors.mlir.rust-tests
deleted file mode 100644
index 3f408ec65..000000000
--- a/arc-mlir/src/tests/arc-to-rust/tensors.mlir.rust-tests
+++ /dev/null
@@ -1,46 +0,0 @@
-#[cfg(test)]
-mod tests {
-  use crate::arctorusttensors::*;
-  #[rewrite(main)]
-  #[test]
-  fn test() {
-    let tmp0 = call!(make_0());
-    let tmp1 = call!(make_1());
-    let tmp2 = call!(make_2());
-    let tmp3 = call!(make_3());
-
-    assert_eq!(tmp0[[0]], 0.0);
-
-    assert_eq!(tmp1[[0]], 0.0);
-    assert_eq!(tmp1[[1]], 1.0);
-
-    assert_eq!(tmp2[[0]], 0.0);
-    assert_eq!(tmp2[[1]], 1.0);
-    assert_eq!(tmp2[[2]], 2.0);
-
-    assert_eq!(tmp3[[0,0,0]], 0.0);
-    assert_eq!(tmp3[[0,0,1]], 1.0);
-    assert_eq!(tmp3[[0,0,2]], 2.0);
-    assert_eq!(tmp3[[0,0,3]], 3.0);
-    assert_eq!(tmp3[[0,1,0]], 4.0);
-    assert_eq!(tmp3[[0,1,1]], 5.0);
-    assert_eq!(tmp3[[0,1,2]], 6.0);
-    assert_eq!(tmp3[[0,1,3]], 7.0);
-    assert_eq!(tmp3[[0,2,0]], 8.0);
-    assert_eq!(tmp3[[0,2,1]], 9.0);
-    assert_eq!(tmp3[[0,2,2]], 10.0);
-    assert_eq!(tmp3[[0,2,3]], 11.0);
-    assert_eq!(tmp3[[1,0,0]], 12.0);
-    assert_eq!(tmp3[[1,0,1]], 13.0);
-    assert_eq!(tmp3[[1,0,2]], 14.0);
-    assert_eq!(tmp3[[1,0,3]], 15.0);
-    assert_eq!(tmp3[[1,1,0]], 16.0);
-    assert_eq!(tmp3[[1,1,1]], 17.0);
-    assert_eq!(tmp3[[1,1,2]], 18.0);
-    assert_eq!(tmp3[[1,1,3]], 19.0);
-    assert_eq!(tmp3[[1,2,0]], 20.0);
-    assert_eq!(tmp3[[1,2,1]], 21.0);
-    assert_eq!(tmp3[[1,2,2]], 22.0);
-    assert_eq!(tmp3[[1,2,3]], 23.0);
-  }
-}
diff --git a/arc-mlir/src/tests/arc-to-rust/unary-ops.mlir b/arc-mlir/src/tests/arc-to-rust/unary-ops.mlir
index 38e85bcd3..c8d4938a1 100644
--- a/arc-mlir/src/tests/arc-to-rust/unary-ops.mlir
+++ b/arc-mlir/src/tests/arc-to-rust/unary-ops.mlir
@@ -2,124 +2,123 @@
 // RUN: arc-mlir-rust-test %t-roundtrip-scf %s -rustinclude %s.rust-tests -canonicalize -remove-scf -canonicalize -to-scf -canonicalize
 
 module @arctorustunaryops {
-func.func @acos_f32(%a : f32) -> f32 {
-  %r = arc.acos %a : f32
-  return %r : f32
-}
-
-func.func @asin_f32(%a : f32) -> f32 {
-  %r = arc.asin %a : f32
-  return %r : f32
-}
-
-func.func @atan_f32(%a : f32) -> f32 {
-  %r = math.atan %a : f32
-  return %r : f32
-}
-
-func.func @cos_f32(%a : f32) -> f32 {
-  %r = math.cos %a : f32
-  return %r : f32
-}
-
-func.func @cosh_f32(%a : f32) -> f32 {
-  %r = arc.cosh %a : f32
-  return %r : f32
-}
-
-func.func @exp_f32(%a : f32) -> f32 {
-  %r = math.exp %a : f32
-  return %r : f32
-}
-
-func.func @log_f32(%a : f32) -> f32 {
-  %r = math.log %a : f32
-  return %r : f32
-}
-
-func.func @sin_f32(%a : f32) -> f32 {
-  %r = math.sin %a : f32
-  return %r : f32
-}
-
-func.func @sinh_f32(%a : f32) -> f32 {
-  %r = arc.sinh %a : f32
-  return %r : f32
-}
-
-func.func @sqrt_f32(%a : f32) -> f32 {
-  %r = math.sqrt %a : f32
-  return %r : f32
-}
-
-func.func @tan_f32(%a : f32) -> f32 {
-  %r = arc.tan %a : f32
-  return %r : f32
-}
-
-func.func @tanh_f32(%a : f32) -> f32 {
-  %r = math.tanh %a : f32
-  return %r : f32
-}
-
-func.func @acos_f64(%a : f64) -> f64 {
-  %r = arc.acos %a : f64
-  return %r : f64
-}
-
-func.func @asin_f64(%a : f64) -> f64 {
-  %r = arc.asin %a : f64
-  return %r : f64
-}
-
-func.func @atan_f64(%a : f64) -> f64 {
-  %r = math.atan %a : f64
-  return %r : f64
-}
-
-func.func @cos_f64(%a : f64) -> f64 {
-  %r = math.cos %a : f64
-  return %r : f64
-}
-
-func.func @cosh_f64(%a : f64) -> f64 {
-  %r = arc.cosh %a : f64
-  return %r : f64
-}
-
-func.func @exp_f64(%a : f64) -> f64 {
-  %r = math.exp %a : f64
-  return %r : f64
-}
-
-func.func @log_f64(%a : f64) -> f64 {
-  %r = math.log %a : f64
-  return %r : f64
-}
-
-func.func @sin_f64(%a : f64) -> f64 {
-  %r = math.sin %a : f64
-  return %r : f64
-}
-
-func.func @sinh_f64(%a : f64) -> f64 {
-  %r = arc.sinh %a : f64
-  return %r : f64
-}
-
-func.func @sqrt_f64(%a : f64) -> f64 {
-  %r = math.sqrt %a : f64
-  return %r : f64
-}
-
-func.func @tan_f64(%a : f64) -> f64 {
-  %r = arc.tan %a : f64
-  return %r : f64
-}
-
-func.func @tanh_f64(%a : f64) -> f64 {
-  %r = math.tanh %a : f64
-  return %r : f64
-}
-
+  func.func @acos_f32(%a : f32) -> f32 {
+    %r = arc.acos %a : f32
+      return %r : f32
+  }
+
+  func.func @asin_f32(%a : f32) -> f32 {
+    %r = arc.asin %a : f32
+      return %r : f32
+  }
+
+  func.func @atan_f32(%a : f32) -> f32 {
+    %r = math.atan %a : f32
+      return %r : f32
+  }
+
+  func.func @cos_f32(%a : f32) -> f32 {
+    %r = math.cos %a : f32
+      return %r : f32
+  }
+
+  func.func @cosh_f32(%a : f32) -> f32 {
+    %r = arc.cosh %a : f32
+      return %r : f32
+  }
+
+  func.func @exp_f32(%a : f32) -> f32 {
+    %r = math.exp %a : f32
+      return %r : f32
+  }
+
+  func.func @log_f32(%a : f32) -> f32 {
+    %r = math.log %a : f32
+      return %r : f32
+  }
+
+  func.func @sin_f32(%a : f32) -> f32 {
+    %r = math.sin %a : f32
+      return %r : f32
+  }
+
+  func.func @sinh_f32(%a : f32) -> f32 {
+    %r = arc.sinh %a : f32
+      return %r : f32
+  }
+
+  func.func @sqrt_f32(%a : f32) -> f32 {
+    %r = math.sqrt %a : f32
+      return %r : f32
+  }
+
+  func.func @tan_f32(%a : f32) -> f32 {
+    %r = arc.tan %a : f32
+      return %r : f32
+  }
+
+  func.func @tanh_f32(%a : f32) -> f32 {
+    %r = math.tanh %a : f32
+      return %r : f32
+  }
+
+  func.func @acos_f64(%a : f64) -> f64 {
+    %r = arc.acos %a : f64
+      return %r : f64
+  }
+
+  func.func @asin_f64(%a : f64) -> f64 {
+    %r = arc.asin %a : f64
+      return %r : f64
+  }
+
+  func.func @atan_f64(%a : f64) -> f64 {
+    %r = math.atan %a : f64
+      return %r : f64
+  }
+
+  func.func @cos_f64(%a : f64) -> f64 {
+    %r = math.cos %a : f64
+      return %r : f64
+  }
+
+  func.func @cosh_f64(%a : f64) -> f64 {
+    %r = arc.cosh %a : f64
+      return %r : f64
+  }
+
+  func.func @exp_f64(%a : f64) -> f64 {
+    %r = math.exp %a : f64
+      return %r : f64
+  }
+
+  func.func @log_f64(%a : f64) -> f64 {
+    %r = math.log %a : f64
+      return %r : f64
+  }
+
+  func.func @sin_f64(%a : f64) -> f64 {
+    %r = math.sin %a : f64
+      return %r : f64
+  }
+
+  func.func @sinh_f64(%a : f64) -> f64 {
+    %r = arc.sinh %a : f64
+      return %r : f64
+  }
+
+  func.func @sqrt_f64(%a : f64) -> f64 {
+    %r = math.sqrt %a : f64
+      return %r : f64
+  }
+
+  func.func @tan_f64(%a : f64) -> f64 {
+    %r = arc.tan %a : f64
+      return %r : f64
+  }
+
+  func.func @tanh_f64(%a : f64) -> f64 {
+    %r = math.tanh %a : f64
+      return %r : f64
+  }
 }
diff --git a/arc-mlir/src/tests/arc-to-rust/unary-ops.mlir.rust-tests b/arc-mlir/src/tests/arc-to-rust/unary-ops.mlir.rust-tests
index a922714e2..81ef232ad 100644
--- a/arc-mlir/src/tests/arc-to-rust/unary-ops.mlir.rust-tests
+++ b/arc-mlir/src/tests/arc-to-rust/unary-ops.mlir.rust-tests
@@ -1,194 +1,180 @@
 #[cfg(test)]
 mod tests {
-use crate::arctorustunaryops::*;
-#[rewrite(main)]
-#[test]
-  fn test_0() {
-    assert!((call!(acos_f32(1.00000000000000000000e+00)) - 0.00000000000000000000e+00).abs() < 1e-6);
-    assert!((call!(acos_f32(5.00000000000000000000e-01)) - 1.04719755119659785336e+00).abs() < 1e-6);
-    assert!((call!(acos_f32(1.00000000000000005551e-01)) - 1.47062890563333681371e+00).abs() < 1e-6);
-    assert!((call!(acos_f32(0.00000000000000000000e+00)) - 1.57079632679489655800e+00).abs() < 1e-6);
-    assert!((call!(acos_f32(-5.00000000000000000000e-01)) - 2.09439510239319570672e+00).abs() < 1e-6);
-    assert!((call!(acos_f32(-1.00000000000000000000e+00)) - 3.14159265358979311600e+00).abs() < 1e-6);
-    assert!((call!(acos_f64(1.00000000000000000000e+00)) - 0.00000000000000000000e+00).abs() < 1e-6);
-    assert!((call!(acos_f64(5.00000000000000000000e-01)) - 1.04719755119659785336e+00).abs() < 1e-6);
-    assert!((call!(acos_f64(1.00000000000000005551e-01)) - 1.47062890563333681371e+00).abs() < 1e-6);
-    assert!((call!(acos_f64(0.00000000000000000000e+00)) - 1.57079632679489655800e+00).abs() < 1e-6);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_1() {
-    assert!((call!(acos_f64(-5.00000000000000000000e-01)) - 2.09439510239319570672e+00).abs() < 1e-6);
-    assert!((call!(acos_f64(-1.00000000000000000000e+00)) - 3.14159265358979311600e+00).abs() < 1e-6);
-    assert!((call!(asin_f32(-1.00000000000000000000e+00)) - -1.57079632679489655800e+00).abs() < 1e-6);
-    assert!((call!(asin_f32(-5.00000000000000000000e-01)) - -5.23598775598298926681e-01).abs() < 1e-6);
-    assert!((call!(asin_f32(0.00000000000000000000e+00)) - 0.00000000000000000000e+00).abs() < 1e-6);
-    assert!((call!(asin_f32(1.00000000000000005551e-01)) - 1.00167421161559799803e-01).abs() < 1e-6);
-    assert!((call!(asin_f32(5.00000000000000000000e-01)) - 5.23598775598298926681e-01).abs() < 1e-6);
-    assert!((call!(asin_f32(1.00000000000000000000e+00)) - 1.57079632679489655800e+00).abs() < 1e-6);
-    assert!((call!(asin_f64(-1.00000000000000000000e+00)) - -1.57079632679489655800e+00).abs() < 1e-6);
-    assert!((call!(asin_f64(-5.00000000000000000000e-01)) - -5.23598775598298926681e-01).abs() < 1e-6);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_2() {
-    assert!((call!(asin_f64(0.00000000000000000000e+00)) - 0.00000000000000000000e+00).abs() < 1e-6);
-    assert!((call!(asin_f64(1.00000000000000005551e-01)) - 1.00167421161559799803e-01).abs() < 1e-6);
-    assert!((call!(asin_f64(5.00000000000000000000e-01)) - 5.23598775598298926681e-01).abs() < 1e-6);
-    assert!((call!(asin_f64(1.00000000000000000000e+00)) - 1.57079632679489655800e+00).abs() < 1e-6);
-    assert!((call!(atan_f32(-1.00000000000000000000e+00)) - -7.85398163397448278999e-01).abs() < 1e-6);
-    assert!((call!(atan_f32(-5.00000000000000000000e-01)) - -4.63647609000806093515e-01).abs() < 1e-6);
-    assert!((call!(atan_f32(0.00000000000000000000e+00)) - 0.00000000000000000000e+00).abs() < 1e-6);
-    assert!((call!(atan_f32(1.00000000000000005551e-01)) - 9.96686524911620380651e-02).abs() < 1e-6);
-    assert!((call!(atan_f32(5.00000000000000000000e-01)) - 4.63647609000806093515e-01).abs() < 1e-6);
-    assert!((call!(atan_f32(1.00000000000000000000e+00)) - 7.85398163397448278999e-01).abs() < 1e-6);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_3() {
-    assert!((call!(atan_f64(-1.00000000000000000000e+00)) - -7.85398163397448278999e-01).abs() < 1e-6);
-    assert!((call!(atan_f64(-5.00000000000000000000e-01)) - -4.63647609000806093515e-01).abs() < 1e-6);
-    assert!((call!(atan_f64(0.00000000000000000000e+00)) - 0.00000000000000000000e+00).abs() < 1e-6);
-    assert!((call!(atan_f64(1.00000000000000005551e-01)) - 9.96686524911620380651e-02).abs() < 1e-6);
-    assert!((call!(atan_f64(5.00000000000000000000e-01)) - 4.63647609000806093515e-01).abs() < 1e-6);
-    assert!((call!(atan_f64(1.00000000000000000000e+00)) - 7.85398163397448278999e-01).abs() < 1e-6);
-    assert!((call!(cos_f32(-1.00000000000000000000e+00)) - 5.40302305868139765010e-01).abs() < 1e-6);
-    assert!((call!(cos_f32(1.00000000000000000000e+00)) - 5.40302305868139765010e-01).abs() < 1e-6);
-    assert!((call!(cos_f32(-5.00000000000000000000e-01)) - 8.77582561890372758739e-01).abs() < 1e-6);
-    assert!((call!(cos_f32(5.00000000000000000000e-01)) - 8.77582561890372758739e-01).abs() < 1e-6);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_4() {
-    assert!((call!(cos_f32(1.00000000000000005551e-01)) - 9.95004165278025820562e-01).abs() < 1e-6);
-    assert!((call!(cos_f32(0.00000000000000000000e+00)) - 1.00000000000000000000e+00).abs() < 1e-6);
-    assert!((call!(cos_f64(-1.00000000000000000000e+00)) - 5.40302305868139765010e-01).abs() < 1e-6);
-    assert!((call!(cos_f64(1.00000000000000000000e+00)) - 5.40302305868139765010e-01).abs() < 1e-6);
-    assert!((call!(cos_f64(-5.00000000000000000000e-01)) - 8.77582561890372758739e-01).abs() < 1e-6);
-    assert!((call!(cos_f64(5.00000000000000000000e-01)) - 8.77582561890372758739e-01).abs() < 1e-6);
-    assert!((call!(cos_f64(1.00000000000000005551e-01)) - 9.95004165278025820562e-01).abs() < 1e-6);
-    assert!((call!(cos_f64(0.00000000000000000000e+00)) - 1.00000000000000000000e+00).abs() < 1e-6);
-    assert!((call!(cosh_f32(0.00000000000000000000e+00)) - 1.00000000000000000000e+00).abs() < 1e-6);
-    assert!((call!(cosh_f32(1.00000000000000005551e-01)) - 1.00500416805580350399e+00).abs() < 1e-6);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_5() {
-    assert!((call!(cosh_f32(-5.00000000000000000000e-01)) - 1.12762596520638069819e+00).abs() < 1e-6);
-    assert!((call!(cosh_f32(5.00000000000000000000e-01)) - 1.12762596520638069819e+00).abs() < 1e-6);
-    assert!((call!(cosh_f32(-1.00000000000000000000e+00)) - 1.54308063481524371241e+00).abs() < 1e-6);
-    assert!((call!(cosh_f32(1.00000000000000000000e+00)) - 1.54308063481524371241e+00).abs() < 1e-6);
-    assert!((call!(cosh_f64(0.00000000000000000000e+00)) - 1.00000000000000000000e+00).abs() < 1e-6);
-    assert!((call!(cosh_f64(1.00000000000000005551e-01)) - 1.00500416805580350399e+00).abs() < 1e-6);
-    assert!((call!(cosh_f64(-5.00000000000000000000e-01)) - 1.12762596520638069819e+00).abs() < 1e-6);
-    assert!((call!(cosh_f64(5.00000000000000000000e-01)) - 1.12762596520638069819e+00).abs() < 1e-6);
-    assert!((call!(cosh_f64(-1.00000000000000000000e+00)) - 1.54308063481524371241e+00).abs() < 1e-6);
-    assert!((call!(cosh_f64(1.00000000000000000000e+00)) - 1.54308063481524371241e+00).abs() < 1e-6);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_6() {
-    assert!((call!(exp_f32(-1.00000000000000000000e+00)) - 3.67879441171442334024e-01).abs() < 1e-6);
-    assert!((call!(exp_f32(-5.00000000000000000000e-01)) - 6.06530659712633424263e-01).abs() < 1e-6);
-    assert!((call!(exp_f32(0.00000000000000000000e+00)) - 1.00000000000000000000e+00).abs() < 1e-6);
-    assert!((call!(exp_f32(1.00000000000000005551e-01)) - 1.10517091807564771244e+00).abs() < 1e-6);
-    assert!((call!(exp_f32(5.00000000000000000000e-01)) - 1.64872127070012819416e+00).abs() < 1e-6);
-    assert!((call!(exp_f32(1.00000000000000000000e+00)) - 2.71828182845904509080e+00).abs() < 1e-6);
-    assert!((call!(exp_f64(-1.00000000000000000000e+00)) - 3.67879441171442334024e-01).abs() < 1e-6);
-    assert!((call!(exp_f64(-5.00000000000000000000e-01)) - 6.06530659712633424263e-01).abs() < 1e-6);
-    assert!((call!(exp_f64(0.00000000000000000000e+00)) - 1.00000000000000000000e+00).abs() < 1e-6);
-    assert!((call!(exp_f64(1.00000000000000005551e-01)) - 1.10517091807564771244e+00).abs() < 1e-6);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_7() {
-    assert!((call!(exp_f64(5.00000000000000000000e-01)) - 1.64872127070012819416e+00).abs() < 1e-6);
-    assert!((call!(exp_f64(1.00000000000000000000e+00)) - 2.71828182845904509080e+00).abs() < 1e-6);
-    assert!((call!(log_f32(1.00000000000000005551e-01)) - -2.30258509299404545700e+00).abs() < 1e-6);
-    assert!((call!(log_f32(5.00000000000000000000e-01)) - -6.93147180559945286227e-01).abs() < 1e-6);
-    assert!((call!(log_f32(1.00000000000000000000e+00)) - 0.00000000000000000000e+00).abs() < 1e-6);
-    assert!((call!(log_f64(1.00000000000000005551e-01)) - -2.30258509299404545700e+00).abs() < 1e-6);
-    assert!((call!(log_f64(5.00000000000000000000e-01)) - -6.93147180559945286227e-01).abs() < 1e-6);
-    assert!((call!(log_f64(1.00000000000000000000e+00)) - 0.00000000000000000000e+00).abs() < 1e-6);
-    assert!((call!(sin_f32(-1.00000000000000000000e+00)) - -8.41470984807896504876e-01).abs() < 1e-6);
-    assert!((call!(sin_f32(-5.00000000000000000000e-01)) - -4.79425538604203005377e-01).abs() < 1e-6);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_8() {
-    assert!((call!(sin_f32(0.00000000000000000000e+00)) - 0.00000000000000000000e+00).abs() < 1e-6);
-    assert!((call!(sin_f32(1.00000000000000005551e-01)) - 9.98334166468281547502e-02).abs() < 1e-6);
-    assert!((call!(sin_f32(5.00000000000000000000e-01)) - 4.79425538604203005377e-01).abs() < 1e-6);
-    assert!((call!(sin_f32(1.00000000000000000000e+00)) - 8.41470984807896504876e-01).abs() < 1e-6);
-    assert!((call!(sin_f64(-1.00000000000000000000e+00)) - -8.41470984807896504876e-01).abs() < 1e-6);
-    assert!((call!(sin_f64(-5.00000000000000000000e-01)) - -4.79425538604203005377e-01).abs() < 1e-6);
-    assert!((call!(sin_f64(0.00000000000000000000e+00)) - 0.00000000000000000000e+00).abs() < 1e-6);
-    assert!((call!(sin_f64(1.00000000000000005551e-01)) - 9.98334166468281547502e-02).abs() < 1e-6);
-    assert!((call!(sin_f64(5.00000000000000000000e-01)) - 4.79425538604203005377e-01).abs() < 1e-6);
-    assert!((call!(sin_f64(1.00000000000000000000e+00)) - 8.41470984807896504876e-01).abs() < 1e-6);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_9() {
-    assert!((call!(sinh_f32(-1.00000000000000000000e+00)) - -1.17520119364380137839e+00).abs() < 1e-6);
-    assert!((call!(sinh_f32(-5.00000000000000000000e-01)) - -5.21095305493747384951e-01).abs() < 1e-6);
-    assert!((call!(sinh_f32(0.00000000000000000000e+00)) - 0.00000000000000000000e+00).abs() < 1e-6);
-    assert!((call!(sinh_f32(1.00000000000000005551e-01)) - 1.00166750019844028041e-01).abs() < 1e-6);
-    assert!((call!(sinh_f32(5.00000000000000000000e-01)) - 5.21095305493747384951e-01).abs() < 1e-6);
-    assert!((call!(sinh_f32(1.00000000000000000000e+00)) - 1.17520119364380137839e+00).abs() < 1e-6);
-    assert!((call!(sinh_f64(-1.00000000000000000000e+00)) - -1.17520119364380137839e+00).abs() < 1e-6);
-    assert!((call!(sinh_f64(-5.00000000000000000000e-01)) - -5.21095305493747384951e-01).abs() < 1e-6);
-    assert!((call!(sinh_f64(0.00000000000000000000e+00)) - 0.00000000000000000000e+00).abs() < 1e-6);
-    assert!((call!(sinh_f64(1.00000000000000005551e-01)) - 1.00166750019844028041e-01).abs() < 1e-6);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_10() {
-    assert!((call!(sinh_f64(5.00000000000000000000e-01)) - 5.21095305493747384951e-01).abs() < 1e-6);
-    assert!((call!(sinh_f64(1.00000000000000000000e+00)) - 1.17520119364380137839e+00).abs() < 1e-6);
-    assert!((call!(sqrt_f32(0.00000000000000000000e+00)) - 0.00000000000000000000e+00).abs() < 1e-6);
-    assert!((call!(sqrt_f32(1.00000000000000005551e-01)) - 3.16227766016837941176e-01).abs() < 1e-6);
-    assert!((call!(sqrt_f32(5.00000000000000000000e-01)) - 7.07106781186547572737e-01).abs() < 1e-6);
-    assert!((call!(sqrt_f32(1.00000000000000000000e+00)) - 1.00000000000000000000e+00).abs() < 1e-6);
-    assert!((call!(sqrt_f64(0.00000000000000000000e+00)) - 0.00000000000000000000e+00).abs() < 1e-6);
-    assert!((call!(sqrt_f64(1.00000000000000005551e-01)) - 3.16227766016837941176e-01).abs() < 1e-6);
-    assert!((call!(sqrt_f64(5.00000000000000000000e-01)) - 7.07106781186547572737e-01).abs() < 1e-6);
-    assert!((call!(sqrt_f64(1.00000000000000000000e+00)) - 1.00000000000000000000e+00).abs() < 1e-6);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_11() {
-    assert!((call!(tan_f32(-1.00000000000000000000e+00)) - -1.55740772465490229237e+00).abs() < 1e-6);
-    assert!((call!(tan_f32(-5.00000000000000000000e-01)) - -5.46302489843790484159e-01).abs() < 1e-6);
-    assert!((call!(tan_f32(0.00000000000000000000e+00)) - 0.00000000000000000000e+00).abs() < 1e-6);
-    assert!((call!(tan_f32(1.00000000000000005551e-01)) - 1.00334672085450549162e-01).abs() < 1e-6);
-    assert!((call!(tan_f32(5.00000000000000000000e-01)) - 5.46302489843790484159e-01).abs() < 1e-6);
-    assert!((call!(tan_f32(1.00000000000000000000e+00)) - 1.55740772465490229237e+00).abs() < 1e-6);
-    assert!((call!(tan_f64(-1.00000000000000000000e+00)) - -1.55740772465490229237e+00).abs() < 1e-6);
-    assert!((call!(tan_f64(-5.00000000000000000000e-01)) - -5.46302489843790484159e-01).abs() < 1e-6);
-    assert!((call!(tan_f64(0.00000000000000000000e+00)) - 0.00000000000000000000e+00).abs() < 1e-6);
-    assert!((call!(tan_f64(1.00000000000000005551e-01)) - 1.00334672085450549162e-01).abs() < 1e-6);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_12() {
-    assert!((call!(tan_f64(5.00000000000000000000e-01)) - 5.46302489843790484159e-01).abs() < 1e-6);
-    assert!((call!(tan_f64(1.00000000000000000000e+00)) - 1.55740772465490229237e+00).abs() < 1e-6);
-    assert!((call!(tanh_f32(-1.00000000000000000000e+00)) - -7.61594155955764851029e-01).abs() < 1e-6);
-    assert!((call!(tanh_f32(-5.00000000000000000000e-01)) - -4.62117157260009736586e-01).abs() < 1e-6);
-    assert!((call!(tanh_f32(0.00000000000000000000e+00)) - 0.00000000000000000000e+00).abs() < 1e-6);
-    assert!((call!(tanh_f32(1.00000000000000005551e-01)) - 9.96679946249558190718e-02).abs() < 1e-6);
-    assert!((call!(tanh_f32(5.00000000000000000000e-01)) - 4.62117157260009736586e-01).abs() < 1e-6);
-    assert!((call!(tanh_f32(1.00000000000000000000e+00)) - 7.61594155955764851029e-01).abs() < 1e-6);
-    assert!((call!(tanh_f64(-1.00000000000000000000e+00)) - -7.61594155955764851029e-01).abs() < 1e-6);
-    assert!((call!(tanh_f64(-5.00000000000000000000e-01)) - -4.62117157260009736586e-01).abs() < 1e-6);
-  }
-  #[rewrite(main)]
-  #[test]
-  fn test_13() {
-    assert!((call!(tanh_f64(0.00000000000000000000e+00)) - 0.00000000000000000000e+00).abs() < 1e-6);
-    assert!((call!(tanh_f64(1.00000000000000005551e-01)) - 9.96679946249558190718e-02).abs() < 1e-6);
-    assert!((call!(tanh_f64(5.00000000000000000000e-01)) - 4.62117157260009736586e-01).abs() < 1e-6);
-    assert!((call!(tanh_f64(1.00000000000000000000e+00)) - 7.61594155955764851029e-01).abs() < 1e-6);
-  }
+    use crate::arctorustunaryops::*;
+    #[test]
+    fn test_0() {
+        assert!((acos_f32(1.00000000000000000000e+00) - 0.00000000000000000000e+00).abs() < 1e-6);
+        assert!((acos_f32(5.00000000000000000000e-01) - 1.04719755119659785336e+00).abs() < 1e-6);
+        assert!((acos_f32(1.00000000000000005551e-01) - 1.47062890563333681371e+00).abs() < 1e-6);
+        assert!((acos_f32(0.00000000000000000000e+00) - 1.57079632679489655800e+00).abs() < 1e-6);
+        assert!((acos_f32(-5.00000000000000000000e-01) - 2.09439510239319570672e+00).abs() < 1e-6);
+        assert!((acos_f32(-1.00000000000000000000e+00) - 3.14159265358979311600e+00).abs() < 1e-6);
+        assert!((acos_f64(1.00000000000000000000e+00) - 0.00000000000000000000e+00).abs() < 1e-6);
+        assert!((acos_f64(5.00000000000000000000e-01) - 1.04719755119659785336e+00).abs() < 1e-6);
+        assert!((acos_f64(1.00000000000000005551e-01) - 1.47062890563333681371e+00).abs() < 1e-6);
+        assert!((acos_f64(0.00000000000000000000e+00) - 1.57079632679489655800e+00).abs() < 1e-6);
+    }
+    #[test]
+    fn test_1() {
+        assert!((acos_f64(-5.00000000000000000000e-01) - 2.09439510239319570672e+00).abs() < 1e-6);
+        assert!((acos_f64(-1.00000000000000000000e+00) - 3.14159265358979311600e+00).abs() < 1e-6);
+        assert!((asin_f32(-1.00000000000000000000e+00) - -1.57079632679489655800e+00).abs() < 1e-6);
+        assert!((asin_f32(-5.00000000000000000000e-01) - -5.23598775598298926681e-01).abs() < 1e-6);
+        assert!((asin_f32(0.00000000000000000000e+00) - 0.00000000000000000000e+00).abs() < 1e-6);
+        assert!((asin_f32(1.00000000000000005551e-01) - 1.00167421161559799803e-01).abs() < 1e-6);
+        assert!((asin_f32(5.00000000000000000000e-01) - 5.23598775598298926681e-01).abs() < 1e-6);
+        assert!((asin_f32(1.00000000000000000000e+00) - 1.57079632679489655800e+00).abs() < 1e-6);
+        assert!((asin_f64(-1.00000000000000000000e+00) - -1.57079632679489655800e+00).abs() < 1e-6);
+        assert!((asin_f64(-5.00000000000000000000e-01) - -5.23598775598298926681e-01).abs() < 1e-6);
+    }
+    #[test]
+    fn test_2() {
+        assert!((asin_f64(0.00000000000000000000e+00) - 0.00000000000000000000e+00).abs() < 1e-6);
+        assert!((asin_f64(1.00000000000000005551e-01) - 1.00167421161559799803e-01).abs() < 1e-6);
+        assert!((asin_f64(5.00000000000000000000e-01) - 5.23598775598298926681e-01).abs() < 1e-6);
+        assert!((asin_f64(1.00000000000000000000e+00) - 1.57079632679489655800e+00).abs() < 1e-6);
+        assert!((atan_f32(-1.00000000000000000000e+00) - -7.85398163397448278999e-01).abs() < 1e-6);
+        assert!((atan_f32(-5.00000000000000000000e-01) - -4.63647609000806093515e-01).abs() < 1e-6);
+        assert!((atan_f32(0.00000000000000000000e+00) - 0.00000000000000000000e+00).abs() < 1e-6);
+        assert!((atan_f32(1.00000000000000005551e-01) - 9.96686524911620380651e-02).abs() < 1e-6);
+        assert!((atan_f32(5.00000000000000000000e-01) - 4.63647609000806093515e-01).abs() < 1e-6);
+        assert!((atan_f32(1.00000000000000000000e+00) - 7.85398163397448278999e-01).abs() < 1e-6);
+    }
+    #[test]
+    fn test_3() {
+        assert!((atan_f64(-1.00000000000000000000e+00) - -7.85398163397448278999e-01).abs() < 1e-6);
+        assert!((atan_f64(-5.00000000000000000000e-01) - -4.63647609000806093515e-01).abs() < 1e-6);
+        assert!((atan_f64(0.00000000000000000000e+00) - 0.00000000000000000000e+00).abs() < 1e-6);
+        assert!((atan_f64(1.00000000000000005551e-01) - 9.96686524911620380651e-02).abs() < 1e-6);
+        assert!((atan_f64(5.00000000000000000000e-01) - 4.63647609000806093515e-01).abs() < 1e-6);
+        assert!((atan_f64(1.00000000000000000000e+00) - 7.85398163397448278999e-01).abs() < 1e-6);
+        assert!((cos_f32(-1.00000000000000000000e+00) - 5.40302305868139765010e-01).abs() < 1e-6);
+        assert!((cos_f32(1.00000000000000000000e+00) - 5.40302305868139765010e-01).abs() < 1e-6);
+        assert!((cos_f32(-5.00000000000000000000e-01) - 8.77582561890372758739e-01).abs() < 1e-6);
+        assert!((cos_f32(5.00000000000000000000e-01) - 8.77582561890372758739e-01).abs() < 1e-6);
+    }
+    #[test]
+    fn test_4() {
+        assert!((cos_f32(1.00000000000000005551e-01) - 9.95004165278025820562e-01).abs() < 1e-6);
+        assert!((cos_f32(0.00000000000000000000e+00) - 1.00000000000000000000e+00).abs() < 1e-6);
+        assert!((cos_f64(-1.00000000000000000000e+00) - 5.40302305868139765010e-01).abs() < 1e-6);
+        assert!((cos_f64(1.00000000000000000000e+00) - 5.40302305868139765010e-01).abs() < 1e-6);
+        assert!((cos_f64(-5.00000000000000000000e-01) - 8.77582561890372758739e-01).abs() < 1e-6);
+        assert!((cos_f64(5.00000000000000000000e-01) - 8.77582561890372758739e-01).abs() < 1e-6);
+        assert!((cos_f64(1.00000000000000005551e-01) - 9.95004165278025820562e-01).abs() < 1e-6);
+        assert!((cos_f64(0.00000000000000000000e+00) - 1.00000000000000000000e+00).abs() < 1e-6);
+        assert!((cosh_f32(0.00000000000000000000e+00) - 1.00000000000000000000e+00).abs() < 1e-6);
+        assert!((cosh_f32(1.00000000000000005551e-01) - 1.00500416805580350399e+00).abs() < 1e-6);
+    }
+    #[test]
+    fn test_5() {
+        assert!((cosh_f32(-5.00000000000000000000e-01) - 1.12762596520638069819e+00).abs() < 1e-6);
+        assert!((cosh_f32(5.00000000000000000000e-01) - 1.12762596520638069819e+00).abs() < 1e-6);
+        assert!((cosh_f32(-1.00000000000000000000e+00) - 1.54308063481524371241e+00).abs() < 1e-6);
+        assert!((cosh_f32(1.00000000000000000000e+00) - 1.54308063481524371241e+00).abs() < 1e-6);
+        assert!((cosh_f64(0.00000000000000000000e+00) - 1.00000000000000000000e+00).abs() < 1e-6);
+        assert!((cosh_f64(1.00000000000000005551e-01) - 1.00500416805580350399e+00).abs() < 1e-6);
+        assert!((cosh_f64(-5.00000000000000000000e-01) - 1.12762596520638069819e+00).abs() < 1e-6);
+        assert!((cosh_f64(5.00000000000000000000e-01) - 1.12762596520638069819e+00).abs() < 1e-6);
+        assert!((cosh_f64(-1.00000000000000000000e+00) - 1.54308063481524371241e+00).abs() < 1e-6);
+        assert!((cosh_f64(1.00000000000000000000e+00) - 1.54308063481524371241e+00).abs() < 1e-6);
+    }
+    #[test]
+    fn test_6() {
+        assert!((exp_f32(-1.00000000000000000000e+00) - 3.67879441171442334024e-01).abs() < 1e-6);
+        assert!((exp_f32(-5.00000000000000000000e-01) - 6.06530659712633424263e-01).abs() < 1e-6);
+        assert!((exp_f32(0.00000000000000000000e+00) - 1.00000000000000000000e+00).abs() < 1e-6);
+        assert!((exp_f32(1.00000000000000005551e-01) - 1.10517091807564771244e+00).abs() < 1e-6);
+        assert!((exp_f32(5.00000000000000000000e-01) - 1.64872127070012819416e+00).abs() < 1e-6);
+        assert!((exp_f32(1.00000000000000000000e+00) - 2.71828182845904509080e+00).abs() < 1e-6);
+        assert!((exp_f64(-1.00000000000000000000e+00) - 3.67879441171442334024e-01).abs() < 1e-6);
+        assert!((exp_f64(-5.00000000000000000000e-01) - 6.06530659712633424263e-01).abs() < 1e-6);
+        assert!((exp_f64(0.00000000000000000000e+00) - 1.00000000000000000000e+00).abs() < 1e-6);
+        assert!((exp_f64(1.00000000000000005551e-01) - 1.10517091807564771244e+00).abs() < 1e-6);
+    }
+    #[test]
+    fn test_7() {
+        assert!((exp_f64(5.00000000000000000000e-01) - 1.64872127070012819416e+00).abs() < 1e-6);
+        assert!((exp_f64(1.00000000000000000000e+00) - 2.71828182845904509080e+00).abs() < 1e-6);
+        assert!((log_f32(1.00000000000000005551e-01) - -2.30258509299404545700e+00).abs() < 1e-6);
+        assert!((log_f32(5.00000000000000000000e-01) - -6.93147180559945286227e-01).abs() < 1e-6);
+        assert!((log_f32(1.00000000000000000000e+00) - 0.00000000000000000000e+00).abs() < 1e-6);
+        assert!((log_f64(1.00000000000000005551e-01) - -2.30258509299404545700e+00).abs() < 1e-6);
+        assert!((log_f64(5.00000000000000000000e-01) - -6.93147180559945286227e-01).abs() < 1e-6);
+        assert!((log_f64(1.00000000000000000000e+00) - 0.00000000000000000000e+00).abs() < 1e-6);
+        assert!((sin_f32(-1.00000000000000000000e+00) - -8.41470984807896504876e-01).abs() < 1e-6);
+        assert!((sin_f32(-5.00000000000000000000e-01) - -4.79425538604203005377e-01).abs() < 1e-6);
+    }
+    #[test]
+    fn test_8() {
+        assert!((sin_f32(0.00000000000000000000e+00) - 0.00000000000000000000e+00).abs() < 1e-6);
+        assert!((sin_f32(1.00000000000000005551e-01) - 9.98334166468281547502e-02).abs() < 1e-6);
+        assert!((sin_f32(5.00000000000000000000e-01) - 4.79425538604203005377e-01).abs() < 1e-6);
+        assert!((sin_f32(1.00000000000000000000e+00) - 8.41470984807896504876e-01).abs() < 1e-6);
+        assert!((sin_f64(-1.00000000000000000000e+00) - -8.41470984807896504876e-01).abs() < 1e-6);
+        assert!((sin_f64(-5.00000000000000000000e-01) - -4.79425538604203005377e-01).abs() < 1e-6);
+        assert!((sin_f64(0.00000000000000000000e+00) - 0.00000000000000000000e+00).abs() < 1e-6);
+        assert!((sin_f64(1.00000000000000005551e-01) - 9.98334166468281547502e-02).abs() < 1e-6);
+        assert!((sin_f64(5.00000000000000000000e-01) - 4.79425538604203005377e-01).abs() < 1e-6);
+        assert!((sin_f64(1.00000000000000000000e+00) - 8.41470984807896504876e-01).abs() < 1e-6);
+    }
+    #[test]
+    fn test_9() {
+        assert!((sinh_f32(-1.00000000000000000000e+00) - -1.17520119364380137839e+00).abs() < 1e-6);
+        assert!((sinh_f32(-5.00000000000000000000e-01) - -5.21095305493747384951e-01).abs() < 1e-6);
+        assert!((sinh_f32(0.00000000000000000000e+00) - 0.00000000000000000000e+00).abs() < 1e-6);
+        assert!((sinh_f32(1.00000000000000005551e-01) - 1.00166750019844028041e-01).abs() < 1e-6);
+        assert!((sinh_f32(5.00000000000000000000e-01) - 5.21095305493747384951e-01).abs() < 1e-6);
+        assert!((sinh_f32(1.00000000000000000000e+00) - 1.17520119364380137839e+00).abs() < 1e-6);
+        assert!((sinh_f64(-1.00000000000000000000e+00) - -1.17520119364380137839e+00).abs() < 1e-6);
+        assert!((sinh_f64(-5.00000000000000000000e-01) - -5.21095305493747384951e-01).abs() < 1e-6);
+        assert!((sinh_f64(0.00000000000000000000e+00) - 0.00000000000000000000e+00).abs() < 1e-6);
+        assert!((sinh_f64(1.00000000000000005551e-01) - 1.00166750019844028041e-01).abs() < 1e-6);
+    }
+    #[test]
+    fn test_10() {
+        assert!((sinh_f64(5.00000000000000000000e-01) - 5.21095305493747384951e-01).abs() < 1e-6);
+        assert!((sinh_f64(1.00000000000000000000e+00) - 1.17520119364380137839e+00).abs() < 1e-6);
+        assert!((sqrt_f32(0.00000000000000000000e+00) - 0.00000000000000000000e+00).abs() < 1e-6);
+        assert!((sqrt_f32(1.00000000000000005551e-01) - 3.16227766016837941176e-01).abs() < 1e-6);
+        assert!((sqrt_f32(5.00000000000000000000e-01) - 7.07106781186547572737e-01).abs() < 1e-6);
+        assert!((sqrt_f32(1.00000000000000000000e+00) - 1.00000000000000000000e+00).abs() < 1e-6);
+        assert!((sqrt_f64(0.00000000000000000000e+00) - 0.00000000000000000000e+00).abs() < 1e-6);
+        assert!((sqrt_f64(1.00000000000000005551e-01) - 3.16227766016837941176e-01).abs() < 1e-6);
+        assert!((sqrt_f64(5.00000000000000000000e-01) - 7.07106781186547572737e-01).abs() < 1e-6);
+        assert!((sqrt_f64(1.00000000000000000000e+00) - 1.00000000000000000000e+00).abs() < 1e-6);
+    }
+    #[test]
+    fn test_11() {
+        assert!((tan_f32(-1.00000000000000000000e+00) - -1.55740772465490229237e+00).abs() < 1e-6);
+        assert!((tan_f32(-5.00000000000000000000e-01) - -5.46302489843790484159e-01).abs() < 1e-6);
+        assert!((tan_f32(0.00000000000000000000e+00) - 0.00000000000000000000e+00).abs() < 1e-6);
+        assert!((tan_f32(1.00000000000000005551e-01) - 1.00334672085450549162e-01).abs() < 1e-6);
+        assert!((tan_f32(5.00000000000000000000e-01) - 5.46302489843790484159e-01).abs() < 1e-6);
+        assert!((tan_f32(1.00000000000000000000e+00) - 1.55740772465490229237e+00).abs() < 1e-6);
+        assert!((tan_f64(-1.00000000000000000000e+00) - -1.55740772465490229237e+00).abs() < 1e-6);
+        assert!((tan_f64(-5.00000000000000000000e-01) - -5.46302489843790484159e-01).abs() < 1e-6);
+        assert!((tan_f64(0.00000000000000000000e+00) - 0.00000000000000000000e+00).abs() < 1e-6);
+        assert!((tan_f64(1.00000000000000005551e-01) - 1.00334672085450549162e-01).abs() < 1e-6);
+    }
+    #[test]
+    fn test_12() {
+        assert!((tan_f64(5.00000000000000000000e-01) - 5.46302489843790484159e-01).abs() < 1e-6);
+        assert!((tan_f64(1.00000000000000000000e+00) - 1.55740772465490229237e+00).abs() < 1e-6);
+        assert!((tanh_f32(-1.00000000000000000000e+00) - -7.61594155955764851029e-01).abs() < 1e-6);
+        assert!((tanh_f32(-5.00000000000000000000e-01) - -4.62117157260009736586e-01).abs() < 1e-6);
+        assert!((tanh_f32(0.00000000000000000000e+00) - 0.00000000000000000000e+00).abs() < 1e-6);
+        assert!((tanh_f32(1.00000000000000005551e-01) - 9.96679946249558190718e-02).abs() < 1e-6);
+        assert!((tanh_f32(5.00000000000000000000e-01) - 4.62117157260009736586e-01).abs() < 1e-6);
+        assert!((tanh_f32(1.00000000000000000000e+00) - 7.61594155955764851029e-01).abs() < 1e-6);
+        assert!((tanh_f64(-1.00000000000000000000e+00) - -7.61594155955764851029e-01).abs() < 1e-6);
+        assert!((tanh_f64(-5.00000000000000000000e-01) - -4.62117157260009736586e-01).abs() < 1e-6);
+    }
+    #[test]
+    fn test_13() {
+        assert!((tanh_f64(0.00000000000000000000e+00) - 0.00000000000000000000e+00).abs() < 1e-6);
+        assert!((tanh_f64(1.00000000000000005551e-01) - 9.96679946249558190718e-02).abs() < 1e-6);
+        assert!((tanh_f64(5.00000000000000000000e-01) - 4.62117157260009736586e-01).abs() < 1e-6);
+        assert!((tanh_f64(1.00000000000000000000e+00) - 7.61594155955764851029e-01).abs() < 1e-6);
+    }
 }
diff --git a/arc-mlir/src/tests/lit.cfg.py b/arc-mlir/src/tests/lit.cfg.py
index f139608ba..c22b95097 100644
--- a/arc-mlir/src/tests/lit.cfg.py
+++ b/arc-mlir/src/tests/lit.cfg.py
@@ -57,7 +57,7 @@
 llvm_config.with_environment('ARC_CARGO', 'arc-cargo')
 
 tool_dirs = [config.mlir_tools_dir, config.llvm_tools_dir,
-             config.arcscript_tools_dir]
+             config.arclang_tools_dir]
 tools = [
     'mlir-opt',
     'mlir-tblgen',
diff --git a/arc-mlir/src/tests/lit.site.cfg.py.in b/arc-mlir/src/tests/lit.site.cfg.py.in
index 73329d9db..7a7c1cfaa 100644
--- a/arc-mlir/src/tests/lit.site.cfg.py.in
+++ b/arc-mlir/src/tests/lit.site.cfg.py.in
@@ -32,7 +32,7 @@ config.mlir_src_root = "@MLIR_SOURCE_DIR@"
 config.mlir_obj_root = "@MLIR_BINARY_DIR@"
 config.mlir_tools_dir = "@MLIR_TOOLS_DIR@"
 config.linalg_test_lib_dir = "@MLIR_DIALECT_LINALG_INTEGRATION_TEST_LIB_DIR@"
-config.arcscript_tools_dir = "@ARC_SCRIPT_TOOLS_DIR@"
+config.arclang_tools_dir = "@ARC_LANG_TOOLS_DIR@"
 
 # Support substitution of the tools_dir with user parameters. This is
 # used when we can't determine the tool dir at configuration time.
@@ -48,4 +48,4 @@ import lit.llvm
 lit.llvm.initialize(lit_config, config)
 
 # Let the main config do the real work.
-lit_config.load_config(config, "@ARC_MLIR_SOURCE_DIR@/tests/lit.cfg.py")
+lit_config.load_config(config, "@ARC_MLIR_SRC_DIR@/tests/lit.cfg.py")
diff --git a/arc-mlir/src/tools/CMakeLists.txt b/arc-mlir/src/tools/CMakeLists.txt
index 8cffc346c..faac9e8a7 100644
--- a/arc-mlir/src/tools/CMakeLists.txt
+++ b/arc-mlir/src/tools/CMakeLists.txt
@@ -1,10 +1,10 @@
 add_subdirectory(arc-mlir)
 
-set(CARGO_TOML_TEMPLATE_FILE "${ARC_LANG_SRC_DIR}/etc/Cargo.toml.template")
-file(READ ${CARGO_TOML_TEMPLATE_FILE} CARGO_TOML_TEMPLATE)
-set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS
-  ${CARGO_TOML_TEMPLATE_FILE})
-
+# Generate script files from a templates (e.g., arc-cargo from arc-cargo.in) by
+# replacing variables like @VAR@ with their CMake values. The resulting file 
+# will be placed in the LLVM_TOOLS_BINARY_DIR directory. @ONLY indicates that 
+# only variables of the form @VAR@ will be replaced, not cmake built-in 
+# substitutions.
 configure_file(arc-cargo.in ${LLVM_TOOLS_BINARY_DIR}/arc-cargo @ONLY)
 configure_file(arc-mlir-rust-test.in ${LLVM_TOOLS_BINARY_DIR}/arc-mlir-rust-test @ONLY)
 configure_file(arc.in ${LLVM_TOOLS_BINARY_DIR}/arc @ONLY)
diff --git a/arc-mlir/src/tools/arc-mlir-rust-test.in b/arc-mlir/src/tools/arc-mlir-rust-test.in
index e7e79f046..2eb18cbf2 100755
--- a/arc-mlir/src/tools/arc-mlir-rust-test.in
+++ b/arc-mlir/src/tools/arc-mlir-rust-test.in
@@ -3,10 +3,9 @@
 set -e
 
 export PATH="@ARC_TOOLS_BIN_DIR@:$PATH"
-export ARC_LANG_SOURCE_DIR="@ARC_LANG_SRC_DIR@"
-export ARC_MLIR_SOURCE_DIR="@ARC_MLIR_SRC_DIR@"
-export ARC_CODEGEN_SOURCE_DIR="@ARC_CODEGEN_SRC_DIR@"
-export ARC_RUNTIME_SOURCE_DIR="@ARC_RUNTIME_SRC_DIR@"
+export ARC_LANG_DIR="@ARC_LANG_DIR@"
+export ARC_MLIR_DIR="@ARC_MLIR_DIR@"
+export ARC_RUNTIME_DIR="@ARC_RUNTIME_DIR@"
 
 WORK_DIR="$1"
 TARGET_DIR="${WORK_DIR}.target"
@@ -17,12 +16,12 @@ MAIN="${WORK_DIR}/src/main.rs"
 TEST_NAME=$(basename ${WORK_DIR})
 TEST_NAME=${TEST_NAME//.mlir.tmp/}
 TEST_NAME=${TEST_NAME//.arc.tmp/}
-export CRATE_NAME=${TEST_NAME//-/_}
+export TEST_NAME
 
 CARGO_DEP_FRAGMENT="${MLIR_FILE%.mlir}.cargo-dep"
 echo "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
 rustc --version
-echo "Arc-lang sources are in: ${ARC_LANG_SOURCE_DIR}"
+echo "Arc-lang sources are in: ${ARC_LANG_DIR}"
 echo "Test name: ${TEST_NAME}"
 echo "MLIR input: ${MLIR_FILE}"
 echo "Crate will be written to: ${WORK_DIR}"
@@ -37,7 +36,13 @@ mkdir -p ${WORK_DIR}/src
 
 # Create the Cargo.toml
 envsubst > ${WORK_DIR}/Cargo.toml <<'EOF'
-@CARGO_TOML_TEMPLATE@
+[package]
+name = "${TEST_NAME}"
+version = "0.0.0"
+edition = "2021"
+
+[dependencies]
+runtime = { path = "${ARC_RUNTIME_DIR}" }
 EOF
 
 # Allow a test to include extra dependencies in the Cargo.toml
@@ -47,7 +52,6 @@ fi
 
 # Create dummy wrapper .rs-file which includes the generated test-case
 
-echo '#![feature(unboxed_closures)]' > ${MAIN}
 arc-mlir ${MLIR_FILE} "$@" -arc-to-rust -inline-rust >> ${MAIN}
 
 cat >> ${MAIN} <<EOF
diff --git a/arc-mlir/src/tools/arc.in b/arc-mlir/src/tools/arc.in
index 34ea9b488..cba2d17cd 100755
--- a/arc-mlir/src/tools/arc.in
+++ b/arc-mlir/src/tools/arc.in
@@ -167,33 +167,37 @@ debug "ARC_MLIR: $ARC_MLIR"
 INSTALLED_SHARED_DIR="$ROOT/../share/arc/"
 if [ -d "${INSTALLED_SHARED_DIR}" ]; then
     # Looks like we are running from the installed location
-    export ARC_RUNTIME_SOURCE_DIR="${INSTALLED_SHARED_DIR}/arc-runtime"
-    export ARC_LANG_STDLIB_PATH="${INSTALLED_SHARED_DIR}/stdlib/stdlib.arc"
-    export ARC_MLIR_STDLIB_PATH="${INSTALLED_SHARED_DIR}/stdlib/stdlib.mlir"
+    export ARC_RUNTIME_DIR="${INSTALLED_SHARED_DIR}/arc-lang/crates/runtime"
+    export ARC_LANG_STDLIB_PATH="${INSTALLED_SHARED_DIR}/stdlib/std.arc"
+    export ARC_MLIR_STDLIB_PATH="${INSTALLED_SHARED_DIR}/stdlib/std.mlir"
 else
     # We are running from the build tree
-    export ARC_RUNTIME_SOURCE_DIR="@ARC_RUNTIME_SRC_DIR@"
-    export ARC_LANG_STDLIB_PATH="@ARC_LANG_SRC_DIR@/stdlib/stdlib.arc"
-    export ARC_MLIR_STDLIB_PATH="@ARC_LANG_SRC_DIR@/stdlib/stdlib.mlir"
+    export ARC_RUNTIME_DIR="@ARC_RUNTIME_DIR@"
+    export ARC_LANG_STDLIB_PATH="@ARC_LANG_DIR@/stdlib/std.arc"
+    export ARC_MLIR_STDLIB_PATH="@ARC_LANG_DIR@/stdlib/std.mlir"
 fi
 
-debug "ARC_RUNTIME_SOURCE_DIR: $ARC_RUNTIME_SOURCE_DIR"
+debug "ARC_RUNTIME_DIR: $ARC_RUNTIME_DIR"
 debug "ARC_LANG_STDLIB_PATH: $ARC_LANG_STDLIB_PATH"
 debug "ARC_MLIR_STDLIB_PATH: $ARC_MLIR_STDLIB_PATH"
 
 mkdir -p "$CRATE_DIR/src"
 
 # Create the Cargo.toml
-envsubst > "$CRATE_TOML_FILE" <<'EOF'
-@CARGO_TOML_TEMPLATE@
+envsubst > ${WORK_DIR}/Cargo.toml <<'EOF'
+[package]
+name = "{TEST_NAME}"
+version = "0.0.0"
+edition = "2021"
+
+[dependencies]
+runtime = { path = "{RUNTIME_DIR}" }
 EOF
 
 [ "$ARC_DEBUG" ] && echo "$CRATE_TOML_FILE: " && cat "$CRATE_TOML_FILE"
 
 envsubst > "$CRATE_MAIN_FILE" <<'EOF'
 // Generated source for $INPUT_FILE
-#![feature(unboxed_closures)]
-#![feature(imported_main)]
 EOF
 
 case $INPUT_FILE in