test/2046-checker-comparison/src/Main.java - LeafOS-Project/android_art - Gitiles

 /*
  * Copyright (C) 2023 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 public class Main {
     public static void main(String[] args) {
         assertEquals(1, $noinline$testEqualBool(true));
         assertEquals(0, $noinline$testNotEqualBool(true));
         // Other comparisons e.g. `<` don't exists for boolean values.

         assertEquals(1, $noinline$testEqualInt(0));
         assertEquals(0, $noinline$testNotEqualInt(0));
         assertEquals(0, $noinline$testGreaterThanInt(0));
         assertEquals(1, $noinline$testGreaterThanOrEqualInt(0));
         assertEquals(0, $noinline$testLessThanInt(0));
         assertEquals(1, $noinline$testLessThanOrEqualInt(0));

         assertEquals(1, $noinline$testEqualLong(0L));
         assertEquals(0, $noinline$testNotEqualLong(0L));
         assertEquals(0, $noinline$testGreaterThanLong(0L));
         assertEquals(1, $noinline$testGreaterThanOrEqualLong(0L));
         assertEquals(0, $noinline$testLessThanLong(0L));
         assertEquals(1, $noinline$testLessThanOrEqualLong(0L));

         // We cannot perform the optimization on unknown float/doubles since equality for NaN
         // returns the opposite as for normal numbers.
         assertEquals(1, $noinline$testEqualFloat(0f));
         assertEquals(0, $noinline$testEqualFloat(Float.NaN));
         assertEquals(1, $noinline$testEqualFloat(Float.NEGATIVE_INFINITY));
         assertEquals(1, $noinline$testEqualFloat(Float.POSITIVE_INFINITY));
         assertEquals(0, $noinline$testNotEqualFloat(0f));
         assertEquals(1, $noinline$testNotEqualFloat(Float.NaN));
         assertEquals(0, $noinline$testNotEqualFloat(Float.NEGATIVE_INFINITY));
         assertEquals(0, $noinline$testNotEqualFloat(Float.POSITIVE_INFINITY));
         assertEquals(0, $noinline$testGreaterThanFloat(0f));
         assertEquals(0, $noinline$testGreaterThanFloat(Float.NaN));
         assertEquals(0, $noinline$testGreaterThanFloat(Float.NEGATIVE_INFINITY));
         assertEquals(0, $noinline$testGreaterThanFloat(Float.POSITIVE_INFINITY));
         assertEquals(1, $noinline$testGreaterThanOrEqualFloat(0f));
         assertEquals(0, $noinline$testGreaterThanOrEqualFloat(Float.NaN));
         assertEquals(1, $noinline$testGreaterThanOrEqualFloat(Float.NEGATIVE_INFINITY));
         assertEquals(1, $noinline$testGreaterThanOrEqualFloat(Float.POSITIVE_INFINITY));
         assertEquals(0, $noinline$testLessThanFloat(0f));
         assertEquals(0, $noinline$testLessThanFloat(Float.NaN));
         assertEquals(0, $noinline$testLessThanFloat(Float.NEGATIVE_INFINITY));
         assertEquals(0, $noinline$testLessThanFloat(Float.POSITIVE_INFINITY));
         assertEquals(1, $noinline$testLessThanOrEqualFloat(0f));
         assertEquals(0, $noinline$testLessThanOrEqualFloat(Float.NaN));
         assertEquals(1, $noinline$testLessThanOrEqualFloat(Float.NEGATIVE_INFINITY));
         assertEquals(1, $noinline$testLessThanOrEqualFloat(Float.POSITIVE_INFINITY));

         assertEquals(1, $noinline$testEqualDouble(0d));
         assertEquals(0, $noinline$testEqualDouble(Double.NaN));
         assertEquals(1, $noinline$testEqualDouble(Double.NEGATIVE_INFINITY));
         assertEquals(1, $noinline$testEqualDouble(Double.POSITIVE_INFINITY));
         assertEquals(0, $noinline$testNotEqualDouble(0d));
         assertEquals(1, $noinline$testNotEqualDouble(Double.NaN));
         assertEquals(0, $noinline$testNotEqualDouble(Double.NEGATIVE_INFINITY));
         assertEquals(0, $noinline$testNotEqualDouble(Double.POSITIVE_INFINITY));
         assertEquals(0, $noinline$testGreaterThanDouble(0d));
         assertEquals(0, $noinline$testGreaterThanDouble(Double.NaN));
         assertEquals(0, $noinline$testGreaterThanDouble(Double.NEGATIVE_INFINITY));
         assertEquals(0, $noinline$testGreaterThanDouble(Double.POSITIVE_INFINITY));
         assertEquals(1, $noinline$testGreaterThanOrEqualDouble(0d));
         assertEquals(0, $noinline$testGreaterThanOrEqualDouble(Double.NaN));
         assertEquals(1, $noinline$testGreaterThanOrEqualDouble(Double.NEGATIVE_INFINITY));
         assertEquals(1, $noinline$testGreaterThanOrEqualDouble(Double.POSITIVE_INFINITY));
         assertEquals(0, $noinline$testLessThanDouble(0d));
         assertEquals(0, $noinline$testLessThanDouble(Double.NaN));
         assertEquals(0, $noinline$testLessThanDouble(Double.NEGATIVE_INFINITY));
         assertEquals(0, $noinline$testLessThanDouble(Double.POSITIVE_INFINITY));
         assertEquals(1, $noinline$testLessThanOrEqualDouble(0d));
         assertEquals(0, $noinline$testLessThanOrEqualDouble(Double.NaN));
         assertEquals(1, $noinline$testLessThanOrEqualDouble(Double.NEGATIVE_INFINITY));
         assertEquals(1, $noinline$testLessThanOrEqualDouble(Double.POSITIVE_INFINITY));

         assertEquals(1, $noinline$testEqualObject(null));
         assertEquals(1, $noinline$testEqualObject(new Object()));
         assertEquals(0, $noinline$testNotEqualObject(null));
         assertEquals(0, $noinline$testNotEqualObject(new Object()));
         // Other comparisons e.g. `<` don't exists for references.
     }

     /// CHECK-START: int Main.$noinline$testEqualBool(boolean) register (after)
     /// CHECK: <<Const1:i\d+>> IntConstant 1
     /// CHECK:                 Return [<<Const1>>]
     private static int $noinline$testEqualBool(boolean a) {
         if (a == $inline$returnValueBool(a)) {
             return 1;
         } else {
             return 0;
         }
     }

     /// CHECK-START: int Main.$noinline$testNotEqualBool(boolean) register (after)
     /// CHECK: <<Const0:i\d+>> IntConstant 0
     /// CHECK:                 Return [<<Const0>>]
     private static int $noinline$testNotEqualBool(boolean a) {
         if (a != $inline$returnValueBool(a)) {
             return 1;
         } else {
             return 0;
         }
     }

     private static boolean $inline$returnValueBool(boolean a) {
         return a;
     }

     /// CHECK-START: int Main.$noinline$testEqualInt(int) register (after)
     /// CHECK: <<Const1:i\d+>> IntConstant 1
     /// CHECK:                 Return [<<Const1>>]
     private static int $noinline$testEqualInt(int a) {
         if (a == $inline$returnValueInt(a)) {
             return 1;
         } else {
             return 0;
         }
     }

     /// CHECK-START: int Main.$noinline$testNotEqualInt(int) register (after)
     /// CHECK: <<Const0:i\d+>> IntConstant 0
     /// CHECK:                 Return [<<Const0>>]
     private static int $noinline$testNotEqualInt(int a) {
         if (a != $inline$returnValueInt(a)) {
             return 1;
         } else {
             return 0;
         }
     }

     /// CHECK-START: int Main.$noinline$testGreaterThanInt(int) register (after)
     /// CHECK: <<Const0:i\d+>> IntConstant 0
     /// CHECK:                 Return [<<Const0>>]
     private static int $noinline$testGreaterThanInt(int a) {
         if (a > $inline$returnValueInt(a)) {
             return 1;
         } else {
             return 0;
         }
     }

     /// CHECK-START: int Main.$noinline$testGreaterThanOrEqualInt(int) register (after)
     /// CHECK: <<Const1:i\d+>> IntConstant 1
     /// CHECK:                 Return [<<Const1>>]
     private static int $noinline$testGreaterThanOrEqualInt(int a) {
         if (a >= $inline$returnValueInt(a)) {
             return 1;
         } else {
             return 0;
         }
     }

     /// CHECK-START: int Main.$noinline$testLessThanInt(int) register (after)
     /// CHECK: <<Const0:i\d+>> IntConstant 0
     /// CHECK:                 Return [<<Const0>>]
     private static int $noinline$testLessThanInt(int a) {
         if (a < $inline$returnValueInt(a)) {
             return 1;
         } else {
             return 0;
         }
     }

     /// CHECK-START: int Main.$noinline$testLessThanOrEqualInt(int) register (after)
     /// CHECK: <<Const1:i\d+>> IntConstant 1
     /// CHECK:                 Return [<<Const1>>]
     private static int $noinline$testLessThanOrEqualInt(int a) {
         if (a <= $inline$returnValueInt(a)) {
             return 1;
         } else {
             return 0;
         }
     }

     private static int $inline$returnValueInt(int a) {
         return a;
     }

     /// CHECK-START: int Main.$noinline$testEqualLong(long) register (after)
     /// CHECK: <<Const1:i\d+>> IntConstant 1
     /// CHECK:                 Return [<<Const1>>]
     private static int $noinline$testEqualLong(long a) {
         if (a == $inline$returnValueLong(a)) {
             return 1;
         } else {
             return 0;
         }
     }

     /// CHECK-START: int Main.$noinline$testNotEqualLong(long) register (after)
     /// CHECK: <<Const0:i\d+>> IntConstant 0
     /// CHECK:                 Return [<<Const0>>]
     private static int $noinline$testNotEqualLong(long a) {
         if (a != $inline$returnValueLong(a)) {
             return 1;
         } else {
             return 0;
         }
     }

     /// CHECK-START: int Main.$noinline$testGreaterThanLong(long) register (after)
     /// CHECK: <<Const0:i\d+>> IntConstant 0
     /// CHECK:                 Return [<<Const0>>]
     private static int $noinline$testGreaterThanLong(long a) {
         if (a > $inline$returnValueLong(a)) {
             return 1;
         } else {
             return 0;
         }
     }

     /// CHECK-START: int Main.$noinline$testGreaterThanOrEqualLong(long) register (after)
     /// CHECK: <<Const1:i\d+>> IntConstant 1
     /// CHECK:                 Return [<<Const1>>]
     private static int $noinline$testGreaterThanOrEqualLong(long a) {
         if (a >= $inline$returnValueLong(a)) {
             return 1;
         } else {
             return 0;
         }
     }

     /// CHECK-START: int Main.$noinline$testLessThanLong(long) register (after)
     /// CHECK: <<Const0:i\d+>> IntConstant 0
     /// CHECK:                 Return [<<Const0>>]
     private static int $noinline$testLessThanLong(long a) {
         if (a < $inline$returnValueLong(a)) {
             return 1;
         } else {
             return 0;
         }
     }

     /// CHECK-START: int Main.$noinline$testLessThanOrEqualLong(long) register (after)
     /// CHECK: <<Const1:i\d+>> IntConstant 1
     /// CHECK:                 Return [<<Const1>>]
     private static int $noinline$testLessThanOrEqualLong(long a) {
         if (a <= $inline$returnValueLong(a)) {
             return 1;
         } else {
             return 0;
         }
     }

     private static long $inline$returnValueLong(long a) {
         return a;
     }

     /// CHECK-START: int Main.$noinline$testEqualFloat(float) register (after)
     /// CHECK: <<NotEqual:z\d+>> NotEqual
     /// CHECK: <<BNot:z\d+>>     BooleanNot [<<NotEqual>>]
     /// CHECK:                   Return [<<BNot>>]
     private static int $noinline$testEqualFloat(float a) {
         if (a == $inline$returnValueFloat(a)) {
             return 1;
         } else {
             return 0;
         }
     }

     /// CHECK-START: int Main.$noinline$testNotEqualFloat(float) register (after)
     /// CHECK: <<Equal:z\d+>>    Equal
     /// CHECK: <<BNot:z\d+>>     BooleanNot [<<Equal>>]
     /// CHECK:                   Return [<<BNot>>]
     private static int $noinline$testNotEqualFloat(float a) {
         if (a != $inline$returnValueFloat(a)) {
             return 1;
         } else {
             return 0;
         }
     }

     /// CHECK-START: int Main.$noinline$testGreaterThanFloat(float) register (after)
     /// CHECK: <<Const0:i\d+>> IntConstant 0
     /// CHECK:                 Return [<<Const0>>]
     private static int $noinline$testGreaterThanFloat(float a) {
         if (a > $inline$returnValueFloat(a)) {
             return 1;
         } else {
             return 0;
         }
     }

     /// CHECK-START: int Main.$noinline$testGreaterThanOrEqualFloat(float) register (after)
     /// CHECK: <<LessThan:z\d+>> LessThan
     /// CHECK: <<BNot:z\d+>>     BooleanNot [<<LessThan>>]
     /// CHECK:                   Return [<<BNot>>]
     private static int $noinline$testGreaterThanOrEqualFloat(float a) {
         if (a >= $inline$returnValueFloat(a)) {
             return 1;
         } else {
             return 0;
         }
     }

     /// CHECK-START: int Main.$noinline$testLessThanFloat(float) register (after)
     /// CHECK: <<Const0:i\d+>> IntConstant 0
     /// CHECK:                 Return [<<Const0>>]
     private static int $noinline$testLessThanFloat(float a) {
         if (a < $inline$returnValueFloat(a)) {
             return 1;
         } else {
             return 0;
         }
     }

     /// CHECK-START: int Main.$noinline$testLessThanOrEqualFloat(float) register (after)
     /// CHECK: <<GreaterThan:z\d+>> GreaterThan
     /// CHECK: <<BNot:z\d+>>        BooleanNot [<<GreaterThan>>]
     /// CHECK:                      Return [<<BNot>>]
     private static int $noinline$testLessThanOrEqualFloat(float a) {
         if (a <= $inline$returnValueFloat(a)) {
             return 1;
         } else {
             return 0;
         }
     }

     private static float $inline$returnValueFloat(float a) {
         return a;
     }

     /// CHECK-START: int Main.$noinline$testEqualDouble(double) register (after)
     /// CHECK: <<NotEqual:z\d+>> NotEqual
     /// CHECK: <<BNot:z\d+>>     BooleanNot [<<NotEqual>>]
     /// CHECK:                   Return [<<BNot>>]
     private static int $noinline$testEqualDouble(double a) {
         if (a == $inline$returnValueDouble(a)) {
             return 1;
         } else {
             return 0;
         }
     }

     /// CHECK-START: int Main.$noinline$testNotEqualDouble(double) register (after)
     /// CHECK: <<Equal:z\d+>>    Equal
     /// CHECK: <<BNot:z\d+>>     BooleanNot [<<Equal>>]
     /// CHECK:                   Return [<<BNot>>]
     private static int $noinline$testNotEqualDouble(double a) {
         if (a != $inline$returnValueDouble(a)) {
             return 1;
         } else {
             return 0;
         }
     }

     /// CHECK-START: int Main.$noinline$testGreaterThanDouble(double) register (after)
     /// CHECK: <<Const0:i\d+>> IntConstant 0
     /// CHECK:                 Return [<<Const0>>]
     private static int $noinline$testGreaterThanDouble(double a) {
         if (a > $inline$returnValueDouble(a)) {
             return 1;
         } else {
             return 0;
         }
     }

     /// CHECK-START: int Main.$noinline$testGreaterThanOrEqualDouble(double) register (after)
     /// CHECK: <<LessThan:z\d+>> LessThan
     /// CHECK: <<BNot:z\d+>>     BooleanNot [<<LessThan>>]
     /// CHECK:                   Return [<<BNot>>]
     private static int $noinline$testGreaterThanOrEqualDouble(double a) {
         if (a >= $inline$returnValueDouble(a)) {
             return 1;
         } else {
             return 0;
         }
     }

     /// CHECK-START: int Main.$noinline$testLessThanDouble(double) register (after)
     /// CHECK: <<Const0:i\d+>> IntConstant 0
     /// CHECK:                 Return [<<Const0>>]
     private static int $noinline$testLessThanDouble(double a) {
         if (a < $inline$returnValueDouble(a)) {
             return 1;
         } else {
             return 0;
         }
     }

     /// CHECK-START: int Main.$noinline$testLessThanOrEqualDouble(double) register (after)
     /// CHECK: <<GreaterThan:z\d+>> GreaterThan
     /// CHECK: <<BNot:z\d+>>        BooleanNot [<<GreaterThan>>]
     /// CHECK:                      Return [<<BNot>>]
     private static int $noinline$testLessThanOrEqualDouble(double a) {
         if (a <= $inline$returnValueDouble(a)) {
             return 1;
         } else {
             return 0;
         }
     }

     private static double $inline$returnValueDouble(double a) {
         return a;
     }

     /// CHECK-START: int Main.$noinline$testEqualObject(java.lang.Object) register (after)
     /// CHECK: <<Const1:i\d+>> IntConstant 1
     /// CHECK:                 Return [<<Const1>>]
     private static int $noinline$testEqualObject(Object a) {
         if (a == $inline$returnValueObject(a)) {
             return 1;
         } else {
             return 0;
         }
     }

     /// CHECK-START: int Main.$noinline$testNotEqualObject(java.lang.Object) register (after)
     /// CHECK: <<Const0:i\d+>> IntConstant 0
     /// CHECK:                 Return [<<Const0>>]
     private static int $noinline$testNotEqualObject(Object a) {
         if (a != $inline$returnValueObject(a)) {
             return 1;
         } else {
             return 0;
         }
     }

     private static Object $inline$returnValueObject(Object a) {
         return a;
     }

     static void assertEquals(int expected, int actual) {
         if (expected != actual) {
             throw new AssertionError("Expected " + expected + " got " + actual);
         }
     }
 }
	/*
	* Copyright (C) 2023 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	public class Main {
	public static void main(String[] args) {
	assertEquals(1, $noinline$testEqualBool(true));
	assertEquals(0, $noinline$testNotEqualBool(true));
	// Other comparisons e.g. `<` don't exists for boolean values.

	assertEquals(1, $noinline$testEqualInt(0));
	assertEquals(0, $noinline$testNotEqualInt(0));
	assertEquals(0, $noinline$testGreaterThanInt(0));
	assertEquals(1, $noinline$testGreaterThanOrEqualInt(0));
	assertEquals(0, $noinline$testLessThanInt(0));
	assertEquals(1, $noinline$testLessThanOrEqualInt(0));

	assertEquals(1, $noinline$testEqualLong(0L));
	assertEquals(0, $noinline$testNotEqualLong(0L));
	assertEquals(0, $noinline$testGreaterThanLong(0L));
	assertEquals(1, $noinline$testGreaterThanOrEqualLong(0L));
	assertEquals(0, $noinline$testLessThanLong(0L));
	assertEquals(1, $noinline$testLessThanOrEqualLong(0L));

	// We cannot perform the optimization on unknown float/doubles since equality for NaN
	// returns the opposite as for normal numbers.
	assertEquals(1, $noinline$testEqualFloat(0f));
	assertEquals(0, $noinline$testEqualFloat(Float.NaN));
	assertEquals(1, $noinline$testEqualFloat(Float.NEGATIVE_INFINITY));
	assertEquals(1, $noinline$testEqualFloat(Float.POSITIVE_INFINITY));
	assertEquals(0, $noinline$testNotEqualFloat(0f));
	assertEquals(1, $noinline$testNotEqualFloat(Float.NaN));
	assertEquals(0, $noinline$testNotEqualFloat(Float.NEGATIVE_INFINITY));
	assertEquals(0, $noinline$testNotEqualFloat(Float.POSITIVE_INFINITY));
	assertEquals(0, $noinline$testGreaterThanFloat(0f));
	assertEquals(0, $noinline$testGreaterThanFloat(Float.NaN));
	assertEquals(0, $noinline$testGreaterThanFloat(Float.NEGATIVE_INFINITY));
	assertEquals(0, $noinline$testGreaterThanFloat(Float.POSITIVE_INFINITY));
	assertEquals(1, $noinline$testGreaterThanOrEqualFloat(0f));
	assertEquals(0, $noinline$testGreaterThanOrEqualFloat(Float.NaN));
	assertEquals(1, $noinline$testGreaterThanOrEqualFloat(Float.NEGATIVE_INFINITY));
	assertEquals(1, $noinline$testGreaterThanOrEqualFloat(Float.POSITIVE_INFINITY));
	assertEquals(0, $noinline$testLessThanFloat(0f));
	assertEquals(0, $noinline$testLessThanFloat(Float.NaN));
	assertEquals(0, $noinline$testLessThanFloat(Float.NEGATIVE_INFINITY));
	assertEquals(0, $noinline$testLessThanFloat(Float.POSITIVE_INFINITY));
	assertEquals(1, $noinline$testLessThanOrEqualFloat(0f));
	assertEquals(0, $noinline$testLessThanOrEqualFloat(Float.NaN));
	assertEquals(1, $noinline$testLessThanOrEqualFloat(Float.NEGATIVE_INFINITY));
	assertEquals(1, $noinline$testLessThanOrEqualFloat(Float.POSITIVE_INFINITY));

	assertEquals(1, $noinline$testEqualDouble(0d));
	assertEquals(0, $noinline$testEqualDouble(Double.NaN));
	assertEquals(1, $noinline$testEqualDouble(Double.NEGATIVE_INFINITY));
	assertEquals(1, $noinline$testEqualDouble(Double.POSITIVE_INFINITY));
	assertEquals(0, $noinline$testNotEqualDouble(0d));
	assertEquals(1, $noinline$testNotEqualDouble(Double.NaN));
	assertEquals(0, $noinline$testNotEqualDouble(Double.NEGATIVE_INFINITY));
	assertEquals(0, $noinline$testNotEqualDouble(Double.POSITIVE_INFINITY));
	assertEquals(0, $noinline$testGreaterThanDouble(0d));
	assertEquals(0, $noinline$testGreaterThanDouble(Double.NaN));
	assertEquals(0, $noinline$testGreaterThanDouble(Double.NEGATIVE_INFINITY));
	assertEquals(0, $noinline$testGreaterThanDouble(Double.POSITIVE_INFINITY));
	assertEquals(1, $noinline$testGreaterThanOrEqualDouble(0d));
	assertEquals(0, $noinline$testGreaterThanOrEqualDouble(Double.NaN));
	assertEquals(1, $noinline$testGreaterThanOrEqualDouble(Double.NEGATIVE_INFINITY));
	assertEquals(1, $noinline$testGreaterThanOrEqualDouble(Double.POSITIVE_INFINITY));
	assertEquals(0, $noinline$testLessThanDouble(0d));
	assertEquals(0, $noinline$testLessThanDouble(Double.NaN));
	assertEquals(0, $noinline$testLessThanDouble(Double.NEGATIVE_INFINITY));
	assertEquals(0, $noinline$testLessThanDouble(Double.POSITIVE_INFINITY));
	assertEquals(1, $noinline$testLessThanOrEqualDouble(0d));
	assertEquals(0, $noinline$testLessThanOrEqualDouble(Double.NaN));
	assertEquals(1, $noinline$testLessThanOrEqualDouble(Double.NEGATIVE_INFINITY));
	assertEquals(1, $noinline$testLessThanOrEqualDouble(Double.POSITIVE_INFINITY));

	assertEquals(1, $noinline$testEqualObject(null));
	assertEquals(1, $noinline$testEqualObject(new Object()));
	assertEquals(0, $noinline$testNotEqualObject(null));
	assertEquals(0, $noinline$testNotEqualObject(new Object()));
	// Other comparisons e.g. `<` don't exists for references.
	}

	/// CHECK-START: int Main.$noinline$testEqualBool(boolean) register (after)
	/// CHECK: <<Const1:i\d+>> IntConstant 1
	/// CHECK: Return [<<Const1>>]
	private static int $noinline$testEqualBool(boolean a) {
	if (a == $inline$returnValueBool(a)) {
	return 1;
	} else {
	return 0;
	}
	}

	/// CHECK-START: int Main.$noinline$testNotEqualBool(boolean) register (after)
	/// CHECK: <<Const0:i\d+>> IntConstant 0
	/// CHECK: Return [<<Const0>>]
	private static int $noinline$testNotEqualBool(boolean a) {
	if (a != $inline$returnValueBool(a)) {
	return 1;
	} else {
	return 0;
	}
	}

	private static boolean $inline$returnValueBool(boolean a) {
	return a;
	}

	/// CHECK-START: int Main.$noinline$testEqualInt(int) register (after)
	/// CHECK: <<Const1:i\d+>> IntConstant 1
	/// CHECK: Return [<<Const1>>]
	private static int $noinline$testEqualInt(int a) {
	if (a == $inline$returnValueInt(a)) {
	return 1;
	} else {
	return 0;
	}
	}

	/// CHECK-START: int Main.$noinline$testNotEqualInt(int) register (after)
	/// CHECK: <<Const0:i\d+>> IntConstant 0
	/// CHECK: Return [<<Const0>>]
	private static int $noinline$testNotEqualInt(int a) {
	if (a != $inline$returnValueInt(a)) {
	return 1;
	} else {
	return 0;
	}
	}

	/// CHECK-START: int Main.$noinline$testGreaterThanInt(int) register (after)
	/// CHECK: <<Const0:i\d+>> IntConstant 0
	/// CHECK: Return [<<Const0>>]
	private static int $noinline$testGreaterThanInt(int a) {
	if (a > $inline$returnValueInt(a)) {
	return 1;
	} else {
	return 0;
	}
	}

	/// CHECK-START: int Main.$noinline$testGreaterThanOrEqualInt(int) register (after)
	/// CHECK: <<Const1:i\d+>> IntConstant 1
	/// CHECK: Return [<<Const1>>]
	private static int $noinline$testGreaterThanOrEqualInt(int a) {
	if (a >= $inline$returnValueInt(a)) {
	return 1;
	} else {
	return 0;
	}
	}

	/// CHECK-START: int Main.$noinline$testLessThanInt(int) register (after)
	/// CHECK: <<Const0:i\d+>> IntConstant 0
	/// CHECK: Return [<<Const0>>]
	private static int $noinline$testLessThanInt(int a) {
	if (a < $inline$returnValueInt(a)) {
	return 1;
	} else {
	return 0;
	}
	}

	/// CHECK-START: int Main.$noinline$testLessThanOrEqualInt(int) register (after)
	/// CHECK: <<Const1:i\d+>> IntConstant 1
	/// CHECK: Return [<<Const1>>]
	private static int $noinline$testLessThanOrEqualInt(int a) {
	if (a <= $inline$returnValueInt(a)) {
	return 1;
	} else {
	return 0;
	}
	}

	private static int $inline$returnValueInt(int a) {
	return a;
	}

	/// CHECK-START: int Main.$noinline$testEqualLong(long) register (after)
	/// CHECK: <<Const1:i\d+>> IntConstant 1
	/// CHECK: Return [<<Const1>>]
	private static int $noinline$testEqualLong(long a) {
	if (a == $inline$returnValueLong(a)) {
	return 1;
	} else {
	return 0;
	}
	}

	/// CHECK-START: int Main.$noinline$testNotEqualLong(long) register (after)
	/// CHECK: <<Const0:i\d+>> IntConstant 0
	/// CHECK: Return [<<Const0>>]
	private static int $noinline$testNotEqualLong(long a) {
	if (a != $inline$returnValueLong(a)) {
	return 1;
	} else {
	return 0;
	}
	}

	/// CHECK-START: int Main.$noinline$testGreaterThanLong(long) register (after)
	/// CHECK: <<Const0:i\d+>> IntConstant 0
	/// CHECK: Return [<<Const0>>]
	private static int $noinline$testGreaterThanLong(long a) {
	if (a > $inline$returnValueLong(a)) {
	return 1;
	} else {
	return 0;
	}
	}

	/// CHECK-START: int Main.$noinline$testGreaterThanOrEqualLong(long) register (after)
	/// CHECK: <<Const1:i\d+>> IntConstant 1
	/// CHECK: Return [<<Const1>>]
	private static int $noinline$testGreaterThanOrEqualLong(long a) {
	if (a >= $inline$returnValueLong(a)) {
	return 1;
	} else {
	return 0;
	}
	}

	/// CHECK-START: int Main.$noinline$testLessThanLong(long) register (after)
	/// CHECK: <<Const0:i\d+>> IntConstant 0
	/// CHECK: Return [<<Const0>>]
	private static int $noinline$testLessThanLong(long a) {
	if (a < $inline$returnValueLong(a)) {
	return 1;
	} else {
	return 0;
	}
	}

	/// CHECK-START: int Main.$noinline$testLessThanOrEqualLong(long) register (after)
	/// CHECK: <<Const1:i\d+>> IntConstant 1
	/// CHECK: Return [<<Const1>>]
	private static int $noinline$testLessThanOrEqualLong(long a) {
	if (a <= $inline$returnValueLong(a)) {
	return 1;
	} else {
	return 0;
	}
	}

	private static long $inline$returnValueLong(long a) {
	return a;
	}

	/// CHECK-START: int Main.$noinline$testEqualFloat(float) register (after)
	/// CHECK: <<NotEqual:z\d+>> NotEqual
	/// CHECK: <<BNot:z\d+>> BooleanNot [<<NotEqual>>]
	/// CHECK: Return [<<BNot>>]
	private static int $noinline$testEqualFloat(float a) {
	if (a == $inline$returnValueFloat(a)) {
	return 1;
	} else {
	return 0;
	}
	}

	/// CHECK-START: int Main.$noinline$testNotEqualFloat(float) register (after)
	/// CHECK: <<Equal:z\d+>> Equal
	/// CHECK: <<BNot:z\d+>> BooleanNot [<<Equal>>]
	/// CHECK: Return [<<BNot>>]
	private static int $noinline$testNotEqualFloat(float a) {
	if (a != $inline$returnValueFloat(a)) {
	return 1;
	} else {
	return 0;
	}
	}

	/// CHECK-START: int Main.$noinline$testGreaterThanFloat(float) register (after)
	/// CHECK: <<Const0:i\d+>> IntConstant 0
	/// CHECK: Return [<<Const0>>]
	private static int $noinline$testGreaterThanFloat(float a) {
	if (a > $inline$returnValueFloat(a)) {
	return 1;
	} else {
	return 0;
	}
	}

	/// CHECK-START: int Main.$noinline$testGreaterThanOrEqualFloat(float) register (after)
	/// CHECK: <<LessThan:z\d+>> LessThan
	/// CHECK: <<BNot:z\d+>> BooleanNot [<<LessThan>>]
	/// CHECK: Return [<<BNot>>]
	private static int $noinline$testGreaterThanOrEqualFloat(float a) {
	if (a >= $inline$returnValueFloat(a)) {
	return 1;
	} else {
	return 0;
	}
	}

	/// CHECK-START: int Main.$noinline$testLessThanFloat(float) register (after)
	/// CHECK: <<Const0:i\d+>> IntConstant 0
	/// CHECK: Return [<<Const0>>]
	private static int $noinline$testLessThanFloat(float a) {
	if (a < $inline$returnValueFloat(a)) {
	return 1;
	} else {
	return 0;
	}
	}

	/// CHECK-START: int Main.$noinline$testLessThanOrEqualFloat(float) register (after)
	/// CHECK: <<GreaterThan:z\d+>> GreaterThan
	/// CHECK: <<BNot:z\d+>> BooleanNot [<<GreaterThan>>]
	/// CHECK: Return [<<BNot>>]
	private static int $noinline$testLessThanOrEqualFloat(float a) {
	if (a <= $inline$returnValueFloat(a)) {
	return 1;
	} else {
	return 0;
	}
	}

	private static float $inline$returnValueFloat(float a) {
	return a;
	}

	/// CHECK-START: int Main.$noinline$testEqualDouble(double) register (after)
	/// CHECK: <<NotEqual:z\d+>> NotEqual
	/// CHECK: <<BNot:z\d+>> BooleanNot [<<NotEqual>>]
	/// CHECK: Return [<<BNot>>]
	private static int $noinline$testEqualDouble(double a) {
	if (a == $inline$returnValueDouble(a)) {
	return 1;
	} else {
	return 0;
	}
	}

	/// CHECK-START: int Main.$noinline$testNotEqualDouble(double) register (after)
	/// CHECK: <<Equal:z\d+>> Equal
	/// CHECK: <<BNot:z\d+>> BooleanNot [<<Equal>>]
	/// CHECK: Return [<<BNot>>]
	private static int $noinline$testNotEqualDouble(double a) {
	if (a != $inline$returnValueDouble(a)) {
	return 1;
	} else {
	return 0;
	}
	}

	/// CHECK-START: int Main.$noinline$testGreaterThanDouble(double) register (after)
	/// CHECK: <<Const0:i\d+>> IntConstant 0
	/// CHECK: Return [<<Const0>>]
	private static int $noinline$testGreaterThanDouble(double a) {
	if (a > $inline$returnValueDouble(a)) {
	return 1;
	} else {
	return 0;
	}
	}

	/// CHECK-START: int Main.$noinline$testGreaterThanOrEqualDouble(double) register (after)
	/// CHECK: <<LessThan:z\d+>> LessThan
	/// CHECK: <<BNot:z\d+>> BooleanNot [<<LessThan>>]
	/// CHECK: Return [<<BNot>>]
	private static int $noinline$testGreaterThanOrEqualDouble(double a) {
	if (a >= $inline$returnValueDouble(a)) {
	return 1;
	} else {
	return 0;
	}
	}

	/// CHECK-START: int Main.$noinline$testLessThanDouble(double) register (after)
	/// CHECK: <<Const0:i\d+>> IntConstant 0
	/// CHECK: Return [<<Const0>>]
	private static int $noinline$testLessThanDouble(double a) {
	if (a < $inline$returnValueDouble(a)) {
	return 1;
	} else {
	return 0;
	}
	}

	/// CHECK-START: int Main.$noinline$testLessThanOrEqualDouble(double) register (after)
	/// CHECK: <<GreaterThan:z\d+>> GreaterThan
	/// CHECK: <<BNot:z\d+>> BooleanNot [<<GreaterThan>>]
	/// CHECK: Return [<<BNot>>]
	private static int $noinline$testLessThanOrEqualDouble(double a) {
	if (a <= $inline$returnValueDouble(a)) {
	return 1;
	} else {
	return 0;
	}
	}

	private static double $inline$returnValueDouble(double a) {
	return a;
	}

	/// CHECK-START: int Main.$noinline$testEqualObject(java.lang.Object) register (after)
	/// CHECK: <<Const1:i\d+>> IntConstant 1
	/// CHECK: Return [<<Const1>>]
	private static int $noinline$testEqualObject(Object a) {
	if (a == $inline$returnValueObject(a)) {
	return 1;
	} else {
	return 0;
	}
	}

	/// CHECK-START: int Main.$noinline$testNotEqualObject(java.lang.Object) register (after)
	/// CHECK: <<Const0:i\d+>> IntConstant 0
	/// CHECK: Return [<<Const0>>]
	private static int $noinline$testNotEqualObject(Object a) {
	if (a != $inline$returnValueObject(a)) {
	return 1;
	} else {
	return 0;
	}
	}

	private static Object $inline$returnValueObject(Object a) {
	return a;
	}

	static void assertEquals(int expected, int actual) {
	if (expected != actual) {
	throw new AssertionError("Expected " + expected + " got " + actual);
	}
	}
	}