Data compare int.

@param left  the left
@param right the right
@return the int
431029
public static int dataCompare(final Bits left, final Bits right) {
    for (int i = 0; i < left.bytes.length; i++) {
      if (right.bytes.length <= i) {
        return 1;
      }
      final int a = left.bytes[i] & 0xFF;
      final int b = right.bytes[i] & 0xFF;
      if (a < b) {
        return -1;
      }
      if (a > b) {
        return 1;
      }
    }
    if (left.bitLength < right.bitLength) {
      return -1;
    }
    if (left.bitLength > right.bitLength) {
      return 1;
    }
    return 0;
  }
506839
public static Number or(Number left, Number right) {
        return NumberMath.or(left, right);
    }
1121026
public static Number multiply(Number left, Number right) {
        return NumberMath.multiply(left, right);
    }
1336024
public boolean lessThan(Object left, Object right) {
    if ((left == right) || (left == null) || (right == null)) {
      return false;
    }
    else {
      return compare(left, right, "<") < 0;
    }

  }
520178
public static Boolean or(Boolean left, Boolean right) {
        return left || Boolean.TRUE.equals(right);
    }
1240485
public static boolean adOrOver(Bound<?> left, Bound<?> right) {
        boolean isValueEqual = left.getValue().equals(right.getValue());
        boolean isBothOpen = left.getBoundaryType() == RangeBoundary.OPEN && right.getBoundaryType() == RangeBoundary.OPEN;
        return isValueEqual && !isBothOpen;
    }
453809
public static Number xor(Number left, Number right) {
        return NumberMath.xor(left, right);
    }
942890
public static Boolean and(Boolean left, Boolean right) {
        return left && Boolean.TRUE.equals(right);
    }
122806
public static int compareHashes(int[] leftHashes, int[] rightHashes) {
        assert(leftHashes != null);
        assert(rightHashes != null);
        assert(leftHashes.length >= 3);
        assert(rightHashes.length >= 3);

        // Compare total checksum first
        if (leftHashes[0] == rightHashes[0]) {
            return -1;
        }
        int includedHashLeft = Math.min(leftHashes[2], MAX_HASHES_COUNT);
        int includedHashRight = Math.min(rightHashes[2], MAX_HASHES_COUNT);
        int includedHashMin = Math.min(includedHashLeft, includedHashRight);
        int pos = 0;
        for(int i = HEADER_OFFSET ; i < HEADER_OFFSET + includedHashMin; i += 2) {
            if(leftHashes[i] != rightHashes[i] || leftHashes[i + 1] != rightHashes[i + 1]) {
                return pos;
            }
            pos++;
        }
        // If the number of per-statement hashes is more than MAX_HASHES_COUNT and
        // the mismatched hash isn't included in the per-statement hashes
        return HASH_NOT_INCLUDE;
    }
344763
private static int compareUnsigned(int left, int right) {
    // NOTE: JDK 7 does not have a built-in operation for this, other than casting to longs.
    //       In JDK 8 it's just Integer.compareUnsigned(left, right).  For now we emulate it
    //       by shifting the sign bit away, with a fallback second compare only if needed.
    int diff = (left >>> 2) - (right >>> 2);
    return diff != 0 ? diff : (left & 3) - (right & 3);
  }
700809
public boolean evaluate(InternalWorkingMemory workingMemory, Object left, Object right) {
        Object leftValue = leftTimestamp != null ? leftTimestamp : left;
        Object rightValue = rightTimestamp != null ? rightTimestamp : right;

        return rightLiteral ?
                evaluator.evaluate( workingMemory,
                                    new ConstantValueReader( leftValue ),
                                    dummyFactHandleOf( leftValue ),
                                    new ObjectFieldImpl( rightValue ) ) :
                evaluator.evaluate( workingMemory,
                                    new ConstantValueReader( leftValue ),
                                    dummyFactHandleOf( leftValue ),
                                    new ConstantValueReader( rightValue ),
                                    dummyFactHandleOf( rightValue ) );
    }
864998
public int first(int node) {
        if (node == NIL) {
            return NIL;
        }
        while (true) {
            final int left = left(node);
            if (left == NIL) {
                break;
            }
            node = left;
        }
        return node;
    }
993863
public boolean greaterThan(Object left, Object right) {
    if ((left == right) || left == null || right == null) {
      return false;
    }
    else {
      return compare(left, right, ">") > 0;
    }
  }
787698
public static Number intdiv(Number left, Number right) {
        return NumberMath.intdiv(left, right);
    }
1007696
public static BooleanIsEqual isEqual(ComparableExpression<Boolean> left, Boolean constant) {
        return new BooleanIsEqual(left, constant(constant));
    }
826491
@Deprecated
  public final ComparisonChain compare(Boolean left, Boolean right) {
    return compareFalseFirst(left, right);
  }
941131
@Pure /* not guaranteed, since compareTo() is invoked */
	@Inline("($1.compareTo($2) <= 0)")
	public static <C> boolean operator_lessEqualsThan(Comparable<? super C> left, C right) {
		return left.compareTo(right) <= 0;
	}