changeset 52143:ad6384355aa3

8210215: C2 should optimize trichotomy calculations Summary: Ideal transformation to optimize trichotomic comparisons. Reviewed-by: kvn, jrose
author thartmann
date Tue, 16 Oct 2018 14:17:19 +0200
parents ca0c25e01c5b
children f53671e05660
files src/hotspot/share/opto/cfgnode.cpp src/hotspot/share/opto/cfgnode.hpp src/hotspot/share/opto/subnode.cpp src/hotspot/share/opto/subnode.hpp test/hotspot/jtreg/compiler/codegen/TestTrichotomyExpressions.java
diffstat 5 files changed, 2682 insertions(+), 2 deletions(-) [+]
line wrap: on
line diff
--- a/src/hotspot/share/opto/cfgnode.cpp	Tue Oct 16 13:18:22 2018 +0200
+++ b/src/hotspot/share/opto/cfgnode.cpp	Tue Oct 16 14:17:19 2018 +0200
@@ -714,10 +714,151 @@
     }
   }
 
+  if (can_reshape) {
+    modified |= optimize_trichotomy(phase->is_IterGVN());
+  }
+
   return modified ? this : NULL;
 }
 
-
+//------------------------------optimize_trichotomy--------------------------
+// Optimize nested comparisons of the following kind:
+//
+// int compare(int a, int b) {
+//   return (a < b) ? -1 : (a == b) ? 0 : 1;
+// }
+//
+// Shape 1:
+// if (compare(a, b) == 1) { ... } -> if (a > b) { ... }
+//
+// Shape 2:
+// if (compare(a, b) == 0) { ... } -> if (a == b) { ... }
+//
+// Above code leads to the following IR shapes where both Ifs compare the
+// same value and two out of three region inputs idx1 and idx2 map to
+// the same value and control flow.
+//
+// (1)   If                 (2)   If
+//      /  \                     /  \
+//   Proj  Proj               Proj  Proj
+//     |      \                |      \
+//     |       If              |      If                      If
+//     |      /  \             |     /  \                    /  \
+//     |   Proj  Proj          |  Proj  Proj      ==>     Proj  Proj
+//     |   /      /            \    |    /                  |    /
+//    Region     /              \   |   /                   |   /
+//         \    /                \  |  /                    |  /
+//         Region                Region                    Region
+//
+// The method returns true if 'this' is modified and false otherwise.
+bool RegionNode::optimize_trichotomy(PhaseIterGVN* igvn) {
+  int idx1 = 1, idx2 = 2;
+  Node* region = NULL;
+  if (req() == 3 && in(1) != NULL && in(2) != NULL) {
+    // Shape 1: Check if one of the inputs is a region that merges two control
+    // inputs and has no other users (especially no Phi users).
+    region = in(1)->isa_Region() ? in(1) : in(2)->isa_Region();
+    if (region == NULL || region->outcnt() != 2 || region->req() != 3) {
+      return false; // No suitable region input found
+    }
+  } else if (req() == 4) {
+    // Shape 2: Check if two control inputs map to the same value of the unique phi
+    // user and treat these as if they would come from another region (shape (1)).
+    PhiNode* phi = has_unique_phi();
+    if (phi == NULL) {
+      return false; // No unique phi user
+    }
+    if (phi->in(idx1) != phi->in(idx2)) {
+      idx2 = 3;
+      if (phi->in(idx1) != phi->in(idx2)) {
+        idx1 = 2;
+        if (phi->in(idx1) != phi->in(idx2)) {
+          return false; // No equal phi inputs found
+        }
+      }
+    }
+    assert(phi->in(idx1) == phi->in(idx2), "must be"); // Region is merging same value
+    region = this;
+  }
+  if (region == NULL || region->in(idx1) == NULL || region->in(idx2) == NULL) {
+    return false; // Region does not merge two control inputs
+  }
+  // At this point we know that region->in(idx1) and region->(idx2) map to the same
+  // value and control flow. Now search for ifs that feed into these region inputs.
+  ProjNode* proj1 = region->in(idx1)->isa_Proj();
+  ProjNode* proj2 = region->in(idx2)->isa_Proj();
+  if (proj1 == NULL || proj1->outcnt() != 1 ||
+      proj2 == NULL || proj2->outcnt() != 1) {
+    return false; // No projection inputs with region as unique user found
+  }
+  assert(proj1 != proj2, "should be different projections");
+  IfNode* iff1 = proj1->in(0)->isa_If();
+  IfNode* iff2 = proj2->in(0)->isa_If();
+  if (iff1 == NULL || iff1->outcnt() != 2 ||
+      iff2 == NULL || iff2->outcnt() != 2) {
+    return false; // No ifs found
+  }
+  if (iff1 == iff2) {
+    igvn->add_users_to_worklist(iff1); // Make sure dead if is eliminated
+    igvn->replace_input_of(region, idx1, iff1->in(0));
+    igvn->replace_input_of(region, idx2, igvn->C->top());
+    return (region == this); // Remove useless if (both projections map to the same control/value)
+  }
+  BoolNode* bol1 = iff1->in(1)->isa_Bool();
+  BoolNode* bol2 = iff2->in(1)->isa_Bool();
+  if (bol1 == NULL || bol2 == NULL) {
+    return false; // No bool inputs found
+  }
+  Node* cmp1 = bol1->in(1);
+  Node* cmp2 = bol2->in(1);
+  bool commute = false;
+  if (!cmp1->is_Cmp() || !cmp2->is_Cmp()) {
+    return false; // No comparison
+  } else if (cmp1->Opcode() == Op_CmpF || cmp1->Opcode() == Op_CmpD ||
+             cmp2->Opcode() == Op_CmpF || cmp2->Opcode() == Op_CmpD ||
+             cmp1->Opcode() == Op_CmpP || cmp1->Opcode() == Op_CmpN ||
+             cmp2->Opcode() == Op_CmpP || cmp2->Opcode() == Op_CmpN) {
+    // Floats and pointers don't exactly obey trichotomy. To be on the safe side, don't transform their tests.
+    return false;
+  } else if (cmp1 != cmp2) {
+    if (cmp1->in(1) == cmp2->in(2) &&
+        cmp1->in(2) == cmp2->in(1)) {
+      commute = true; // Same but swapped inputs, commute the test
+    } else {
+      return false; // Ifs are not comparing the same values
+    }
+  }
+  proj1 = proj1->other_if_proj();
+  proj2 = proj2->other_if_proj();
+  if (!((proj1->unique_ctrl_out() == iff2 &&
+         proj2->unique_ctrl_out() == this) ||
+        (proj2->unique_ctrl_out() == iff1 &&
+         proj1->unique_ctrl_out() == this))) {
+    return false; // Ifs are not connected through other projs
+  }
+  // Found 'iff -> proj -> iff -> proj -> this' shape where all other projs are merged
+  // through 'region' and map to the same value. Merge the boolean tests and replace
+  // the ifs by a single comparison.
+  BoolTest test1 = (proj1->_con == 1) ? bol1->_test : bol1->_test.negate();
+  BoolTest test2 = (proj2->_con == 1) ? bol2->_test : bol2->_test.negate();
+  test1 = commute ? test1.commute() : test1;
+  // After possibly commuting test1, if we can merge test1 & test2, then proj2/iff2/bol2 are the nodes to refine.
+  BoolTest::mask res = test1.merge(test2);
+  if (res == BoolTest::illegal) {
+    return false; // Unable to merge tests
+  }
+  // Adjust iff1 to always pass (only iff2 will remain)
+  igvn->replace_input_of(iff1, 1, igvn->intcon(proj1->_con));
+  if (res == BoolTest::never) {
+    // Merged test is always false, adjust iff2 to always fail
+    igvn->replace_input_of(iff2, 1, igvn->intcon(1 - proj2->_con));
+  } else {
+    // Replace bool input of iff2 with merged test
+    BoolNode* new_bol = new BoolNode(bol2->in(1), res);
+    igvn->replace_input_of(iff2, 1, igvn->transform((proj2->_con == 1) ? new_bol : new_bol->negate(igvn)));
+  }
+  return false;
+}
 
 const RegMask &RegionNode::out_RegMask() const {
   return RegMask::Empty;
--- a/src/hotspot/share/opto/cfgnode.hpp	Tue Oct 16 13:18:22 2018 +0200
+++ b/src/hotspot/share/opto/cfgnode.hpp	Tue Oct 16 14:17:19 2018 +0200
@@ -96,6 +96,7 @@
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
   virtual const RegMask &out_RegMask() const;
   bool try_clean_mem_phi(PhaseGVN *phase);
+  bool optimize_trichotomy(PhaseIterGVN* igvn);
 };
 
 //------------------------------JProjNode--------------------------------------
--- a/src/hotspot/share/opto/subnode.cpp	Tue Oct 16 13:18:22 2018 +0200
+++ b/src/hotspot/share/opto/subnode.cpp	Tue Oct 16 14:17:19 2018 +0200
@@ -1252,6 +1252,24 @@
   st->print("%s", msg[_test]);
 }
 
+// Returns the logical AND of two tests (or 'never' if both tests can never be true).
+// For example, a test for 'le' followed by a test for 'lt' is equivalent with 'lt'.
+BoolTest::mask BoolTest::merge(BoolTest other) const {
+  const mask res[illegal+1][illegal+1] = {
+    // eq,      gt,      of,      lt,      ne,      le,      nof,     ge,      never,   illegal
+      {eq,      never,   illegal, never,   never,   eq,      illegal, eq,      never,   illegal},  // eq
+      {never,   gt,      illegal, never,   gt,      never,   illegal, gt,      never,   illegal},  // gt
+      {illegal, illegal, illegal, illegal, illegal, illegal, illegal, illegal, never,   illegal},  // of
+      {never,   never,   illegal, lt,      lt,      lt,      illegal, never,   never,   illegal},  // lt
+      {never,   gt,      illegal, lt,      ne,      lt,      illegal, gt,      never,   illegal},  // ne
+      {eq,      never,   illegal, lt,      lt,      le,      illegal, eq,      never,   illegal},  // le
+      {illegal, illegal, illegal, illegal, illegal, illegal, illegal, illegal, never,   illegal},  // nof
+      {eq,      gt,      illegal, never,   gt,      eq,      illegal, ge,      never,   illegal},  // ge
+      {never,   never,   never,   never,   never,   never,   never,   never,   never,   illegal},  // never
+      {illegal, illegal, illegal, illegal, illegal, illegal, illegal, illegal, illegal, illegal}}; // illegal
+  return res[_test][other._test];
+}
+
 //=============================================================================
 uint BoolNode::hash() const { return (Node::hash() << 3)|(_test._test+1); }
 uint BoolNode::size_of() const { return sizeof(BoolNode); }
--- a/src/hotspot/share/opto/subnode.hpp	Tue Oct 16 13:18:22 2018 +0200
+++ b/src/hotspot/share/opto/subnode.hpp	Tue Oct 16 14:17:19 2018 +0200
@@ -280,7 +280,7 @@
 // We pick the values as 3 bits; the low order 2 bits we compare against the
 // condition codes, the high bit flips the sense of the result.
 struct BoolTest {
-  enum mask { eq = 0, ne = 4, le = 5, ge = 7, lt = 3, gt = 1, overflow = 2, no_overflow = 6, illegal = 8 };
+  enum mask { eq = 0, ne = 4, le = 5, ge = 7, lt = 3, gt = 1, overflow = 2, no_overflow = 6, never = 8, illegal = 9 };
   mask _test;
   BoolTest( mask btm ) : _test(btm) {}
   const Type *cc2logical( const Type *CC ) const;
@@ -293,6 +293,7 @@
   bool is_less( )  const { return _test == BoolTest::lt || _test == BoolTest::le; }
   bool is_greater( ) const { return _test == BoolTest::gt || _test == BoolTest::ge; }
   void dump_on(outputStream *st) const;
+  mask merge(BoolTest other) const;
 };
 
 //------------------------------BoolNode---------------------------------------
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/hotspot/jtreg/compiler/codegen/TestTrichotomyExpressions.java	Tue Oct 16 14:17:19 2018 +0200
@@ -0,0 +1,2519 @@
+/*
+ * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/**
+ * @test
+ * @bug 8210215
+ * @summary Test that C2 correctly optimizes trichotomy expressions.
+ * @library /test/lib
+ * @run main/othervm -XX:-TieredCompilation -Xbatch
+ *                   -XX:CompileCommand=dontinline,compiler.codegen.TestTrichotomyExpressions::test*
+ *                   compiler.codegen.TestTrichotomyExpressions
+ * @run main/othervm -XX:-TieredCompilation -Xcomp
+ *                   -XX:CompileCommand=dontinline,compiler.codegen.TestTrichotomyExpressions::test*
+ *                   compiler.codegen.TestTrichotomyExpressions
+ */
+
+package compiler.codegen;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.reflect.Method;
+import java.util.Random;
+
+import jdk.test.lib.Asserts;
+import jdk.test.lib.Utils;
+
+enum Operation { SMALLER, SMALLER_EQUAL, EQUAL, GREATER_EQUAL, GREATER, ALWAYS_FALSE }
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.METHOD)
+@interface Test {
+    Operation op();
+}
+
+public class TestTrichotomyExpressions {
+
+    public static int compare1(int a, int b) {
+        return (a < b) ? -1 : (a == b) ? 0 : 1;
+    }
+
+    public static int compare2(int a, int b) {
+        return (a < b) ? -1 : (a <= b) ? 0 : 1;
+    }
+
+    public static int compare3(int a, int b) {
+        return (a < b) ? -1 : (a > b) ? 1 : 0;
+    }
+
+    public static int compare4(int a, int b) {
+        return (a < b) ? -1 : (a != b) ? 1 : 0;
+    }
+
+    public static int compare5(int a, int b) {
+        return (a > b) ? 1 : (a < b) ? -1 : 0;
+    }
+
+    public static int compare6(int a, int b) {
+        return (a > b) ? 1 : (a == b) ? 0 : -1;
+    }
+
+    public static int compare7(int a, int b) {
+        return (a > b) ? 1 : (a >= b) ? 0 : -1;
+    }
+
+    public static int compare8(int a, int b) {
+        return (a > b) ? 1 : (a != b) ? -1 : 0;
+    }
+
+    public static int compare9(int a, int b) {
+        return (a == b) ? 0 : (a < b) ? -1 : 1;
+    }
+
+    public static int compare10(int a, int b) {
+        return (a == b) ? 0 : (a <= b) ? -1 : 1;
+    }
+
+    public static int compare11(int a, int b) {
+        return (a == b) ? 0 : (a > b) ? 1 : -1;
+    }
+
+    public static int compare12(int a, int b) {
+        return (a == b) ? 0 : (a >= b) ? 1 : -1;
+    }
+
+    public static int compare13(int a, int b) {
+        return (a <= b) ? ((a == b) ? 0 : -1) : 1;
+    }
+
+    public static int compare14(int a, int b) {
+        return (a <= b) ? ((a < b) ? -1 : 0) : 1;
+    }
+
+    public static int compare15(int a, int b) {
+        return (a <= b) ? ((a >= b) ? 0 : -1) : 1;
+    }
+
+    public static int compare16(int a, int b) {
+        return (a <= b) ? ((a != b) ? -1 : 0) : 1;
+    }
+
+    public static int compare17(int a, int b) {
+        return (a >= b) ? ((a <= b) ? 0 : 1) : -1;
+    }
+
+    public static int compare18(int a, int b) {
+        return (a >= b) ? ((a == b) ? 0 : 1) : -1;
+    }
+
+    public static int compare19(int a, int b) {
+        return (a >= b) ? ((a > b) ? 1 : 0) : -1;
+    }
+
+    public static int compare20(int a, int b) {
+        return (a >= b) ? ((a != b) ? 1 : 0) : -1;
+    }
+
+    public static int compare21(int a, int b) {
+        return (a != b) ? ((a < b) ? -1 : 1) : 0;
+    }
+
+    public static int compare22(int a, int b) {
+        return (a != b) ? ((a <= b) ? -1 : 1) : 0;
+    }
+
+    public static int compare23(int a, int b) {
+        return (a != b) ? ((a > b) ? 1 : -1) : 0;
+    }
+
+    public static int compare24(int a, int b) {
+        return (a != b) ? ((a >= b) ? 1 : -1) : 0;
+    }
+
+    public static int compare25(int a, int b) {
+        return (a < b) ? -1 : (b == a) ? 0 : 1;
+    }
+
+    public static int compare26(int a, int b) {
+        return (a < b) ? -1 : (b >= a) ? 0 : 1;
+    }
+
+    public static int compare27(int a, int b) {
+        return (a < b) ? -1 : (b < a) ? 1 : 0;
+    }
+
+    public static int compare28(int a, int b) {
+        return (a < b) ? -1 : (b != a) ? 1 : 0;
+    }
+
+    public static int compare29(int a, int b) {
+        return (a > b) ? 1 : (b > a) ? -1 : 0;
+    }
+
+    public static int compare30(int a, int b) {
+        return (a > b) ? 1 : (b == a) ? 0 : -1;
+    }
+
+    public static int compare31(int a, int b) {
+        return (a > b) ? 1 : (b <= a) ? 0 : -1;
+    }
+
+    public static int compare32(int a, int b) {
+        return (a > b) ? 1 : (b != a) ? -1 : 0;
+    }
+
+    public static int compare33(int a, int b) {
+        return (a == b) ? 0 : (b > a) ? -1 : 1;
+    }
+
+    public static int compare34(int a, int b) {
+        return (a == b) ? 0 : (b >= a) ? -1 : 1;
+    }
+
+    public static int compare35(int a, int b) {
+        return (a == b) ? 0 : (b < a) ? 1 : -1;
+    }
+
+    public static int compare36(int a, int b) {
+        return (a == b) ? 0 : (b <= a) ? 1 : -1;
+    }
+
+    public static int compare37(int a, int b) {
+        return (a <= b) ? ((b == a) ? 0 : -1) : 1;
+    }
+
+    public static int compare38(int a, int b) {
+        return (a <= b) ? ((b > a) ? -1 : 0) : 1;
+    }
+
+    public static int compare39(int a, int b) {
+        return (a <= b) ? ((b <= a) ? 0 : -1) : 1;
+    }
+
+    public static int compare40(int a, int b) {
+        return (a <= b) ? ((b != a) ? -1 : 0) : 1;
+    }
+
+    public static int compare41(int a, int b) {
+        return (a >= b) ? ((b >= a) ? 0 : 1) : -1;
+    }
+
+    public static int compare42(int a, int b) {
+        return (a >= b) ? ((b == a) ? 0 : 1) : -1;
+    }
+
+    public static int compare43(int a, int b) {
+        return (a >= b) ? ((b < a) ? 1 : 0) : -1;
+    }
+
+    public static int compare44(int a, int b) {
+        return (a >= b) ? ((b != a) ? 1 : 0) : -1;
+    }
+
+    public static int compare45(int a, int b) {
+        return (a != b) ? ((b > a) ? -1 : 1) : 0;
+    }
+
+    public static int compare46(int a, int b) {
+        return (a != b) ? ((b >= a) ? -1 : 1) : 0;
+    }
+
+    public static int compare47(int a, int b) {
+        return (a != b) ? ((b < a) ? 1 : -1) : 0;
+    }
+
+    public static int compare48(int a, int b) {
+        return (a != b) ? ((b <= a) ? 1 : -1) : 0;
+    }
+
+
+    public static int compareAlwaysFalse1(int a, int b) {
+        return (a >= b) ? 1 : (a > b) ? 2 : -1;
+    }
+
+    public static int compareAlwaysFalse2(int a, int b) {
+        return (a <= b) ? 1 : (a < b) ? 2 : -1;
+    }
+
+    public static int compareAlwaysFalse3(int a, int b) {
+        return (a == b) ? 1 : (a == b) ? 2 : -1;
+    }
+
+    public static int compareAlwaysFalse4(int a, int b) {
+        return (a != b) ? 1 : (a < b) ? 2 : -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller1(int a, int b) {
+        return compare1(a, b) == -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller2(int a, int b) {
+        return compare1(a, b) < 0;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller3(int a, int b) {
+        return compare1(a, b) <= -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller4(int a, int b) {
+        return compare2(a, b) == -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller5(int a, int b) {
+        return compare2(a, b) < 0;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller6(int a, int b) {
+        return compare2(a, b) <= -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller7(int a, int b) {
+        return compare3(a, b) == -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller8(int a, int b) {
+        return compare3(a, b) < 0;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller9(int a, int b) {
+        return compare3(a, b) <= -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller10(int a, int b) {
+        return compare4(a, b) == -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller11(int a, int b) {
+        return compare4(a, b) < 0;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller12(int a, int b) {
+        return compare4(a, b) <= -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller13(int a, int b) {
+        return compare5(a, b) == -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller14(int a, int b) {
+        return compare5(a, b) < 0;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller15(int a, int b) {
+        return compare5(a, b) <= -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller16(int a, int b) {
+        return compare6(a, b) == -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller17(int a, int b) {
+        return compare6(a, b) < 0;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller18(int a, int b) {
+        return compare6(a, b) <= -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller19(int a, int b) {
+        return compare7(a, b) == -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller20(int a, int b) {
+        return compare7(a, b) < 0;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller21(int a, int b) {
+        return compare7(a, b) <= -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller22(int a, int b) {
+        return compare8(a, b) == -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller23(int a, int b) {
+        return compare8(a, b) < 0;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller24(int a, int b) {
+        return compare8(a, b) <= -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller25(int a, int b) {
+        return compare9(a, b) == -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller26(int a, int b) {
+        return compare9(a, b) < 0;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller27(int a, int b) {
+        return compare9(a, b) <= -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller28(int a, int b) {
+        return compare10(a, b) == -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller29(int a, int b) {
+        return compare10(a, b) < 0;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller30(int a, int b) {
+        return compare10(a, b) <= -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller31(int a, int b) {
+        return compare11(a, b) == -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller32(int a, int b) {
+        return compare11(a, b) < 0;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller33(int a, int b) {
+        return compare11(a, b) <= -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller34(int a, int b) {
+        return compare12(a, b) == -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller35(int a, int b) {
+        return compare12(a, b) < 0;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller36(int a, int b) {
+        return compare12(a, b) <= -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller37(int a, int b) {
+        return compare13(a, b) == -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller38(int a, int b) {
+        return compare13(a, b) < 0;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller39(int a, int b) {
+        return compare13(a, b) <= -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller40(int a, int b) {
+        return compare14(a, b) == -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller41(int a, int b) {
+        return compare14(a, b) < 0;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller42(int a, int b) {
+        return compare14(a, b) <= -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller43(int a, int b) {
+        return compare15(a, b) == -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller44(int a, int b) {
+        return compare15(a, b) < 0;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller45(int a, int b) {
+        return compare15(a, b) <= -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller46(int a, int b) {
+        return compare16(a, b) == -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller47(int a, int b) {
+        return compare16(a, b) < 0;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller48(int a, int b) {
+        return compare16(a, b) <= -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller49(int a, int b) {
+        return compare17(a, b) == -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller50(int a, int b) {
+        return compare17(a, b) < 0;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller51(int a, int b) {
+        return compare17(a, b) <= -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller52(int a, int b) {
+        return compare18(a, b) == -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller53(int a, int b) {
+        return compare18(a, b) < 0;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller54(int a, int b) {
+        return compare18(a, b) <= -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller55(int a, int b) {
+        return compare19(a, b) == -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller56(int a, int b) {
+        return compare19(a, b) < 0;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller57(int a, int b) {
+        return compare19(a, b) <= -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller58(int a, int b) {
+        return compare20(a, b) == -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller59(int a, int b) {
+        return compare20(a, b) < 0;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller60(int a, int b) {
+        return compare20(a, b) <= -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller61(int a, int b) {
+        return compare21(a, b) == -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller62(int a, int b) {
+        return compare21(a, b) < 0;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller63(int a, int b) {
+        return compare21(a, b) <= -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller64(int a, int b) {
+        return compare22(a, b) == -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller65(int a, int b) {
+        return compare22(a, b) < 0;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller66(int a, int b) {
+        return compare22(a, b) <= -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller67(int a, int b) {
+        return compare23(a, b) == -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller68(int a, int b) {
+        return compare23(a, b) < 0;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller69(int a, int b) {
+        return compare23(a, b) <= -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller70(int a, int b) {
+        return compare24(a, b) == -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller71(int a, int b) {
+        return compare24(a, b) < 0;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller72(int a, int b) {
+        return compare24(a, b) <= -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller73(int a, int b) {
+        return compare25(a, b) == -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller74(int a, int b) {
+        return compare25(a, b) < 0;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller75(int a, int b) {
+        return compare25(a, b) <= -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller76(int a, int b) {
+        return compare26(a, b) == -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller77(int a, int b) {
+        return compare26(a, b) < 0;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller78(int a, int b) {
+        return compare26(a, b) <= -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller79(int a, int b) {
+        return compare27(a, b) == -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller80(int a, int b) {
+        return compare27(a, b) < 0;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller81(int a, int b) {
+        return compare27(a, b) <= -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller82(int a, int b) {
+        return compare28(a, b) == -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller83(int a, int b) {
+        return compare28(a, b) < 0;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller84(int a, int b) {
+        return compare28(a, b) <= -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller85(int a, int b) {
+        return compare29(a, b) == -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller86(int a, int b) {
+        return compare29(a, b) < 0;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller87(int a, int b) {
+        return compare29(a, b) <= -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller88(int a, int b) {
+        return compare30(a, b) == -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller89(int a, int b) {
+        return compare30(a, b) < 0;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller90(int a, int b) {
+        return compare30(a, b) <= -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller91(int a, int b) {
+        return compare31(a, b) == -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller92(int a, int b) {
+        return compare31(a, b) < 0;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller93(int a, int b) {
+        return compare31(a, b) <= -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller94(int a, int b) {
+        return compare32(a, b) == -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller95(int a, int b) {
+        return compare32(a, b) < 0;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller96(int a, int b) {
+        return compare32(a, b) <= -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller97(int a, int b) {
+        return compare33(a, b) == -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller98(int a, int b) {
+        return compare33(a, b) < 0;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller99(int a, int b) {
+        return compare33(a, b) <= -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller100(int a, int b) {
+        return compare34(a, b) == -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller101(int a, int b) {
+        return compare34(a, b) < 0;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller102(int a, int b) {
+        return compare34(a, b) <= -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller103(int a, int b) {
+        return compare35(a, b) == -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller104(int a, int b) {
+        return compare35(a, b) < 0;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller105(int a, int b) {
+        return compare35(a, b) <= -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller106(int a, int b) {
+        return compare36(a, b) == -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller107(int a, int b) {
+        return compare36(a, b) < 0;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller108(int a, int b) {
+        return compare36(a, b) <= -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller109(int a, int b) {
+        return compare37(a, b) == -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller110(int a, int b) {
+        return compare37(a, b) < 0;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller111(int a, int b) {
+        return compare37(a, b) <= -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller112(int a, int b) {
+        return compare38(a, b) == -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller113(int a, int b) {
+        return compare38(a, b) < 0;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller114(int a, int b) {
+        return compare38(a, b) <= -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller115(int a, int b) {
+        return compare39(a, b) == -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller116(int a, int b) {
+        return compare39(a, b) < 0;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller117(int a, int b) {
+        return compare39(a, b) <= -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller118(int a, int b) {
+        return compare40(a, b) == -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller119(int a, int b) {
+        return compare40(a, b) < 0;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller120(int a, int b) {
+        return compare40(a, b) <= -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller121(int a, int b) {
+        return compare41(a, b) == -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller122(int a, int b) {
+        return compare41(a, b) < 0;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller123(int a, int b) {
+        return compare41(a, b) <= -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller124(int a, int b) {
+        return compare42(a, b) == -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller125(int a, int b) {
+        return compare42(a, b) < 0;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller126(int a, int b) {
+        return compare42(a, b) <= -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller127(int a, int b) {
+        return compare43(a, b) == -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller128(int a, int b) {
+        return compare43(a, b) < 0;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller129(int a, int b) {
+        return compare43(a, b) <= -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller130(int a, int b) {
+        return compare44(a, b) == -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller131(int a, int b) {
+        return compare44(a, b) < 0;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller132(int a, int b) {
+        return compare44(a, b) <= -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller133(int a, int b) {
+        return compare45(a, b) == -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller134(int a, int b) {
+        return compare45(a, b) < 0;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller135(int a, int b) {
+        return compare45(a, b) <= -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller136(int a, int b) {
+        return compare46(a, b) == -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller137(int a, int b) {
+        return compare46(a, b) < 0;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller138(int a, int b) {
+        return compare46(a, b) <= -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller139(int a, int b) {
+        return compare47(a, b) == -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller140(int a, int b) {
+        return compare47(a, b) < 0;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller141(int a, int b) {
+        return compare47(a, b) <= -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller142(int a, int b) {
+        return compare48(a, b) == -1;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller143(int a, int b) {
+        return compare48(a, b) < 0;
+    }
+
+    @Test(op = Operation.SMALLER)
+    public static boolean testSmaller144(int a, int b) {
+        return compare48(a, b) <= -1;
+    }
+
+
+    @Test(op = Operation.SMALLER_EQUAL)
+    public static boolean testSmallerEqual1(int a, int b) {
+        return compare1(a, b) <= 0;
+    }
+
+    @Test(op = Operation.SMALLER_EQUAL)
+    public static boolean testSmallerEqual2(int a, int b) {
+        return compare2(a, b) <= 0;
+    }
+
+    @Test(op = Operation.SMALLER_EQUAL)
+    public static boolean testSmallerEqual3(int a, int b) {
+        return compare3(a, b) <= 0;
+    }
+
+    @Test(op = Operation.SMALLER_EQUAL)
+    public static boolean testSmallerEqual4(int a, int b) {
+        return compare4(a, b) <= 0;
+    }
+
+    @Test(op = Operation.SMALLER_EQUAL)
+    public static boolean testSmallerEqual5(int a, int b) {
+        return compare5(a, b) <= 0;
+    }
+
+    @Test(op = Operation.SMALLER_EQUAL)
+    public static boolean testSmallerEqual6(int a, int b) {
+        return compare6(a, b) <= 0;
+    }
+
+    @Test(op = Operation.SMALLER_EQUAL)
+    public static boolean testSmallerEqual7(int a, int b) {
+        return compare7(a, b) <= 0;
+    }
+
+    @Test(op = Operation.SMALLER_EQUAL)
+    public static boolean testSmallerEqual8(int a, int b) {
+        return compare8(a, b) <= 0;
+    }
+
+    @Test(op = Operation.SMALLER_EQUAL)
+    public static boolean testSmallerEqual9(int a, int b) {
+        return compare9(a, b) <= 0;
+    }
+
+    @Test(op = Operation.SMALLER_EQUAL)
+    public static boolean testSmallerEqual10(int a, int b) {
+        return compare10(a, b) <= 0;
+    }
+
+    @Test(op = Operation.SMALLER_EQUAL)
+    public static boolean testSmallerEqual11(int a, int b) {
+        return compare11(a, b) <= 0;
+    }
+
+    @Test(op = Operation.SMALLER_EQUAL)
+    public static boolean testSmallerEqual12(int a, int b) {
+        return compare12(a, b) <= 0;
+    }
+
+    @Test(op = Operation.SMALLER_EQUAL)
+    public static boolean testSmallerEqual13(int a, int b) {
+        return compare13(a, b) <= 0;
+    }
+
+    @Test(op = Operation.SMALLER_EQUAL)
+    public static boolean testSmallerEqual14(int a, int b) {
+        return compare14(a, b) <= 0;
+    }
+
+    @Test(op = Operation.SMALLER_EQUAL)
+    public static boolean testSmallerEqual15(int a, int b) {
+        return compare15(a, b) <= 0;
+    }
+
+    @Test(op = Operation.SMALLER_EQUAL)
+    public static boolean testSmallerEqual16(int a, int b) {
+        return compare16(a, b) <= 0;
+    }
+
+    @Test(op = Operation.SMALLER_EQUAL)
+    public static boolean testSmallerEqual17(int a, int b) {
+        return compare17(a, b) <= 0;
+    }
+
+    @Test(op = Operation.SMALLER_EQUAL)
+    public static boolean testSmallerEqual18(int a, int b) {
+        return compare18(a, b) <= 0;
+    }
+
+    @Test(op = Operation.SMALLER_EQUAL)
+    public static boolean testSmallerEqual19(int a, int b) {
+        return compare19(a, b) <= 0;
+    }
+
+    @Test(op = Operation.SMALLER_EQUAL)
+    public static boolean testSmallerEqual20(int a, int b) {
+        return compare20(a, b) <= 0;
+    }
+
+    @Test(op = Operation.SMALLER_EQUAL)
+    public static boolean testSmallerEqual21(int a, int b) {
+        return compare21(a, b) <= 0;
+    }
+
+    @Test(op = Operation.SMALLER_EQUAL)
+    public static boolean testSmallerEqual22(int a, int b) {
+        return compare22(a, b) <= 0;
+    }
+
+    @Test(op = Operation.SMALLER_EQUAL)
+    public static boolean testSmallerEqual23(int a, int b) {
+        return compare23(a, b) <= 0;
+    }
+
+    @Test(op = Operation.SMALLER_EQUAL)
+    public static boolean testSmallerEqual24(int a, int b) {
+        return compare24(a, b) <= 0;
+    }
+
+    @Test(op = Operation.SMALLER_EQUAL)
+    public static boolean testSmallerEqual25(int a, int b) {
+        return compare2(a, b) <= 0;
+    }
+
+    @Test(op = Operation.SMALLER_EQUAL)
+    public static boolean testSmallerEqual26(int a, int b) {
+        return compare26(a, b) <= 0;
+    }
+
+    @Test(op = Operation.SMALLER_EQUAL)
+    public static boolean testSmallerEqual27(int a, int b) {
+        return compare27(a, b) <= 0;
+    }
+
+    @Test(op = Operation.SMALLER_EQUAL)
+    public static boolean testSmallerEqual28(int a, int b) {
+        return compare28(a, b) <= 0;
+    }
+
+    @Test(op = Operation.SMALLER_EQUAL)
+    public static boolean testSmallerEqual29(int a, int b) {
+        return compare29(a, b) <= 0;
+    }
+
+    @Test(op = Operation.SMALLER_EQUAL)
+    public static boolean testSmallerEqual30(int a, int b) {
+        return compare30(a, b) <= 0;
+    }
+
+    @Test(op = Operation.SMALLER_EQUAL)
+    public static boolean testSmallerEqual31(int a, int b) {
+        return compare31(a, b) <= 0;
+    }
+
+    @Test(op = Operation.SMALLER_EQUAL)
+    public static boolean testSmallerEqual32(int a, int b) {
+        return compare32(a, b) <= 0;
+    }
+
+    @Test(op = Operation.SMALLER_EQUAL)
+    public static boolean testSmallerEqual33(int a, int b) {
+        return compare33(a, b) <= 0;
+    }
+
+    @Test(op = Operation.SMALLER_EQUAL)
+    public static boolean testSmallerEqual34(int a, int b) {
+        return compare34(a, b) <= 0;
+    }
+
+    @Test(op = Operation.SMALLER_EQUAL)
+    public static boolean testSmallerEqual35(int a, int b) {
+        return compare35(a, b) <= 0;
+    }
+
+    @Test(op = Operation.SMALLER_EQUAL)
+    public static boolean testSmallerEqual36(int a, int b) {
+        return compare36(a, b) <= 0;
+    }
+
+    @Test(op = Operation.SMALLER_EQUAL)
+    public static boolean testSmallerEqual37(int a, int b) {
+        return compare37(a, b) <= 0;
+    }
+
+    @Test(op = Operation.SMALLER_EQUAL)
+    public static boolean testSmallerEqual38(int a, int b) {
+        return compare38(a, b) <= 0;
+    }
+
+    @Test(op = Operation.SMALLER_EQUAL)
+    public static boolean testSmallerEqual39(int a, int b) {
+        return compare39(a, b) <= 0;
+    }
+
+    @Test(op = Operation.SMALLER_EQUAL)
+    public static boolean testSmallerEqual40(int a, int b) {
+        return compare40(a, b) <= 0;
+    }
+
+    @Test(op = Operation.SMALLER_EQUAL)
+    public static boolean testSmallerEqual41(int a, int b) {
+        return compare41(a, b) <= 0;
+    }
+
+    @Test(op = Operation.SMALLER_EQUAL)
+    public static boolean testSmallerEqual42(int a, int b) {
+        return compare42(a, b) <= 0;
+    }
+
+    @Test(op = Operation.SMALLER_EQUAL)
+    public static boolean testSmallerEqual43(int a, int b) {
+        return compare43(a, b) <= 0;
+    }
+
+    @Test(op = Operation.SMALLER_EQUAL)
+    public static boolean testSmallerEqual44(int a, int b) {
+        return compare44(a, b) <= 0;
+    }
+
+    @Test(op = Operation.SMALLER_EQUAL)
+    public static boolean testSmallerEqual45(int a, int b) {
+        return compare45(a, b) <= 0;
+    }
+
+    @Test(op = Operation.SMALLER_EQUAL)
+    public static boolean testSmallerEqual46(int a, int b) {
+        return compare46(a, b) <= 0;
+    }
+
+    @Test(op = Operation.SMALLER_EQUAL)
+    public static boolean testSmallerEqual47(int a, int b) {
+        return compare47(a, b) <= 0;
+    }
+
+    @Test(op = Operation.SMALLER_EQUAL)
+    public static boolean testSmallerEqual48(int a, int b) {
+        return compare48(a, b) <= 0;
+    }
+
+
+    @Test(op = Operation.EQUAL)
+    public static boolean testEqual1(int a, int b) {
+        return compare1(a, b) == 0;
+    }
+
+    @Test(op = Operation.EQUAL)
+    public static boolean testEqual2(int a, int b) {
+        return compare2(a, b) == 0;
+    }
+
+    @Test(op = Operation.EQUAL)
+    public static boolean testEqual3(int a, int b) {
+        return compare3(a, b) == 0;
+    }
+
+    @Test(op = Operation.EQUAL)
+    public static boolean testEqual4(int a, int b) {
+        return compare4(a, b) == 0;
+    }
+
+    @Test(op = Operation.EQUAL)
+    public static boolean testEqual5(int a, int b) {
+        return compare5(a, b) == 0;
+    }
+
+    @Test(op = Operation.EQUAL)
+    public static boolean testEqual6(int a, int b) {
+        return compare6(a, b) == 0;
+    }
+
+    @Test(op = Operation.EQUAL)
+    public static boolean testEqual7(int a, int b) {
+        return compare7(a, b) == 0;
+    }
+
+    @Test(op = Operation.EQUAL)
+    public static boolean testEqual8(int a, int b) {
+        return compare8(a, b) == 0;
+    }
+
+    @Test(op = Operation.EQUAL)
+    public static boolean testEqual9(int a, int b) {
+        return compare9(a, b) == 0;
+    }
+
+    @Test(op = Operation.EQUAL)
+    public static boolean testEqual10(int a, int b) {
+        return compare10(a, b) == 0;
+    }
+
+    @Test(op = Operation.EQUAL)
+    public static boolean testEqual11(int a, int b) {
+        return compare11(a, b) == 0;
+    }
+
+    @Test(op = Operation.EQUAL)
+    public static boolean testEqual12(int a, int b) {
+        return compare12(a, b) == 0;
+    }
+
+    @Test(op = Operation.EQUAL)
+    public static boolean testEqual13(int a, int b) {
+        return compare13(a, b) == 0;
+    }
+
+    @Test(op = Operation.EQUAL)
+    public static boolean testEqual14(int a, int b) {
+        return compare14(a, b) == 0;
+    }
+
+    @Test(op = Operation.EQUAL)
+    public static boolean testEqual15(int a, int b) {
+        return compare15(a, b) == 0;
+    }
+
+    @Test(op = Operation.EQUAL)
+    public static boolean testEqual16(int a, int b) {
+        return compare16(a, b) == 0;
+    }
+
+    @Test(op = Operation.EQUAL)
+    public static boolean testEqual17(int a, int b) {
+        return compare17(a, b) == 0;
+    }
+
+    @Test(op = Operation.EQUAL)
+    public static boolean testEqual18(int a, int b) {
+        return compare18(a, b) == 0;
+    }
+
+    @Test(op = Operation.EQUAL)
+    public static boolean testEqual19(int a, int b) {
+        return compare19(a, b) == 0;
+    }
+
+    @Test(op = Operation.EQUAL)
+    public static boolean testEqual20(int a, int b) {
+        return compare20(a, b) == 0;
+    }
+
+    @Test(op = Operation.EQUAL)
+    public static boolean testEqual21(int a, int b) {
+        return compare21(a, b) == 0;
+    }
+
+    @Test(op = Operation.EQUAL)
+    public static boolean testEqual22(int a, int b) {
+        return compare22(a, b) == 0;
+    }
+
+    @Test(op = Operation.EQUAL)
+    public static boolean testEqual23(int a, int b) {
+        return compare23(a, b) == 0;
+    }
+
+    @Test(op = Operation.EQUAL)
+    public static boolean testEqual24(int a, int b) {
+        return compare24(a, b) == 0;
+    }
+
+    @Test(op = Operation.EQUAL)
+    public static boolean testEqual25(int a, int b) {
+        return compare25(a, b) == 0;
+    }
+
+    @Test(op = Operation.EQUAL)
+    public static boolean testEqual26(int a, int b) {
+        return compare26(a, b) == 0;
+    }
+
+    @Test(op = Operation.EQUAL)
+    public static boolean testEqual27(int a, int b) {
+        return compare27(a, b) == 0;
+    }
+
+    @Test(op = Operation.EQUAL)
+    public static boolean testEqual28(int a, int b) {
+        return compare28(a, b) == 0;
+    }
+
+    @Test(op = Operation.EQUAL)
+    public static boolean testEqual29(int a, int b) {
+        return compare29(a, b) == 0;
+    }
+
+    @Test(op = Operation.EQUAL)
+    public static boolean testEqual30(int a, int b) {
+        return compare30(a, b) == 0;
+    }
+
+    @Test(op = Operation.EQUAL)
+    public static boolean testEqual31(int a, int b) {
+        return compare31(a, b) == 0;
+    }
+
+    @Test(op = Operation.EQUAL)
+    public static boolean testEqual32(int a, int b) {
+        return compare32(a, b) == 0;
+    }
+
+    @Test(op = Operation.EQUAL)
+    public static boolean testEqual33(int a, int b) {
+        return compare33(a, b) == 0;
+    }
+
+    @Test(op = Operation.EQUAL)
+    public static boolean testEqual34(int a, int b) {
+        return compare34(a, b) == 0;
+    }
+
+    @Test(op = Operation.EQUAL)
+    public static boolean testEqual35(int a, int b) {
+        return compare35(a, b) == 0;
+    }
+
+    @Test(op = Operation.EQUAL)
+    public static boolean testEqual36(int a, int b) {
+        return compare36(a, b) == 0;
+    }
+
+    @Test(op = Operation.EQUAL)
+    public static boolean testEqual37(int a, int b) {
+        return compare37(a, b) == 0;
+    }
+
+    @Test(op = Operation.EQUAL)
+    public static boolean testEqual38(int a, int b) {
+        return compare38(a, b) == 0;
+    }
+
+    @Test(op = Operation.EQUAL)
+    public static boolean testEqual39(int a, int b) {
+        return compare39(a, b) == 0;
+    }
+
+    @Test(op = Operation.EQUAL)
+    public static boolean testEqual40(int a, int b) {
+        return compare40(a, b) == 0;
+    }
+
+    @Test(op = Operation.EQUAL)
+    public static boolean testEqual41(int a, int b) {
+        return compare41(a, b) == 0;
+    }
+
+    @Test(op = Operation.EQUAL)
+    public static boolean testEqual42(int a, int b) {
+        return compare42(a, b) == 0;
+    }
+
+    @Test(op = Operation.EQUAL)
+    public static boolean testEqual43(int a, int b) {
+        return compare43(a, b) == 0;
+    }
+
+    @Test(op = Operation.EQUAL)
+    public static boolean testEqual44(int a, int b) {
+        return compare44(a, b) == 0;
+    }
+
+    @Test(op = Operation.EQUAL)
+    public static boolean testEqual45(int a, int b) {
+        return compare45(a, b) == 0;
+    }
+
+    @Test(op = Operation.EQUAL)
+    public static boolean testEqual46(int a, int b) {
+        return compare46(a, b) == 0;
+    }
+
+    @Test(op = Operation.EQUAL)
+    public static boolean testEqual47(int a, int b) {
+        return compare47(a, b) == 0;
+    }
+
+    @Test(op = Operation.EQUAL)
+    public static boolean testEqual48(int a, int b) {
+        return compare48(a, b) == 0;
+    }
+
+
+    @Test(op = Operation.GREATER_EQUAL)
+    public static boolean testGreaterEqual1(int a, int b) {
+        return compare1(a, b) >= 0;
+    }
+
+    @Test(op = Operation.GREATER_EQUAL)
+    public static boolean testGreaterEqual2(int a, int b) {
+        return compare2(a, b) >= 0;
+    }
+
+    @Test(op = Operation.GREATER_EQUAL)
+    public static boolean testGreaterEqual3(int a, int b) {
+        return compare3(a, b) >= 0;
+    }
+
+    @Test(op = Operation.GREATER_EQUAL)
+    public static boolean testGreaterEqual4(int a, int b) {
+        return compare4(a, b) >= 0;
+    }
+
+    @Test(op = Operation.GREATER_EQUAL)
+    public static boolean testGreaterEqual5(int a, int b) {
+        return compare5(a, b) >= 0;
+    }
+
+    @Test(op = Operation.GREATER_EQUAL)
+    public static boolean testGreaterEqual6(int a, int b) {
+        return compare6(a, b) >= 0;
+    }
+
+    @Test(op = Operation.GREATER_EQUAL)
+    public static boolean testGreaterEqual7(int a, int b) {
+        return compare7(a, b) >= 0;
+    }
+
+    @Test(op = Operation.GREATER_EQUAL)
+    public static boolean testGreaterEqual8(int a, int b) {
+        return compare8(a, b) >= 0;
+    }
+
+    @Test(op = Operation.GREATER_EQUAL)
+    public static boolean testGreaterEqual9(int a, int b) {
+        return compare9(a, b) >= 0;
+    }
+
+    @Test(op = Operation.GREATER_EQUAL)
+    public static boolean testGreaterEqual10(int a, int b) {
+        return compare10(a, b) >= 0;
+    }
+
+    @Test(op = Operation.GREATER_EQUAL)
+    public static boolean testGreaterEqual11(int a, int b) {
+        return compare11(a, b) >= 0;
+    }
+
+    @Test(op = Operation.GREATER_EQUAL)
+    public static boolean testGreaterEqual12(int a, int b) {
+        return compare12(a, b) >= 0;
+    }
+
+    @Test(op = Operation.GREATER_EQUAL)
+    public static boolean testGreaterEqual13(int a, int b) {
+        return compare13(a, b) >= 0;
+    }
+
+    @Test(op = Operation.GREATER_EQUAL)
+    public static boolean testGreaterEqual14(int a, int b) {
+        return compare14(a, b) >= 0;
+    }
+
+    @Test(op = Operation.GREATER_EQUAL)
+    public static boolean testGreaterEqual15(int a, int b) {
+        return compare15(a, b) >= 0;
+    }
+
+    @Test(op = Operation.GREATER_EQUAL)
+    public static boolean testGreaterEqual16(int a, int b) {
+        return compare16(a, b) >= 0;
+    }
+
+    @Test(op = Operation.GREATER_EQUAL)
+    public static boolean testGreaterEqual17(int a, int b) {
+        return compare17(a, b) >= 0;
+    }
+
+    @Test(op = Operation.GREATER_EQUAL)
+    public static boolean testGreaterEqual18(int a, int b) {
+        return compare18(a, b) >= 0;
+    }
+
+    @Test(op = Operation.GREATER_EQUAL)
+    public static boolean testGreaterEqual19(int a, int b) {
+        return compare19(a, b) >= 0;
+    }
+
+    @Test(op = Operation.GREATER_EQUAL)
+    public static boolean testGreaterEqual20(int a, int b) {
+        return compare20(a, b) >= 0;
+    }
+
+    @Test(op = Operation.GREATER_EQUAL)
+    public static boolean testGreaterEqual21(int a, int b) {
+        return compare21(a, b) >= 0;
+    }
+
+    @Test(op = Operation.GREATER_EQUAL)
+    public static boolean testGreaterEqual22(int a, int b) {
+        return compare22(a, b) >= 0;
+    }
+
+    @Test(op = Operation.GREATER_EQUAL)
+    public static boolean testGreaterEqual23(int a, int b) {
+        return compare23(a, b) >= 0;
+    }
+
+    @Test(op = Operation.GREATER_EQUAL)
+    public static boolean testGreaterEqual24(int a, int b) {
+        return compare24(a, b) >= 0;
+    }
+
+    @Test(op = Operation.GREATER_EQUAL)
+    public static boolean testGreaterEqual25(int a, int b) {
+        return compare25(a, b) >= 0;
+    }
+
+    @Test(op = Operation.GREATER_EQUAL)
+    public static boolean testGreaterEqual26(int a, int b) {
+        return compare26(a, b) >= 0;
+    }
+
+    @Test(op = Operation.GREATER_EQUAL)
+    public static boolean testGreaterEqual27(int a, int b) {
+        return compare27(a, b) >= 0;
+    }
+
+    @Test(op = Operation.GREATER_EQUAL)
+    public static boolean testGreaterEqual28(int a, int b) {
+        return compare28(a, b) >= 0;
+    }
+
+    @Test(op = Operation.GREATER_EQUAL)
+    public static boolean testGreaterEqual29(int a, int b) {
+        return compare29(a, b) >= 0;
+    }
+
+    @Test(op = Operation.GREATER_EQUAL)
+    public static boolean testGreaterEqual30(int a, int b) {
+        return compare30(a, b) >= 0;
+    }
+
+    @Test(op = Operation.GREATER_EQUAL)
+    public static boolean testGreaterEqual31(int a, int b) {
+        return compare31(a, b) >= 0;
+    }
+
+    @Test(op = Operation.GREATER_EQUAL)
+    public static boolean testGreaterEqual32(int a, int b) {
+        return compare32(a, b) >= 0;
+    }
+
+    @Test(op = Operation.GREATER_EQUAL)
+    public static boolean testGreaterEqual33(int a, int b) {
+        return compare33(a, b) >= 0;
+    }
+
+    @Test(op = Operation.GREATER_EQUAL)
+    public static boolean testGreaterEqual34(int a, int b) {
+        return compare34(a, b) >= 0;
+    }
+
+    @Test(op = Operation.GREATER_EQUAL)
+    public static boolean testGreaterEqual35(int a, int b) {
+        return compare35(a, b) >= 0;
+    }
+
+    @Test(op = Operation.GREATER_EQUAL)
+    public static boolean testGreaterEqual36(int a, int b) {
+        return compare36(a, b) >= 0;
+    }
+
+    @Test(op = Operation.GREATER_EQUAL)
+    public static boolean testGreaterEqual37(int a, int b) {
+        return compare37(a, b) >= 0;
+    }
+
+    @Test(op = Operation.GREATER_EQUAL)
+    public static boolean testGreaterEqual38(int a, int b) {
+        return compare38(a, b) >= 0;
+    }
+
+    @Test(op = Operation.GREATER_EQUAL)
+    public static boolean testGreaterEqual39(int a, int b) {
+        return compare39(a, b) >= 0;
+    }
+
+    @Test(op = Operation.GREATER_EQUAL)
+    public static boolean testGreaterEqual40(int a, int b) {
+        return compare40(a, b) >= 0;
+    }
+
+    @Test(op = Operation.GREATER_EQUAL)
+    public static boolean testGreaterEqual41(int a, int b) {
+        return compare41(a, b) >= 0;
+    }
+
+    @Test(op = Operation.GREATER_EQUAL)
+    public static boolean testGreaterEqual42(int a, int b) {
+        return compare42(a, b) >= 0;
+    }
+
+    @Test(op = Operation.GREATER_EQUAL)
+    public static boolean testGreaterEqual43(int a, int b) {
+        return compare43(a, b) >= 0;
+    }
+
+    @Test(op = Operation.GREATER_EQUAL)
+    public static boolean testGreaterEqual44(int a, int b) {
+        return compare44(a, b) >= 0;
+    }
+
+    @Test(op = Operation.GREATER_EQUAL)
+    public static boolean testGreaterEqual45(int a, int b) {
+        return compare45(a, b) >= 0;
+    }
+
+    @Test(op = Operation.GREATER_EQUAL)
+    public static boolean testGreaterEqual46(int a, int b) {
+        return compare46(a, b) >= 0;
+    }
+
+    @Test(op = Operation.GREATER_EQUAL)
+    public static boolean testGreaterEqual47(int a, int b) {
+        return compare47(a, b) >= 0;
+    }
+
+    @Test(op = Operation.GREATER_EQUAL)
+    public static boolean testGreaterEqual48(int a, int b) {
+        return compare48(a, b) >= 0;
+    }
+
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater1(int a, int b) {
+        return compare1(a, b) == 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater2(int a, int b) {
+        return compare1(a, b) > 0;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater3(int a, int b) {
+        return compare1(a, b) >= 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater4(int a, int b) {
+        return compare2(a, b) == 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater5(int a, int b) {
+        return compare2(a, b) > 0;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater6(int a, int b) {
+        return compare2(a, b) >= 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater7(int a, int b) {
+        return compare3(a, b) == 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater8(int a, int b) {
+        return compare3(a, b) > 0;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater9(int a, int b) {
+        return compare3(a, b) >= 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater10(int a, int b) {
+        return compare4(a, b) == 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater11(int a, int b) {
+        return compare4(a, b) > 0;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater12(int a, int b) {
+        return compare4(a, b) >= 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater13(int a, int b) {
+        return compare5(a, b) == 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater14(int a, int b) {
+        return compare5(a, b) > 0;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater15(int a, int b) {
+        return compare5(a, b) >= 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater16(int a, int b) {
+        return compare6(a, b) == 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater17(int a, int b) {
+        return compare6(a, b) > 0;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater18(int a, int b) {
+        return compare6(a, b) >= 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater19(int a, int b) {
+        return compare7(a, b) == 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater20(int a, int b) {
+        return compare7(a, b) > 0;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater21(int a, int b) {
+        return compare7(a, b) >= 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater22(int a, int b) {
+        return compare8(a, b) == 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater23(int a, int b) {
+        return compare8(a, b) > 0;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater24(int a, int b) {
+        return compare8(a, b) >= 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater25(int a, int b) {
+        return compare9(a, b) == 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater26(int a, int b) {
+        return compare9(a, b) > 0;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater27(int a, int b) {
+        return compare9(a, b) >= 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater28(int a, int b) {
+        return compare10(a, b) == 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater29(int a, int b) {
+        return compare10(a, b) > 0;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater30(int a, int b) {
+        return compare10(a, b) >= 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater31(int a, int b) {
+        return compare11(a, b) == 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater32(int a, int b) {
+        return compare11(a, b) > 0;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater33(int a, int b) {
+        return compare11(a, b) >= 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater34(int a, int b) {
+        return compare12(a, b) == 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater35(int a, int b) {
+        return compare12(a, b) > 0;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater36(int a, int b) {
+        return compare12(a, b) >= 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater37(int a, int b) {
+        return compare13(a, b) == 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater38(int a, int b) {
+        return compare13(a, b) > 0;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater39(int a, int b) {
+        return compare13(a, b) >= 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater40(int a, int b) {
+        return compare14(a, b) == 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater41(int a, int b) {
+        return compare14(a, b) > 0;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater42(int a, int b) {
+        return compare14(a, b) >= 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater43(int a, int b) {
+        return compare15(a, b) == 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater44(int a, int b) {
+        return compare15(a, b) > 0;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater45(int a, int b) {
+        return compare15(a, b) >= 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater46(int a, int b) {
+        return compare16(a, b) == 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater47(int a, int b) {
+        return compare16(a, b) > 0;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater48(int a, int b) {
+        return compare16(a, b) >= 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater49(int a, int b) {
+        return compare17(a, b) == 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater50(int a, int b) {
+        return compare17(a, b) > 0;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater51(int a, int b) {
+        return compare17(a, b) >= 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater52(int a, int b) {
+        return compare18(a, b) == 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater53(int a, int b) {
+        return compare18(a, b) > 0;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater54(int a, int b) {
+        return compare18(a, b) >= 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater55(int a, int b) {
+        return compare19(a, b) == 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater56(int a, int b) {
+        return compare19(a, b) > 0;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater57(int a, int b) {
+        return compare19(a, b) >= 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater58(int a, int b) {
+        return compare20(a, b) == 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater59(int a, int b) {
+        return compare20(a, b) > 0;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater60(int a, int b) {
+        return compare20(a, b) >= 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater61(int a, int b) {
+        return compare21(a, b) == 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater62(int a, int b) {
+        return compare21(a, b) > 0;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater63(int a, int b) {
+        return compare21(a, b) >= 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater64(int a, int b) {
+        return compare22(a, b) == 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater65(int a, int b) {
+        return compare22(a, b) > 0;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater66(int a, int b) {
+        return compare22(a, b) >= 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater67(int a, int b) {
+        return compare23(a, b) == 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater68(int a, int b) {
+        return compare23(a, b) > 0;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater69(int a, int b) {
+        return compare23(a, b) >= 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater70(int a, int b) {
+        return compare24(a, b) == 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater71(int a, int b) {
+        return compare24(a, b) > 0;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater72(int a, int b) {
+        return compare24(a, b) >= 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater73(int a, int b) {
+        return compare25(a, b) == 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater74(int a, int b) {
+        return compare25(a, b) > 0;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater75(int a, int b) {
+        return compare25(a, b) >= 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater76(int a, int b) {
+        return compare26(a, b) == 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater77(int a, int b) {
+        return compare26(a, b) > 0;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater78(int a, int b) {
+        return compare26(a, b) >= 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater79(int a, int b) {
+        return compare27(a, b) == 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater80(int a, int b) {
+        return compare27(a, b) > 0;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater81(int a, int b) {
+        return compare27(a, b) >= 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater82(int a, int b) {
+        return compare28(a, b) == 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater83(int a, int b) {
+        return compare28(a, b) > 0;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater84(int a, int b) {
+        return compare28(a, b) >= 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater85(int a, int b) {
+        return compare29(a, b) == 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater86(int a, int b) {
+        return compare29(a, b) > 0;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater87(int a, int b) {
+        return compare29(a, b) >= 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater88(int a, int b) {
+        return compare30(a, b) == 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater89(int a, int b) {
+        return compare30(a, b) > 0;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater90(int a, int b) {
+        return compare30(a, b) >= 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater91(int a, int b) {
+        return compare31(a, b) == 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater92(int a, int b) {
+        return compare31(a, b) > 0;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater93(int a, int b) {
+        return compare31(a, b) >= 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater94(int a, int b) {
+        return compare32(a, b) == 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater95(int a, int b) {
+        return compare32(a, b) > 0;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater96(int a, int b) {
+        return compare32(a, b) >= 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater97(int a, int b) {
+        return compare33(a, b) == 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater98(int a, int b) {
+        return compare33(a, b) > 0;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater99(int a, int b) {
+        return compare33(a, b) >= 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater100(int a, int b) {
+        return compare34(a, b) == 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater101(int a, int b) {
+        return compare34(a, b) > 0;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater102(int a, int b) {
+        return compare34(a, b) >= 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater103(int a, int b) {
+        return compare35(a, b) == 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater104(int a, int b) {
+        return compare35(a, b) > 0;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater105(int a, int b) {
+        return compare35(a, b) >= 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater106(int a, int b) {
+        return compare36(a, b) == 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater107(int a, int b) {
+        return compare36(a, b) > 0;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater108(int a, int b) {
+        return compare36(a, b) >= 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater109(int a, int b) {
+        return compare37(a, b) == 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater110(int a, int b) {
+        return compare37(a, b) > 0;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater111(int a, int b) {
+        return compare37(a, b) >= 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater112(int a, int b) {
+        return compare38(a, b) == 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater113(int a, int b) {
+        return compare38(a, b) > 0;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater114(int a, int b) {
+        return compare38(a, b) >= 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater115(int a, int b) {
+        return compare39(a, b) == 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater116(int a, int b) {
+        return compare39(a, b) > 0;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater117(int a, int b) {
+        return compare39(a, b) >= 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater118(int a, int b) {
+        return compare40(a, b) == 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater119(int a, int b) {
+        return compare40(a, b) > 0;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater120(int a, int b) {
+        return compare40(a, b) >= 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater121(int a, int b) {
+        return compare41(a, b) == 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater122(int a, int b) {
+        return compare41(a, b) > 0;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater123(int a, int b) {
+        return compare41(a, b) >= 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater124(int a, int b) {
+        return compare42(a, b) == 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater125(int a, int b) {
+        return compare42(a, b) > 0;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater126(int a, int b) {
+        return compare42(a, b) >= 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater127(int a, int b) {
+        return compare43(a, b) == 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater128(int a, int b) {
+        return compare43(a, b) > 0;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater129(int a, int b) {
+        return compare43(a, b) >= 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater130(int a, int b) {
+        return compare44(a, b) == 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater131(int a, int b) {
+        return compare44(a, b) > 0;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater132(int a, int b) {
+        return compare44(a, b) >= 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater133(int a, int b) {
+        return compare45(a, b) == 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater134(int a, int b) {
+        return compare45(a, b) > 0;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater135(int a, int b) {
+        return compare45(a, b) >= 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater136(int a, int b) {
+        return compare46(a, b) == 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater137(int a, int b) {
+        return compare46(a, b) > 0;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater138(int a, int b) {
+        return compare46(a, b) >= 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater139(int a, int b) {
+        return compare47(a, b) == 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater140(int a, int b) {
+        return compare47(a, b) > 0;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater141(int a, int b) {
+        return compare47(a, b) >= 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater142(int a, int b) {
+        return compare48(a, b) == 1;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater143(int a, int b) {
+        return compare48(a, b) > 0;
+    }
+
+    @Test(op = Operation.GREATER)
+    public static boolean testGreater144(int a, int b) {
+        return compare48(a, b) >= 1;
+    }
+
+
+    @Test(op = Operation.ALWAYS_FALSE)
+    public static boolean testAlwaysFalse1(int a, int b) {
+        return compareAlwaysFalse1(a, b) == 2;
+    }
+
+    @Test(op = Operation.ALWAYS_FALSE)
+    public static boolean testAlwaysFalse2(int a, int b) {
+        return compareAlwaysFalse1(a, b) > 1;
+    }
+
+    @Test(op = Operation.ALWAYS_FALSE)
+    public static boolean testAlwaysFalse3(int a, int b) {
+        return compareAlwaysFalse1(a, b) >= 2;
+    }
+
+    @Test(op = Operation.ALWAYS_FALSE)
+    public static boolean testAlwaysFalse4(int a, int b) {
+        return compareAlwaysFalse2(a, b) == 2;
+    }
+
+    @Test(op = Operation.ALWAYS_FALSE)
+    public static boolean testAlwaysFalse5(int a, int b) {
+        return compareAlwaysFalse2(a, b) > 1;
+    }
+
+    @Test(op = Operation.ALWAYS_FALSE)
+    public static boolean testAlwaysFalse6(int a, int b) {
+        return compareAlwaysFalse2(a, b) >= 2;
+    }
+
+    @Test(op = Operation.ALWAYS_FALSE)
+    public static boolean testAlwaysFalse7(int a, int b) {
+        return compareAlwaysFalse3(a, b) == 2;
+    }
+
+    @Test(op = Operation.ALWAYS_FALSE)
+    public static boolean testAlwaysFalse8(int a, int b) {
+        return compareAlwaysFalse3(a, b) > 1;
+    }
+
+    @Test(op = Operation.ALWAYS_FALSE)
+    public static boolean testAlwaysFalse9(int a, int b) {
+        return compareAlwaysFalse3(a, b) >= 2;
+    }
+
+    @Test(op = Operation.ALWAYS_FALSE)
+    public static boolean testAlwaysFalse10(int a, int b) {
+        return compareAlwaysFalse4(a, b) == 2;
+    }
+
+    @Test(op = Operation.ALWAYS_FALSE)
+    public static boolean testAlwaysFalse11(int a, int b) {
+        return compareAlwaysFalse4(a, b) > 1;
+    }
+
+    @Test(op = Operation.ALWAYS_FALSE)
+    public static boolean testAlwaysFalse12(int a, int b) {
+        return compareAlwaysFalse4(a, b) >= 2;
+    }
+
+    public static void main(String[] args) throws Exception {
+        Random rand = Utils.getRandomInstance();
+        for (int i = 0; i < 20_000; ++i) {
+            int low = rand.nextInt();
+            int high = rand.nextInt();
+            if (low == high) {
+                --low;
+            }
+            if (low > high) {
+                int tmp = low;
+                low = high;
+                high = tmp;
+            }
+            for (Method m : TestTrichotomyExpressions.class.getMethods()) {
+                if (m.isAnnotationPresent(Test.class)) {
+                    Operation op = m.getAnnotation(Test.class).op();
+                    boolean result = (boolean)m.invoke(null, low, low);
+                    Asserts.assertEquals(result, (op == Operation.EQUAL || op == Operation.SMALLER_EQUAL || op == Operation.GREATER_EQUAL) ? true : false, m + " failed");
+                    result = (boolean)m.invoke(null, low, high);
+                    Asserts.assertEquals(result, (op == Operation.SMALLER || op == Operation.SMALLER_EQUAL) ? true : false, m + " failed");
+                    result = (boolean)m.invoke(null, high, low);
+                    Asserts.assertEquals(result, (op == Operation.GREATER || op == Operation.GREATER_EQUAL) ? true : false, m + " failed");
+                }
+            }
+        }
+    }
+}