content: /*
   * Copyright (C) 2011 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.
   */
  
  class Main extends IntMathBase {
  
      public static boolean mBoolean1, mBoolean2;
      public static byte mByte1, mByte2;
      public static char mChar1, mChar2;
      public static short mShort1, mShort2;
      public static int mInt1, mInt2;
      public static float mFloat1, mFloat2;
      public static long mLong1, mLong2;
      public static double mDouble1, mDouble2;
      public static volatile long mVolatileLong1, mVolatileLong2;
  
  
      private int foo_;
  
      public Main(int stuff) {
          super();
          foo_ = stuff;
      }
  
      public Main() {
          super();
          foo_ = 123;
      }
  
      /* Regression test: triggered an SSA renaming bug. */
      static long divideLongByBillion(long a) {
          long quot;
          long rem;
  
          if (a >= 0) {
              long bLong = 1000000000L;
              quot = (a / bLong);
              rem = (a % bLong);
          } else {
              /*
               * Make the dividend positive shifting it right by 1 bit then get
               * the quotient an remainder and correct them properly
               */
              long aPos = a >>> 1;
              long bPos = 1000000000L >>> 1;
              quot = aPos / bPos;
              rem = aPos % bPos;
              // double the remainder and add 1 if 'a' is odd
              rem = (rem << 1) + (a & 1);
          }
          return ((rem << 32) | (quot & 0xFFFFFFFFL));
      }
  
  
      static int instanceTest(int x) {
          IntMathBase a = new IntMathBase();
          Main b = new Main();
  
          if (!(null instanceof IntMathBase)) {
              x = x + 42;
          }
  
          if (a instanceof IntMathBase) {
              x = x * 2;
          }
  
          if (a instanceof Main) {
              x = x + 13;
          }
  
          if (b instanceof IntMathBase) {
              x = x -1;
          }
  
          if (b instanceof Main) {
              x = x + 1333;
          }
          return x;
      }
  
      int tryThing() {
          int val = super.tryThing();
          return val + 10;
      }
  
      static int superTest(int x) {
          Main instance = new Main();
          Main base = instance;
          int val1 = instance.tryThing();
          int val2 = base.tryThing();
          return val1 + val2 + x;
      }
  
      static int constClassTest(int x) {
          Class c = String.class;
          if (c != null) {
             return x * 2;
          } else {
             return x;
          }
      }
  
      static int constStringTest(int x) {
          String str = "Hello World!";
          return x + str.length();
      }
  
      static void throwNullPointerException() {
          throw new NullPointerException();
      }
  
      static void throwImplicitNullPointerException() {
        throw null;
      }
  
      static int catchBlock(int x) {
          try {
              if (x == 1000) {
                  x += 123;
                  throwNullPointerException();
              } else {
                  x += 321;
                  throwImplicitNullPointerException();
              }
          } catch (NullPointerException npe) {
              x += 456;
          }
          return x;
      }
  
      static int catchBlockNoThrow(int x) {
          try {
              x += 123;
          } catch (NullPointerException npe) {
              x += 456;
          }
          return x;
      }
  
      static int staticFieldTest(int x) {
          mBoolean1 = true;
          mBoolean2 = false;
          mByte1 = 127;
          mByte2 = -128;
          mChar1 = 32767;
          mChar2 = 65535;
          mShort1 = 32767;
          mShort2 = -32768;
          mInt1 = 65537;
          mInt2 = -65537;
          mFloat1 = 3.1415f;
          mFloat2 = -1.0f / 0.0f;                // -inf
          mLong1 = 1234605616436508552L;     // 0x1122334455667788
          mLong2 = -1234605616436508552L;
          mDouble1 = 3.1415926535;
          mDouble2 = 1.0 / 0.0;               // +inf
          mVolatileLong1 = mLong1 - 1;
          mVolatileLong2 = mLong2 + 1;
  
          if (!mBoolean1) { return 10; }
          if (mBoolean2) { return 11; }
          if (mByte1 != 127) { return 12; }
          if (mByte2 != -128) { return 13; }
          if (mChar1 != 32767) { return 14; }
          if (mChar2 != 65535) { return 15; }
          if (mShort1 != 32767) { return 16; }
          if (mShort2 != -32768) { return 17; }
          if (mInt1 != 65537) { return 18; }
          if (mInt2 != -65537) { return 19; }
          if (!(mFloat1 > 3.141f && mFloat1 < 3.142f)) { return 20; }
          if (mFloat2 >= mFloat1) { return 21; }
          if (mLong1 != 1234605616436508552L) { return 22; }
          if (mLong2 != -1234605616436508552L) { return 23; }
          if (!(mDouble1 > 3.141592653 && mDouble1 < 3.141592654)) { return 24; }
          if (mDouble2 <= mDouble1) { return 25; }
          if (mVolatileLong1 != 1234605616436508551L) { return 26; }
          if (mVolatileLong2 != -1234605616436508551L) { return 27; }
  
          return 1000 + x;
      }
  
      /*
       * Try to cause some unary operations.
       */
      static int unopTest(int x) {
          x = -x;
          x ^= 0xffffffff;
          return x;
      }
  
      static int shiftTest1() {
          final int[] mBytes = {
              0x11, 0x22, 0x33, 0x44, 0x88, 0x99, 0xaa, 0xbb
          };
          long l;
          int i1, i2;
  
          if (mBytes[0] != 0x11) return 20;
          if (mBytes[1] != 0x22) return 21;
          if (mBytes[2] != 0x33) return 22;
          if (mBytes[3] != 0x44) return 23;
          if (mBytes[4] != 0x88) return 24;
          if (mBytes[5] != 0x99) return 25;
          if (mBytes[6] != 0xaa) return 26;
          if (mBytes[7] != 0xbb) return 27;
  
          i1 = mBytes[0] | mBytes[1] << 8 | mBytes[2] << 16 | mBytes[3] << 24;
          i2 = mBytes[4] | mBytes[5] << 8 | mBytes[6] << 16 | mBytes[7] << 24;
          l = i1 | ((long)i2 << 32);
  
          if (i1 != 0x44332211) { return 0x80000000 | i1; }
          if (i2 != 0xbbaa9988) { return 2; }
          if (l != 0xbbaa998844332211L) { return 3; }
  
          l = (long)mBytes[0]
                  | (long)mBytes[1] << 8
                  | (long)mBytes[2] << 16
                  | (long)mBytes[3] << 24
                  | (long)mBytes[4] << 32
                  | (long)mBytes[5] << 40
                  | (long)mBytes[6] << 48
                  | (long)mBytes[7] << 56;
  
          if (l != 0xbbaa998844332211L) { return 4; }
          return 0;
      }
  
      static int shiftTest2() {
  
          long    a = 0x11;
          long    b = 0x22;
          long    c = 0x33;
          long    d = 0x44;
          long    e = 0x55;
          long    f = 0x66;
          long    g = 0x77;
          long    h = 0x88;
  
          long    result = ((a << 56) | (b << 48) | (c << 40) | (d << 32) |
                            (e << 24) | (f << 16) | (g <<  8) | h);
  
          if (result != 0x1122334455667788L) { return 1; }
          return 0;
      }
  
      static int unsignedShiftTest() {
          byte b = -4;
          short s = -4;
          char c = 0xfffc;
          int i = -4;
  
          b >>>= 4;
          s >>>= 4;
          c >>>= 4;
          i >>>= 4;
  
          if ((int) b != -1) { return 1; }
          if ((int) s != -1) { return 2; }
          if ((int) c != 0x0fff) { return 3; }
          if (i != 268435455) { return 4; }
          return 0;
      }
  
      static int convTest() {
  
          float f;
          double d;
          int i;
          long l;
  
          /* int --> long */
          i = 7654;
          l = (long) i;
          if (l != 7654L) { return 1; }
  
          i = -7654;
          l = (long) i;
          if (l != -7654L) { return 2; }
  
          /* long --> int (with truncation) */
          l = 5678956789L;
          i = (int) l;
          if (i != 1383989493) { return 3; }
  
          l = -5678956789L;
          i = (int) l;
          if (i != -1383989493) { return 4; }
  
          /* long --> double */
          l = 0x7FFFFFFFL;
          d = (double) l;
          if (Double.doubleToRawLongBits(d) != 0x41dfffffffc00000L) { return 5; }
  
          l = 0xFFFFFFFFL;
          d = (double) l;
          if (Double.doubleToRawLongBits(d) != 0x41efffffffe00000L) { return 6; }
  
          l = 0x7FFFFFFFFFFFFFFFL;
          d = (double) l;
          if (Double.doubleToRawLongBits(d) != 0x43e0000000000000L) { return 7; }
  
          l = 0xFFFFFFFFFFFFFFFFL;
          d = (double) l;
          if (Double.doubleToRawLongBits(d) != 0xbff0000000000000L) { return 8; }
  
          return 0;
      }
  
      static int charSubTest() {
  
          char char1 = 0x00e9;
          char char2 = 0xffff;
          int i;
  
          /* chars are unsigned-expanded to ints before subtraction */
          i = char1 - char2;
          if (i != 0xffff00ea) { return 1; }
          return 0;
      }
  
      /*
       * We pass in the arguments and return the results so the compiler
       * doesn't do the math for us.  (x=70000, y=-3)
       */
      static int intOperTest(int x, int y) {
          int[] results = new int[10];
  
          /* this seems to generate "op-int" instructions */
          results[0] = x + y;
          results[1] = x - y;
          results[2] = x * y;
          results[3] = x * x;
          results[4] = x / y;
          results[5] = x % -y;
          results[6] = x & y;
          results[7] = x | y;
          results[8] = x ^ y;
  
          /* this seems to generate "op-int/2addr" instructions */
          results[9] = x + ((((((((x + y) - y) * y) / y) % y) & y) | y) ^ y);
  
          /* check this edge case while we're here (div-int/2addr) */
          int minInt = -2147483648;
          int negOne = -results[5];
          int plusOne = 1;
          int result = (((minInt + plusOne) - plusOne) / negOne) / negOne;
          int shouldBeZero = minInt % negOne;
  
          if (result != minInt) { return 1;};
          if (results[0] != 69997) { return 2;};
          if (results[1] != 70003) { return 3;};
          if (results[2] != -210000) { return 4;};
          if (results[3] != 605032704) { return 5;};
          if (results[4] != -23333) { return 6;};
          if (results[5] != 1) { return 7;};
          if (results[6] != 70000) { return 8;};
          if (results[7] != -3) { return 9;};
          if (results[8] != -70003) { return 10;};
          if (results[9] != 70000) { return 11;};
          if (shouldBeZero != 0) { return 12;};
  
          return 0;
      }
  
      /*
       * More operations, this time with 16-bit constants.  (x=77777)
       */
      static int lit16Test(int x) {
  
          int[] results = new int[10];
  
          /* try to generate op-int/lit16" instructions */
          results[0] = x + 1000;
          results[1] = 1000 - x;
          results[2] = x * 1000;
          results[3] = x / 1000;
          results[4] = x % 1000;
          results[5] = x & 1000;
          results[6] = x | -1000;
          results[7] = x ^ -1000;
          /* use an 16-bit constant that has its MSB (bit-15) set */
          results[8] = x / 32769;
          results[9] = x / -32769;
  
          if (results[0] != 78777) { return 1; }
          if (results[1] != -76777) { return 2; }
          if (results[2] != 77777000) { return 3; }
          if (results[3] != 77) { return 4; }
          if (results[4] != 777) { return 5; }
          if (results[5] != 960) { return 6; }
          if (results[6] != -39) { return 7; }
          if (results[7] != -76855) { return 8; }
          if (results[8] != 2) { return 9; }
          if (results[9] != -2) { return 10; }
          return 0;
      }
  
      /*
       * More operations, this time with 8-bit constants.  (x=-55555)
       */
      static int lit8Test(int x) {
  
          int[] results = new int[9];
  
          /* try to generate op-int/lit8" instructions */
          results[0] = x + 10;
          results[1] = 10 - x;
          results[2] = x * 10;
          results[3] = x / 10;
          results[4] = x % 10;
          results[5] = x & 10;
          results[6] = x | -10;
          results[7] = x ^ -10;
          results[8] = x * -256;
          int minInt = -2147483648;
          int result = minInt / -1;
          if (result != minInt) {return 1; }
          if (results[0] != -55545) {return 2; }
          if (results[1] != 55565) {return 3; }
          if (results[2] != -555550) {return 4; }
          if (results[3] != -5555) {return 5; }
          if (results[4] != -5) {return 6; }
          if (results[5] != 8) {return 7; }
          if (results[6] != -1) {return 8; }
          if (results[7] != 55563) {return 9; }
          if (results[8] != 14222080) {return 10; }
          return 0;
      }
  
  
      /*
       * Shift some data.  (value=0xff00aa01, dist=8)
       */
      static int intShiftTest(int value, int dist) {
          int results[] = new int[4];
          results[0] = value << dist;
          results[1] = value >> dist;
          results[2] = value >>> dist;
          results[3] = (((value << dist) >> dist) >>> dist) << dist;
          if (results[0] != 0x00aa0100) {return 1; }
          if (results[1] != 0xffff00aa) {return 2; }
          if (results[2] != 0x00ff00aa) {return 3; }
          if (results[3] != 0xaa00) {return 4; }
          return 0;
      }
  
      /*
       * We pass in the arguments and return the results so the compiler
       * doesn't do the math for us.  (x=70000000000, y=-3)
       */
      static int longOperTest(long x, long y) {
          long[] results = new long[10];
  
          /* this seems to generate "op-long" instructions */
          results[0] = x + y;
          results[1] = x - y;
          results[2] = x * y;
          results[3] = x * x;
          results[4] = x / y;
          results[5] = x % -y;
          results[6] = x & y;
          results[7] = x | y;
          results[8] = x ^ y;
          /* this seems to generate "op-long/2addr" instructions */
          results[9] = x + ((((((((x + y) - y) * y) / y) % y) & y) | y) ^ y);
          /* check this edge case while we're here (div-long/2addr) */
          long minLong = -9223372036854775808L;
          long negOne = -results[5];
          long plusOne = 1;
          long result = (((minLong + plusOne) - plusOne) / negOne) / negOne;
          if (result != minLong) { return 1; }
          if (results[0] != 69999999997L) { return 2; }
          if (results[1] != 70000000003L) { return 3; }
          if (results[2] != -210000000000L) { return 4; }
          if (results[3] != -6833923606740729856L) { return 5; }    // overflow
          if (results[4] != -23333333333L) { return 6; }
          if (results[5] != 1) { return 7; }
          if (results[6] != 70000000000L) { return 8; }
          if (results[7] != -3) { return 9; }
          if (results[8] != -70000000003L) { return 10; }
          if (results[9] != 70000000000L) { return 11; }
          if (results.length != 10) { return 12; }
          return 0;
      }
  
      /*
       * Shift some data.  (value=0xd5aa96deff00aa01, dist=16)
       */
      static long longShiftTest(long value, int dist) {
          long results[] = new long[4];
          results[0] = value << dist;
          results[1] = value >> dist;
          results[2] = value >>> dist;
          results[3] = (((value << dist) >> dist) >>> dist) << dist;
          if (results[0] != 0x96deff00aa010000L) { return results[0]; }
          if (results[1] != 0xffffd5aa96deff00L) { return results[1]; }
          if (results[2] != 0x0000d5aa96deff00L) { return results[2]; }
          if (results[3] != 0xffff96deff000000L) { return results[3]; }
          if (results.length != 4) { return 5; }
  
          return results[0];      // test return-long
      }
  
      static int switchTest(int a) {
          int res = 1234;
  
          switch (a) {
              case -1: res = 1; return res;
              case 0: res = 2; return res;
              case 1: /*correct*/ break;
              case 2: res = 3; return res;
              case 3: res = 4; return res;
              case 4: res = 5; return res;
              default: res = 6; return res;
          }
          switch (a) {
              case 3: res = 7; return res;
              case 4: res = 8; return res;
              default: /*correct*/ break;
          }
  
          a = 0x12345678;
  
          switch (a) {
              case 0x12345678: /*correct*/ break;
              case 0x12345679: res = 9; return res;
              default: res = 1; return res;
          }
          switch (a) {
              case 57: res = 10; return res;
              case -6: res = 11; return res;
              case 0x12345678: /*correct*/ break;
              case 22: res = 12; return res;
              case 3: res = 13; return res;
              default: res = 14; return res;
          }
          switch (a) {
              case -6: res = 15; return res;
              case 3: res = 16; return res;
              default: /*correct*/ break;
          }
  
          a = -5;
          switch (a) {
              case 12: res = 17; return res;
              case -5: /*correct*/ break;
              case 0: res = 18; return res;
              default: res = 19; return res;
          }
  
          switch (a) {
              default: /*correct*/ break;
          }
          return res;
      }
      /*
       * Test the integer comparisons in various ways.
       */
      static int testIntCompare(int minus, int plus, int plus2, int zero) {
          int res = 1111;
  
          if (minus > plus)
              return 1;
          if (minus >= plus)
              return 2;
          if (plus < minus)
              return 3;
          if (plus <= minus)
              return 4;
          if (plus == minus)
              return 5;
          if (plus != plus2)
              return 6;
  
          /* try a branch-taken */
          if (plus != minus) {
              res = res;
          } else {
              return 7;
          }
  
          if (minus > 0)
              return 8;
          if (minus >= 0)
              return 9;
          if (plus < 0)
              return 10;
          if (plus <= 0)
              return 11;
          if (plus == 0)
              return 12;
          if (zero != 0)
              return 13;
  
          if (zero == 0) {
              res = res;
          } else {
              return 14;
          }
          return res;
      }
  
      /*
       * Test cmp-long.
       *
       * minus=-5, alsoMinus=0xFFFFFFFF00000009, plus=4, alsoPlus=8
       */
      static int testLongCompare(long minus, long alsoMinus, long plus,
                                 long alsoPlus) {
          int res = 2222;
  
          if (minus > plus)
              return 2;
          if (plus < minus)
              return 3;
          if (plus == minus)
              return 4;
  
          if (plus >= plus+1)
              return 5;
          if (minus >= minus+1)
              return 6;
  
          /* try a branch-taken */
          if (plus != minus) {
              res = res;
          } else {
              return 7;
          }
  
          /* compare when high words are equal but low words differ */
          if (plus > alsoPlus)
              return 8;
          if (alsoPlus < plus)
              return 9;
          if (alsoPlus == plus)
              return 10;
  
          /* high words are equal, low words have apparently different signs */
          if (minus < alsoMinus)      // bug!
              return 11;
          if (alsoMinus > minus)
              return 12;
          if (alsoMinus == minus)
              return 13;
  
          return res;
      }
  
      /*
       * Test cmpl-float and cmpg-float.
       */
      static int testFloatCompare(float minus, float plus, float plus2,
                                  float nan) {
          if (minus > plus)
              return 1;
          if (plus < minus)
              return 2;
          if (plus == minus)
              return 3;
          if (plus != plus2)
              return 4;
  
          if (plus <= nan)
              return 5;
          if (plus >= nan)
              return 6;
          if (minus <= nan)
              return 7;
          if (minus >= nan)
              return 8;
          if (nan >= plus)
              return 9;
          if (nan <= plus)
              return 10;
  
          if (nan == nan)
              return 11;
  
          return 3333;
      }
  
      static int testDoubleCompare(double minus, double plus, double plus2,
                                   double nan) {
  
          int res = 4444;
  
          if (minus > plus)
              return 1;
          if (plus < minus)
              return 2;
          if (plus == minus)
              return 3;
          if (plus != plus2)
              return 4;
  
          if (plus <= nan)
              return 5;
          if (plus >= nan)
              return 6;
          if (minus <= nan)
              return 7;
          if (minus >= nan)
              return 8;
          if (nan >= plus)
              return 9;
          if (nan <= plus)
              return 10;
  
          if (nan == nan)
              return 11;
          return res;
      }
  
      static int fibonacci(int n) {
          if (n == 0) {
              return 0;
          } else if (n == 1) {
              return 1;
          } else {
              return fibonacci(n - 1) + fibonacci(n - 2);
          }
      }
  
      static int throwAndCatch() {
          try {
              throwNullPointerException();
              return 1;
          } catch (NullPointerException npe) {
              return 0;
          }
      }
  
      static int manyArgs(int a0, long a1, int a2, long a3, int a4, long a5,
                          int a6, int a7, double a8, float a9, double a10, short a11, int a12,
                          char a13, int a14, int a15, byte a16, boolean a17, int a18, int a19,
                          long a20, long a21, int a22, int a23, int a24, int a25, int a26)
      {
          if (a0 != 0) return 0;
          if (a1 !=  1L) return 1;
          if (a2 != 2) return 2;
          if (a3 != 3L) return 3;
          if (a4 != 4) return 4;
          if (a5 != 5L) return 5;
          if (a6 != 6) return 6;
          if (a7 != 7) return 7;
          if (a8 != 8.0) return 8;
          if (a9 !=  9.0f) return 9;
          if (a10 != 10.0) return 10;
          if (a11 != (short)11) return 11;
          if (a12 != 12) return 12;
          if (a13 != (char)13) return 13;
          if (a14 != 14) return 14;
          if (a15 != 15) return 15;
          if (a16 != (byte)-16) return 16;
          if (a17 !=  true) return 17;
          if (a18 != 18) return 18;
          if (a19 != 19) return 19;
          if (a20 !=  20L) return 20;
          if (a21 != 21L) return 21;
          if (a22 != 22) return 22;
          if (a23 != 23) return 23;
          if (a24 != 24) return 24;
          if (a25 != 25) return 25;
          if (a26 != 26) return 26;
          return -1;
      }
  
      int virtualCall(int a)
      {
          return a * 2;
      }
  
      void setFoo(int a)
      {
          foo_ = a;
      }
  
      int getFoo()
      {
          return foo_;
      }
  
      static int staticCall(int a)
      {
          Main foo = new Main();
          return foo.virtualCall(a);
      }
  
      static int testIGetPut(int a)
      {
          Main foo = new Main(99);
          Main foo123 = new Main();
          int z  = foo.getFoo();
          z += a;
          z += foo123.getFoo();
          foo.setFoo(z);
          return foo.getFoo();
      }
  
      static int throwClassCast(Object o) {
        return ((Integer)o).intValue();
      }
  
      static int testClassCast() {
        int res = 0;
        try {
          res += throwClassCast(Integer.valueOf(123));
        } catch(ClassCastException e) {
          res += 456;
        }
        try {
          res += throwClassCast(new Short((short)321));
        } catch(ClassCastException e) {
          res += 765;
        }
        return res;
      }
  
      static void throwArrayStoreException(Object[] array, Object element) {
        array[0] = element;
      }
  
      static int testArrayStoreException() {
        int res=0;
        Object[] array = new Number[2];
        try {
          throwArrayStoreException(array, null);
          res += 1;
        } catch(ArrayStoreException e) {
          res += 2;
        }
        try {
          throwArrayStoreException(array, Integer.valueOf(1));
          res += 10;
        } catch(ArrayStoreException e) {
          res += 20;
        }
        try {
          throwArrayStoreException(array, "hello MTV-44");
          res += 100;
        } catch(ArrayStoreException e) {
          res += 200;
        }
        return res;
      }
  
      static long recursion_count_;
      static void throwStackOverflow(long l) {
        recursion_count_++;
        throwStackOverflow(recursion_count_);
      }
  
      static long testStackOverflow() {
        try {
          throwStackOverflow(0);
          if (recursion_count_ != 0) {
            return recursion_count_;
          } else {
            return -1;
          }
        } catch(StackOverflowError soe) {
          return 0;
        }
      }
  
      static int testArrayAllocation() {
        int res = 0;
        try {
          int[] x = new int[-1];
          res += 1;
        } catch (NegativeArraySizeException e) {
          res += 2;
        }
        try {
          int[] x = new int [1];
          res += 10;
        } catch (Throwable e) {
          res += 20;
        }
        return res;
      }
  
      public static void main(String[] args) {
          boolean failure = false;
          int res;
          long lres;
  
          lres = divideLongByBillion(123000000000L);
          if (lres == 123) {
              System.out.println("divideLongByBillion PASSED");
          } else {
              System.out.println("divideLongByBillion FAILED: " + lres);
              failure = true;
          }
          res = unopTest(38);
          if (res == 37) {
              System.out.println("unopTest PASSED");
          } else {
              System.out.println("unopTest FAILED: " + res);
              failure = true;
          }
          res = shiftTest1();
          if (res == 0) {
              System.out.println("shiftTest1 PASSED");
          } else {
              System.out.println("shiftTest1 FAILED: " + res);
              failure = true;
          }
          res = shiftTest2();
          if (res == 0) {
              System.out.println("shiftTest2 PASSED");
          } else {
              System.out.println("shiftTest2 FAILED: " + res);
              failure = true;
          }
          res = unsignedShiftTest();
          if (res == 0) {
              System.out.println("unsignedShiftTest PASSED");
          } else {
              System.out.println("unsignedShiftTest FAILED: " + res);
              failure = true;
          }
          res = convTest();
          if (res == 0) {
              System.out.println("convTest PASSED");
          } else {
              System.out.println("convTest FAILED: " + res);
              failure = true;
          }
          res = charSubTest();
          if (res == 0) {
              System.out.println("charSubTest PASSED");
          } else {
              System.out.println("charSubTest FAILED: " + res);
              failure = true;
          }
          res = intOperTest(70000, -3);
          if (res == 0) {
              System.out.println("intOperTest PASSED");
          } else {
              System.out.println("intOperTest FAILED: " + res);
              failure = true;
          }
          res = lit16Test(77777);
          if (res == 0) {
              System.out.println("lit16Test PASSED");
          } else {
              System.out.println("lit16Test FAILED: " + res);
              failure = true;
          }
          res = lit8Test(-55555);
          if (res == 0) {
              System.out.println("lit8Test PASSED");
          } else {
              System.out.println("lit8Test FAILED: " + res);
              failure = true;
          }
          res = intShiftTest(0xff00aa01, 8);
          if (res == 0) {
              System.out.println("intShiftTest PASSED");
          } else {
              System.out.println("intShiftTest FAILED: " + res);
              failure = true;
          }
          res = longOperTest(70000000000L, -3L);
          if (res == 0) {
              System.out.println("longOperTest PASSED");
          } else {
              System.out.println("longOperTest FAILED: " + res);
              failure = true;
          }
          lres = longShiftTest(0xd5aa96deff00aa01L, 16);
          if (lres == 0x96deff00aa010000L) {
              System.out.println("longShiftTest PASSED");
          } else {
              System.out.println("longShiftTest FAILED: " + lres);
              failure = true;
          }
  
          res = switchTest(1);
          if (res == 1234) {
              System.out.println("switchTest PASSED");
          } else {
              System.out.println("switchTest FAILED: " + res);
              failure = true;
          }
  
          res = testIntCompare(-5, 4, 4, 0);
          if (res == 1111) {
              System.out.println("testIntCompare PASSED");
          } else {
              System.out.println("testIntCompare FAILED: " + res);
              failure = true;
          }
  
          res = testLongCompare(-5L, -4294967287L, 4L, 8L);
          if (res == 2222) {
              System.out.println("testLongCompare PASSED");
          } else {
              System.out.println("testLongCompare FAILED: " + res);
              failure = true;
          }
  
          res = testFloatCompare(-5.0f, 4.0f, 4.0f, (1.0f/0.0f) / (1.0f/0.0f));
          if (res == 3333) {
              System.out.println("testFloatCompare PASSED");
          } else {
              System.out.println("testFloatCompare FAILED: " + res);
              failure = true;
          }
  
          res = testDoubleCompare(-5.0, 4.0, 4.0, (1.0/0.0) / (1.0/0.0));
          if (res == 4444) {
              System.out.println("testDoubleCompare PASSED");
          } else {
              System.out.println("testDoubleCompare FAILED: " + res);
              failure = true;
          }
  
          res = fibonacci(10);
          if (res == 55) {
              System.out.println("fibonacci PASSED");
          } else {
              System.out.println("fibonacci FAILED: " + res);
              failure = true;
          }
  
          res = throwAndCatch();
          if (res == 0) {
              System.out.println("throwAndCatch PASSED");
          } else {
              System.out.println("throwAndCatch FAILED: " + res);
              failure = true;
          }
  
          res = testClassCast();
          if (res == 888) {
              System.out.println("testClassCast PASSED");
          } else {
              System.out.println("testClassCast FAILED: " + res);
              failure = true;
          }
  
          res = testArrayStoreException();
          if (res == 211) {
            System.out.println("testArrayStore PASSED");
          } else {
            System.out.println("testArrayStore FAILED: " + res);
            failure = true;
          }
  
          lres= testStackOverflow();
          if (lres == 0) {
              System.out.println("testStackOverflow PASSED");
          } else {
              System.out.println("testStackOverflow FAILED: " + lres);
              failure = true;
          }
  
          res = testArrayAllocation();
          if (res == 12) {
            System.out.println("testArrayAllocation PASSED");
          } else {
            System.out.println("testArrayAllocation FAILED: " + res);
            failure = true;
          }
  
          res = manyArgs(0, 1L, 2, 3L, 4, 5L, 6, 7, 8.0, 9.0f, 10.0,
                         (short)11, 12, (char)13, 14, 15, (byte)-16, true, 18,
                         19, 20L, 21L, 22, 23, 24, 25, 26);
          if (res == -1) {
              System.out.println("manyArgs PASSED");
          } else {
              System.out.println("manyArgs FAILED: " + res);
              failure = true;
          }
  
          res = staticCall(3);
          if (res == 6) {
              System.out.println("virtualCall PASSED");
          } else {
              System.out.println("virtualCall FAILED: " + res);
              failure = true;
          }
  
          res = testIGetPut(111);
          if (res == 333) {
              System.out.println("testGetPut PASSED");
          } else {
              System.out.println("testGetPut FAILED: " + res);
              failure = true;
          }
  
          res = staticFieldTest(404);
          if (res == 1404) {
              System.out.println("staticFieldTest PASSED");
          } else {
              System.out.println("staticFieldTest FAILED: " + res);
              failure = true;
          }
  
          res = catchBlock(1000);
          if (res == 1579) {
              System.out.println("catchBlock(1000) PASSED");
          } else {
              System.out.println("catchBlock(1000) FAILED: " + res);
              failure = true;
          }
          res = catchBlock(7000);
          if (res == 7777) {
              System.out.println("catchBlock(7000) PASSED");
          } else {
              System.out.println("catchBlock(7000) FAILED: " + res);
              failure = true;
          }
          res = catchBlockNoThrow(1000);
          if (res == 1123) {
              System.out.println("catchBlockNoThrow PASSED");
          } else {
              System.out.println("catchBlockNoThrow FAILED: " + res);
              failure = true;
          }
  
          res = superTest(4141);
          if (res == 4175) {
              System.out.println("superTest PASSED");
          } else {
              System.out.println("superTest FAILED: " + res);
              failure = true;
          }
  
          res = constClassTest(1111);
          if (res == 2222) {
              System.out.println("constClassTest PASSED");
          } else {
              System.out.println("constClassTest FAILED: " + res);
              failure = true;
          }
  
          res = constStringTest(10);
          if (res == 22) {
              System.out.println("constStringTest PASSED");
          } else {
              System.out.println("constStringTest FAILED: " + res);
              failure = true;
          }
  
          res = instanceTest(10);
          if (res == 1436) {
              System.out.println("instanceTest PASSED");
          } else {
              System.out.println("instanceTest FAILED: " + res);
              failure = true;
          }
  
          System.exit(failure ? 1 : 0);
      }
  }
  
  class IntMathBase {
      IntMathBase() {
      }
  
      int tryThing() {
          return 7;
      }
  }
  