S283 Planetary Science &n…he Search for Life DVD 2/DVD-ROM.iso/install/jre1_3/lib/rt.jar/java/math/BigInteger.class

Java Class File | 1979-12-31 | 19.5 KB | 1,786 lines

package java.math;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.StreamCorruptedException;
import java.util.Random;

public class BigInteger extends Number implements Comparable {
   int signum;
   transient int[] mag;
   private byte[] magnitude;
   private int bitCount;
   private int bitLength;
   private int lowestSetBit;
   private int firstNonzeroByteNum;
   private transient int firstNonzeroIntNum;
   private static final long LONG_MASK = 4294967295L;
   private static BigInteger smallPrimeProduct = valueOf(1685106581L);
   private static final int MAX_CONSTANT = 16;
   private static BigInteger[] posConst = new BigInteger[17];
   private static BigInteger[] negConst = new BigInteger[17];
   public static final BigInteger ZERO;
   public static final BigInteger ONE;
   private static final BigInteger TWO;
   static int[] bnExpModThreshTable;
   static final byte[] trailingZeroTable;
   private static String[] zeros;
   private static int[] digitsPerLong;
   private static BigInteger[] longRadix;
   private static final long serialVersionUID = -8287574255936472291L;

   public BigInteger(byte[] var1) {
      this.bitCount = -1;
      this.bitLength = -1;
      this.lowestSetBit = -2;
      this.firstNonzeroByteNum = -2;
      this.firstNonzeroIntNum = -2;
      if (var1.length == 0) {
         throw new NumberFormatException("Zero length BigInteger");
      } else {
         if (var1[0] < 0) {
            this.mag = makePositive(var1);
            this.signum = -1;
         } else {
            this.mag = stripLeadingZeroBytes(var1);
            this.signum = this.mag.length == 0 ? 0 : 1;
         }

      }
   }

   private BigInteger(int[] var1) {
      this.bitCount = -1;
      this.bitLength = -1;
      this.lowestSetBit = -2;
      this.firstNonzeroByteNum = -2;
      this.firstNonzeroIntNum = -2;
      if (var1.length == 0) {
         throw new NumberFormatException("Zero length BigInteger");
      } else {
         if (var1[0] < 0) {
            this.mag = makePositive(var1);
            this.signum = -1;
         } else {
            this.mag = trustedStripLeadingZeroInts(var1);
            this.signum = this.mag.length == 0 ? 0 : 1;
         }

      }
   }

   public BigInteger(int var1, byte[] var2) {
      this.bitCount = -1;
      this.bitLength = -1;
      this.lowestSetBit = -2;
      this.firstNonzeroByteNum = -2;
      this.firstNonzeroIntNum = -2;
      this.mag = stripLeadingZeroBytes(var2);
      if (var1 >= -1 && var1 <= 1) {
         if (this.mag.length == 0) {
            this.signum = 0;
         } else {
            if (var1 == 0) {
               throw new NumberFormatException("signum-magnitude mismatch");
            }

            this.signum = var1;
         }

      } else {
         throw new NumberFormatException("Invalid signum value");
      }
   }

   private BigInteger(int var1, int[] var2) {
      this.bitCount = -1;
      this.bitLength = -1;
      this.lowestSetBit = -2;
      this.firstNonzeroByteNum = -2;
      this.firstNonzeroIntNum = -2;
      this.mag = stripLeadingZeroInts(var2);
      if (var1 >= -1 && var1 <= 1) {
         if (this.mag.length == 0) {
            this.signum = 0;
         } else {
            if (var1 == 0) {
               throw new NumberFormatException("signum-magnitude mismatch");
            }

            this.signum = var1;
         }

      } else {
         throw new NumberFormatException("Invalid signum value");
      }
   }

   public BigInteger(String var1, int var2) {
      this.bitCount = -1;
      this.bitLength = -1;
      this.lowestSetBit = -2;
      this.firstNonzeroByteNum = -2;
      this.firstNonzeroIntNum = -2;
      int var3 = 0;
      if (var2 >= 2 && var2 <= 36) {
         if (var1.length() == 0) {
            throw new NumberFormatException("Zero length BigInteger");
         } else {
            this.signum = 1;
            if (var1.charAt(0) == '-') {
               if (var1.length() == 1) {
                  throw new NumberFormatException("Zero length BigInteger");
               }

               this.signum = -1;
               var3 = 1;
            }

            while(var3 < var1.length() && Character.digit(var1.charAt(var3), var2) == 0) {
               ++var3;
            }

            if (var3 == var1.length()) {
               this.signum = 0;
               this.mag = ZERO.mag;
            } else {
               int var4 = var1.length() - var3;
               int var5 = var4 % digitsPerLong[var2];
               if (var5 == 0) {
                  var5 = digitsPerLong[var2];
               }

               int var10;
               String var6 = var1.substring(var3, var10 = var3 + var5);

               BigInteger var7;
               long var8;
               for(var7 = valueOf(Long.parseLong(var6, var2)); var10 < var1.length(); var7 = var7.multiply(longRadix[var2]).add(valueOf(var8))) {
                  var6 = var1.substring(var10, var10 += digitsPerLong[var2]);
                  var8 = Long.parseLong(var6, var2);
                  if (var8 < 0L) {
                     throw new NumberFormatException("Illegal digit");
                  }
               }

               this.mag = var7.mag;
            }
         }
      } else {
         throw new NumberFormatException("Radix out of range");
      }
   }

   public BigInteger(String var1) {
      this((String)var1, 10);
   }

   public BigInteger(int var1, Random var2) {
      this(1, (byte[])randomBits(var1, var2));
   }

   private static byte[] randomBits(int var0, Random var1) {
      if (var0 < 0) {
         throw new IllegalArgumentException("numBits must be non-negative");
      } else {
         int var2 = (var0 + 7) / 8;
         byte[] var3 = new byte[var2];
         if (var2 > 0) {
            var1.nextBytes(var3);
            int var4 = 8 * var2 - var0;
            var3[0] = (byte)(var3[0] & (1 << 8 - var4) - 1);
         }

         return var3;
      }
   }

   public BigInteger(int var1, int var2, Random var3) {
      this.bitCount = -1;
      this.bitLength = -1;
      this.lowestSetBit = -2;
      this.firstNonzeroByteNum = -2;
      this.firstNonzeroIntNum = -2;
      if (var1 < 2) {
         throw new ArithmeticException("bitLength < 2");
      } else {
         if (var1 < 95) {
            this.initToSmallPrime(var1, var2, var3);
         } else {
            this.initToLargePrime(var1, var2, var3);
         }

      }
   }

   private void initToSmallPrime(int var1, int var2, Random var3) {
      int var4 = var1 + 31 >>> 5;
      this.mag = new int[var4];
      this.signum = 1;
      int var5 = 1 << (var1 + 31 & 31);
      int var6 = (var5 << 1) - 1;

      while(true) {
         for(int var7 = 0; var7 < var4; ++var7) {
            this.mag[var7] = var3.nextInt();
         }

         this.mag[0] = this.mag[0] & var6 | var5;
         if (var1 > 2) {
            int[] var10000 = this.mag;
            var10000[var4 - 1] |= 1;
         }

         if (var1 > 6) {
            long var8 = this.remainder(smallPrimeProduct).longValue();
            if (var8 % 3L == 0L || var8 % 5L == 0L || var8 % 7L == 0L || var8 % 11L == 0L || var8 % 13L == 0L || var8 % 17L == 0L || var8 % 19L == 0L || var8 % 23L == 0L || var8 % 29L == 0L || var8 % 31L == 0L || var8 % 37L == 0L || var8 % 41L == 0L) {
               continue;
            }
         }

         if (this.isProbablePrime(var2)) {
            return;
         }
      }
   }

   private void initToLargePrime(int var1, int var2, Random var3) {
      BigInteger var4 = (new BigInteger(var1, var3)).setBit(var1 - 1);
      int[] var10000 = var4.mag;
      int var10001 = var4.mag.length - 1;
      var10000[var10001] &= -2;
      int var5 = var1 / 20 * 64;
      BitSieve var6 = new BitSieve(var4, var5);

      BigInteger var7;
      for(var7 = var6.retrieve(var4, var2); var7 == null || var7.bitLength() != var1; var7 = var6.retrieve(var4, var2)) {
         var4 = var4.add(valueOf((long)(2 * var5)));
         if (var4.bitLength() != var1) {
            var4 = (new BigInteger(var1, var3)).setBit(var1 - 1);
         }

         var10000 = var4.mag;
         var10001 = var4.mag.length - 1;
         var10000[var10001] &= -2;
         var6 = new BitSieve(var4, var5);
      }

      this.signum = 1;
      this.mag = var7.mag;
   }

   private BigInteger(int[] var1, int var2) {
      this.bitCount = -1;
      this.bitLength = -1;
      this.lowestSetBit = -2;
      this.firstNonzeroByteNum = -2;
      this.firstNonzeroIntNum = -2;
      this.signum = var1.length == 0 ? 0 : var2;
      this.mag = var1;
   }

   private BigInteger(byte[] var1, int var2) {
      this.bitCount = -1;
      this.bitLength = -1;
      this.lowestSetBit = -2;
      this.firstNonzeroByteNum = -2;
      this.firstNonzeroIntNum = -2;
      this.signum = var1.length == 0 ? 0 : var2;
      this.mag = stripLeadingZeroBytes(var1);
   }

   BigInteger(MutableBigInteger var1, int var2) {
      this.bitCount = -1;
      this.bitLength = -1;
      this.lowestSetBit = -2;
      this.firstNonzeroByteNum = -2;
      this.firstNonzeroIntNum = -2;
      if (var1.offset <= 0 && var1.value.length == var1.intLen) {
         this.mag = var1.value;
      } else {
         this.mag = new int[var1.intLen];

         for(int var3 = 0; var3 < var1.intLen; ++var3) {
            this.mag[var3] = var1.value[var1.offset + var3];
         }
      }

      this.signum = var1.intLen == 0 ? 0 : var2;
   }

   public static BigInteger valueOf(long var0) {
      if (var0 == 0L) {
         return ZERO;
      } else if (var0 > 0L && var0 <= 16L) {
         return posConst[(int)var0];
      } else {
         return var0 < 0L && var0 >= -16L ? negConst[(int)(-var0)] : new BigInteger(var0);
      }
   }

   private BigInteger(long var1) {
      this.bitCount = -1;
      this.bitLength = -1;
      this.lowestSetBit = -2;
      this.firstNonzeroByteNum = -2;
      this.firstNonzeroIntNum = -2;
      if (var1 < 0L) {
         this.signum = -1;
         var1 = -var1;
      } else {
         this.signum = 1;
      }

      int var3 = (int)(var1 >>> 32);
      if (var3 == 0) {
         this.mag = new int[1];
         this.mag[0] = (int)var1;
      } else {
         this.mag = new int[2];
         this.mag[0] = var3;
         this.mag[1] = (int)var1;
      }

   }

   private static BigInteger valueOf(int[] var0) {
      return var0[0] > 0 ? new BigInteger(var0, 1) : new BigInteger(var0);
   }

   public BigInteger add(BigInteger var1) {
      if (var1.signum == 0) {
         return this;
      } else if (this.signum == 0) {
         return var1;
      } else if (var1.signum == this.signum) {
         return new BigInteger(add(this.mag, var1.mag), this.signum);
      } else {
         int var3 = intArrayCmp(this.mag, var1.mag);
         if (var3 == 0) {
            return ZERO;
         } else {
            int[] var2 = var3 > 0 ? subtract(this.mag, var1.mag) : subtract(var1.mag, this.mag);
            var2 = trustedStripLeadingZeroInts(var2);
            return new BigInteger(var2, var3 * this.signum);
         }
      }
   }

   private static int[] add(int[] var0, int[] var1) {
      if (var0.length < var1.length) {
         int[] var2 = var0;
         var0 = var1;
         var1 = var2;
      }

      int var11 = var0.length;
      int var3 = var1.length;
      int[] var4 = new int[var11];

      long var5;
      for(var5 = 0L; var3 > 0; var4[var11] = (int)var5) {
         --var11;
         long var10000 = (long)var0[var11] & 4294967295L;
         --var3;
         var5 = var10000 + ((long)var1[var3] & 4294967295L) + (var5 >>> 32);
      }

      boolean var7;
      for(var7 = var5 >>> 32 != 0L; var11 > 0 && var7; var7 = (var4[var11] = var0[var11] + 1) == 0) {
         --var11;
      }

      while(var11 > 0) {
         --var11;
         var4[var11] = var0[var11];
      }

      if (var7) {
         int var8 = var4.length + 1;
         int[] var9 = new int[var8];

         for(int var10 = 1; var10 < var8; ++var10) {
            var9[var10] = var4[var10 - 1];
         }

         var9[0] = 1;
         var4 = var9;
      }

      return var4;
   }

   public BigInteger subtract(BigInteger var1) {
      if (var1.signum == 0) {
         return this;
      } else if (this.signum == 0) {
         return var1.negate();
      } else if (var1.signum != this.signum) {
         return new BigInteger(add(this.mag, var1.mag), this.signum);
      } else {
         int var3 = intArrayCmp(this.mag, var1.mag);
         if (var3 == 0) {
            return ZERO;
         } else {
            int[] var2 = var3 > 0 ? subtract(this.mag, var1.mag) : subtract(var1.mag, this.mag);
            var2 = trustedStripLeadingZeroInts(var2);
            return new BigInteger(var2, var3 * this.signum);
         }
      }
   }

   private static int[] subtract(int[] var0, int[] var1) {
      int var2 = var0.length;
      int[] var3 = new int[var2];
      int var4 = var1.length;

      long var5;
      for(var5 = 0L; var4 > 0; var3[var2] = (int)var5) {
         --var2;
         long var10000 = (long)var0[var2] & 4294967295L;
         --var4;
         var5 = var10000 - ((long)var1[var4] & 4294967295L) + (var5 >> 32);
      }

      for(boolean var7 = var5 >> 32 != 0L; var2 > 0 && var7; var7 = (var3[var2] = var0[var2] - 1) == -1) {
         --var2;
      }

      while(var2 > 0) {
         --var2;
         var3[var2] = var0[var2];
      }

      return var3;
   }

   public BigInteger multiply(BigInteger var1) {
      if (this.signum != 0 && var1.signum != 0) {
         int[] var2 = this.multiplyToLen(this.mag, this.mag.length, var1.mag, var1.mag.length, (int[])null);
         var2 = trustedStripLeadingZeroInts(var2);
         return new BigInteger(var2, this.signum * var1.signum);
      } else {
         return ZERO;
      }
   }

   private int[] multiplyToLen(int[] var1, int var2, int[] var3, int var4, int[] var5) {
      int var6 = var2 - 1;
      int var7 = var4 - 1;
      if (var5 == null || var5.length < var2 + var4) {
         var5 = new int[var2 + var4];
      }

      long var8 = 0L;
      int var10 = var7;

      for(int var11 = var7 + 1 + var6; var10 >= 0; --var11) {
         long var12 = ((long)var3[var10] & 4294967295L) * ((long)var1[var6] & 4294967295L) + var8;
         var5[var11] = (int)var12;
         var8 = var12 >>> 32;
         --var10;
      }

      var5[var6] = (int)var8;

      for(int var18 = var6 - 1; var18 >= 0; --var18) {
         var8 = 0L;
         int var13 = var7;

         for(int var14 = var7 + 1 + var18; var13 >= 0; --var14) {
            long var15 = ((long)var3[var13] & 4294967295L) * ((long)var1[var18] & 4294967295L) + ((long)var5[var14] & 4294967295L) + var8;
            var5[var14] = (int)var15;
            var8 = var15 >>> 32;
            --var13;
         }

         var5[var18] = (int)var8;
      }

      return var5;
   }

   private BigInteger square() {
      if (this.signum == 0) {
         return ZERO;
      } else {
         int[] var1 = squareToLen(this.mag, this.mag.length, (int[])null);
         return new BigInteger(trustedStripLeadingZeroInts(var1), 1);
      }
   }

   private static final int[] squareToLen(int[] var0, int var1, int[] var2) {
      int var3 = var1 << 1;
      if (var2 == null || var2.length < var3) {
         var2 = new int[var3];
      }

      int var4 = 0;
      int var5 = 0;

      for(int var6 = 0; var5 < var1; ++var5) {
         long var7 = (long)var0[var5] & 4294967295L;
         long var9 = var7 * var7;
         var2[var6++] = var4 << 31 | (int)(var9 >>> 33);
         var2[var6++] = (int)(var9 >>> 1);
         var4 = (int)var9;
      }

      int var12 = var1;

      for(int var8 = 1; var12 > 0; var8 += 2) {
         int var13 = var0[var12 - 1];
         var13 = mulAdd(var2, var0, var8, var12 - 1, var13);
         addOne(var2, var8 - 1, var12, var13);
         --var12;
      }

      primitiveLeftShift(var2, var3, 1);
      var2[var3 - 1] |= var0[var1 - 1] & 1;
      return var2;
   }

   public BigInteger divide(BigInteger var1) {
      MutableBigInteger var2 = new MutableBigInteger();
      MutableBigInteger var3 = new MutableBigInteger();
      MutableBigInteger var4 = new MutableBigInteger(this.mag);
      MutableBigInteger var5 = new MutableBigInteger(var1.mag);
      var4.divide(var5, var2, var3);
      return new BigInteger(var2, this.signum * var1.signum);
   }

   public BigInteger[] divideAndRemainder(BigInteger var1) {
      BigInteger[] var2 = new BigInteger[2];
      MutableBigInteger var3 = new MutableBigInteger();
      MutableBigInteger var4 = new MutableBigInteger();
      MutableBigInteger var5 = new MutableBigInteger(this.mag);
      MutableBigInteger var6 = new MutableBigInteger(var1.mag);
      var5.divide(var6, var3, var4);
      var2[0] = new BigInteger(var3, this.signum * var1.signum);
      var2[1] = new BigInteger(var4, this.signum);
      return var2;
   }

   public BigInteger remainder(BigInteger var1) {
      MutableBigInteger var2 = new MutableBigInteger();
      MutableBigInteger var3 = new MutableBigInteger();
      MutableBigInteger var4 = new MutableBigInteger(this.mag);
      MutableBigInteger var5 = new MutableBigInteger(var1.mag);
      var4.divide(var5, var2, var3);
      return new BigInteger(var3, this.signum);
   }

   public BigInteger pow(int var1) {
      if (var1 < 0) {
         throw new ArithmeticException("Negative exponent");
      } else if (this.signum == 0) {
         return var1 == 0 ? ONE : this;
      } else {
         int var2 = this.signum < 0 && (var1 & 1) == 1 ? -1 : 1;
         int[] var3 = this.mag;
         int[] var4 = new int[]{1};

         while(var1 != 0) {
            if ((var1 & 1) == 1) {
               var4 = this.multiplyToLen(var4, var4.length, var3, var3.length, (int[])null);
            }

            if ((var1 >>>= 1) != 0) {
               var3 = squareToLen(var3, var3.length, (int[])null);
            }
         }

         var4 = trustedStripLeadingZeroInts(var4);
         return new BigInteger(var4, var2);
      }
   }

   public BigInteger gcd(BigInteger var1) {
      if (var1.signum == 0) {
         return this.abs();
      } else if (this.signum == 0) {
         return var1.abs();
      } else {
         MutableBigInteger var2 = new MutableBigInteger(this);
         MutableBigInteger var3 = new MutableBigInteger(var1);
         MutableBigInteger var4 = var2.hybridGCD(var3);
         return new BigInteger(var4, 1);
      }
   }

   private static int[] leftShift(int[] var0, int var1, int var2) {
      int var3 = var2 >>> 5;
      int var4 = var2 & 31;
      int var5 = bitLen(var0[0]);
      if (var2 <= 32 - var5) {
         primitiveLeftShift(var0, var1, var4);
         return var0;
      } else if (var4 <= 32 - var5) {
         int[] var8 = new int[var3 + var1];

         for(int var9 = 0; var9 < var1; ++var9) {
            var8[var9] = var0[var9];
         }

         primitiveLeftShift(var8, var8.length, var4);
         return var8;
      } else {
         int[] var6 = new int[var3 + var1 + 1];

         for(int var7 = 0; var7 < var1; ++var7) {
            var6[var7] = var0[var7];
         }

         primitiveRightShift(var6, var6.length, 32 - var4);
         return var6;
      }
   }

   static void primitiveRightShift(int[] var0, int var1, int var2) {
      int var3 = 32 - var2;
      int var4 = var1 - 1;

      for(int var5 = var0[var4]; var4 > 0; --var4) {
         int var6 = var5;
         var5 = var0[var4 - 1];
         var0[var4] = var5 << var3 | var6 >>> var2;
      }

      var0[0] >>>= var2;
   }

   static void primitiveLeftShift(int[] var0, int var1, int var2) {
      if (var1 != 0 && var2 != 0) {
         int var3 = 32 - var2;
         int var4 = 0;
         int var5 = var0[var4];

         for(int var6 = var4 + var1 - 1; var4 < var6; ++var4) {
            int var7 = var5;
            var5 = var0[var4 + 1];
            var0[var4] = var7 << var2 | var5 >>> var3;
         }

         var0[var1 - 1] <<= var2;
      }
   }

   private static int bitLength(int[] var0, int var1) {
      return var1 == 0 ? 0 : (var1 - 1 << 5) + bitLen(var0[0]);
   }

   public BigInteger abs() {
      return this.signum >= 0 ? this : this.negate();
   }

   public BigInteger negate() {
      return new BigInteger(this.mag, -this.signum);
   }

   public int signum() {
      return this.signum;
   }

   public BigInteger mod(BigInteger var1) {
      if (var1.signum <= 0) {
         throw new ArithmeticException("BigInteger: modulus not positive");
      } else {
         BigInteger var2 = this.remainder(var1);
         return var2.signum >= 0 ? var2 : var2.add(var1);
      }
   }

   public BigInteger modPow(BigInteger var1, BigInteger var2) {
      if (var2.signum <= 0) {
         throw new ArithmeticException("BigInteger: modulus not positive");
      } else if (var1.signum == 0) {
         return var2.equals(ONE) ? ZERO : ONE;
      } else if (this.equals(ONE)) {
         return var2.equals(ONE) ? ZERO : ONE;
      } else if (this.equals(ZERO) && var1.signum >= 0) {
         return ZERO;
      } else if (this.equals(negConst[1]) && !var1.testBit(0)) {
         return var2.equals(ONE) ? ZERO : ONE;
      } else {
         boolean var3;
         if (var3 = var1.signum < 0) {
            var1 = var1.negate();
         }

         BigInteger var4 = this.signum >= 0 && this.compareTo(var2) < 0 ? this : this.mod(var2);
         BigInteger var5;
         if (var2.testBit(0)) {
            var5 = var4.oddModPow(var1, var2);
         } else {
            int var6 = var2.getLowestSetBit();
            BigInteger var7 = var2.shiftRight(var6);
            BigInteger var8 = ONE.shiftLeft(var6);
            BigInteger var9 = this.signum >= 0 && this.compareTo(var7) < 0 ? this : this.mod(var7);
            BigInteger var10 = var7.equals(ONE) ? ZERO : var9.oddModPow(var1, var7);
            BigInteger var11 = var4.modPow2(var1, var6);
            BigInteger var12 = var8.modInverse(var7);
            BigInteger var13 = var7.modInverse(var8);
            var5 = var10.multiply(var8).multiply(var12).add(var11.multiply(var7).multiply(var13)).mod(var2);
         }

         return var3 ? var5.modInverse(var2) : var5;
      }
   }

   private BigInteger oddModPow(BigInteger var1, BigInteger var2) {
      if (var1.equals(ONE)) {
         return this;
      } else if (this.signum == 0) {
         return ZERO;
      } else {
         int[] var3 = (int[])this.mag.clone();
         int[] var4 = var1.mag;
         int[] var5 = var2.mag;
         int var6 = var5.length;
         int var7 = 0;

         int var8;
         for(var8 = bitLength(var4, var4.length); var8 > bnExpModThreshTable[var7]; ++var7) {
         }

         int var9 = 1 << var7;
         int[][] var10 = new int[var9][];

         for(int var11 = 0; var11 < var9; ++var11) {
            var10[var11] = new int[var6];
         }

         int var12 = -MutableBigInteger.inverseMod32(var5[var6 - 1]);
         int[] var13 = leftShift(var3, var3.length, var6 << 5);
         MutableBigInteger var14 = new MutableBigInteger();
         MutableBigInteger var15 = new MutableBigInteger();
         MutableBigInteger var16 = new MutableBigInteger(var13);
         MutableBigInteger var17 = new MutableBigInteger(var5);
         var16.divide(var17, var14, var15);
         var10[0] = var15.toIntArray();
         if (var10[0].length < var6) {
            int var18 = var6 - var10[0].length;
            int[] var19 = new int[var6];

            for(int var20 = 0; var20 < var10[0].length; ++var20) {
               var19[var20 + var18] = var10[0][var20];
            }

            var10[0] = var19;
         }

         int[] var38 = squareToLen(var10[0], var6, (int[])null);
         var38 = montReduce(var38, var5, var6, var12);
         int[] var41 = new int[var6];

         for(int var44 = 0; var44 < var6; ++var44) {
            var41[var44] = var38[var44];
         }

         for(int var21 = 1; var21 < var9; ++var21) {
            int[] var22 = this.multiplyToLen(var41, var6, var10[var21 - 1], var6, (int[])null);
            var10[var21] = montReduce(var22, var5, var6, var12);
         }

         int var45 = 1 << (var8 - 1 & 31);
         int var23 = 0;
         int var24 = var4.length;
         int var25 = 0;

         for(int var26 = 0; var26 <= var7; ++var26) {
            var23 = var23 << 1 | ((var4[var25] & var45) != 0 ? 1 : 0);
            var45 >>>= 1;
            if (var45 == 0) {
               ++var25;
               var45 = Integer.MIN_VALUE;
               --var24;
            }
         }

         --var8;
         boolean var28 = true;

         int var27;
         for(var27 = var8 - var7; (var23 & 1) == 0; ++var27) {
            var23 >>>= 1;
         }

         int[] var29 = var10[var23 >>> 1];
         var23 = 0;
         if (var27 == var8) {
            var28 = false;
         }

         while(true) {
            --var8;
            var23 <<= 1;
            if (var24 != 0) {
               var23 |= (var4[var25] & var45) != 0 ? 1 : 0;
               var45 >>>= 1;
               if (var45 == 0) {
                  ++var25;
                  var45 = Integer.MIN_VALUE;
                  --var24;
               }
            }

            if ((var23 & var9) != 0) {
               for(var27 = var8 - var7; (var23 & 1) == 0; ++var27) {
                  var23 >>>= 1;
               }

               var29 = var10[var23 >>> 1];
               var23 = 0;
            }

            if (var8 == var27) {
               if (var28) {
                  var38 = (int[])var29.clone();
                  var28 = false;
               } else {
                  var13 = this.multiplyToLen(var38, var6, var29, var6, var13);
                  var13 = montReduce(var13, var5, var6, var12);
                  var13 = var38;
                  var38 = var13;
               }
            }

            if (var8 == 0) {
               int[] var30 = new int[2 * var6];

               for(int var31 = 0; var31 < var6; ++var31) {
                  var30[var31 + var6] = var38[var31];
               }

               var38 = montReduce(var30, var5, var6, var12);
               var30 = new int[var6];

               for(int var32 = 0; var32 < var6; ++var32) {
                  var30[var32] = var38[var32];
               }

               return new BigInteger(1, var30);
            }

            if (!var28) {
               var13 = squareToLen(var38, var6, var13);
               var13 = montReduce(var13, var5, var6, var12);
               var13 = var38;
               var38 = var13;
            }
         }
      }
   }

   private static int[] montReduce(int[] var0, int[] var1, int var2, int var3) {
      int var4 = 0;
      int var5 = var2;
      int var6 = 0;

      do {
         int var7 = var0[var0.length - 1 - var6];
         int var8 = mulAdd(var0, var1, var6, var2, var3 * var7);
         var4 += addOne(var0, var6, var2, var8);
         ++var6;
         --var5;
      } while(var5 > 0);

      while(var4 > 0) {
         var4 += subN(var0, var1, var2);
      }

      while(intArrayCmpToLen(var0, var1, var2) >= 0) {
         subN(var0, var1, var2);
      }

      return var0;
   }

   private static int intArrayCmpToLen(int[] var0, int[] var1, int var2) {
      for(int var3 = 0; var3 < var2; ++var3) {
         long var4 = (long)var0[var3] & 4294967295L;
         long var6 = (long)var1[var3] & 4294967295L;
         if (var4 < var6) {
            return -1;
         }

         if (var4 > var6) {
            return 1;
         }
      }

      return 0;
   }

   private static int subN(int[] var0, int[] var1, int var2) {
      long var3 = 0L;

      while(true) {
         --var2;
         if (var2 < 0) {
            return (int)(var3 >> 32);
         }

         var3 = ((long)var0[var2] & 4294967295L) - ((long)var1[var2] & 4294967295L) + (var3 >> 32);
         var0[var2] = (int)var3;
      }
   }

   static int mulAdd(int[] var0, int[] var1, int var2, int var3, int var4) {
      long var5 = (long)var4 & 4294967295L;
      long var7 = 0L;
      var2 = var0.length - var2 - 1;

      for(int var9 = var3 - 1; var9 >= 0; --var9) {
         long var10 = ((long)var1[var9] & 4294967295L) * var5 + ((long)var0[var2] & 4294967295L) + var7;
         var0[var2--] = (int)var10;
         var7 = var10 >>> 32;
      }

      return (int)var7;
   }

   static int addOne(int[] var0, int var1, int var2, int var3) {
      var1 = var0.length - 1 - var2 - var1;
      long var4 = ((long)var0[var1] & 4294967295L) + ((long)var3 & 4294967295L);
      var0[var1] = (int)var4;
      if (var4 >>> 32 == 0L) {
         return 0;
      } else {
         do {
            --var2;
            if (var2 < 0) {
               return 1;
            }

            --var1;
            if (var1 < 0) {
               return 1;
            }

            int var10002 = var0[var1]++;
         } while(var0[var1] == 0);

         return 0;
      }
   }

   private BigInteger modPow2(BigInteger var1, int var2) {
      BigInteger var3 = valueOf(1L);
      BigInteger var4 = this.mod2(var2);
      int var5 = 0;
      int var6 = var1.bitLength();
      if (this.testBit(0)) {
         var6 = var2 - 1 < var6 ? var2 - 1 : var6;
      }

      while(var5 < var6) {
         if (var1.testBit(var5)) {
            var3 = var3.multiply(var4).mod2(var2);
         }

         ++var5;
         if (var5 < var6) {
            var4 = var4.square().mod2(var2);
         }
      }

      return var3;
   }

   private BigInteger mod2(int var1) {
      if (this.bitLength() <= var1) {
         return this;
      } else {
         int var2 = (var1 + 31) / 32;
         int[] var3 = new int[var2];

         for(int var4 = 0; var4 < var2; ++var4) {
            var3[var4] = this.mag[var4 + (this.mag.length - var2)];
         }

         int var5 = (var2 << 5) - var1;
         var3[0] = (int)((long)var3[0] & (1L << 32 - var5) - 1L);
         return var3[0] == 0 ? new BigInteger(1, var3) : new BigInteger(var3, 1);
      }
   }

   public BigInteger modInverse(BigInteger var1) {
      if (var1.signum != 1) {
         throw new ArithmeticException("BigInteger: modulus not positive");
      } else if (var1.equals(ONE)) {
         return ZERO;
      } else {
         BigInteger var2 = this;
         if (this.signum < 0 || intArrayCmp(this.mag, var1.mag) >= 0) {
            var2 = this.mod(var1);
         }

         if (var2.equals(ONE)) {
            return ONE;
         } else {
            MutableBigInteger var3 = new MutableBigInteger(var2);
            MutableBigInteger var4 = new MutableBigInteger(var1);
            MutableBigInteger var5 = var3.mutableModInverse(var4);
            return new BigInteger(var5, 1);
         }
      }
   }

   public BigInteger shiftLeft(int var1) {
      if (this.signum == 0) {
         return ZERO;
      } else if (var1 == 0) {
         return this;
      } else if (var1 < 0) {
         return this.shiftRight(-var1);
      } else {
         int var2 = var1 >>> 5;
         int var3 = var1 & 31;
         int var4 = this.mag.length;
         Object var5 = null;
         int[] var10;
         if (var3 == 0) {
            var10 = new int[var4 + var2];

            for(int var6 = 0; var6 < var4; ++var6) {
               var10[var6] = this.mag[var6];
            }
         } else {
            int var11 = 0;
            int var7 = 32 - var3;
            int var8 = this.mag[0] >>> var7;
            if (var8 != 0) {
               var10 = new int[var4 + var2 + 1];
               var10[var11++] = var8;
            } else {
               var10 = new int[var4 + var2];
            }

            int var9;
            for(var9 = 0; var9 < var4 - 1; var10[var11++] = this.mag[var9++] << var3 | this.mag[var9] >>> var7) {
            }

            var10[var11] = this.mag[var9] << var3;
         }

         return new BigInteger(var10, this.signum);
      }
   }

   public BigInteger shiftRight(int var1) {
      if (var1 == 0) {
         return this;
      } else if (var1 < 0) {
         return this.shiftLeft(-var1);
      } else {
         int var2 = var1 >>> 5;
         int var3 = var1 & 31;
         int var4 = this.mag.length;
         Object var5 = null;
         if (var2 >= var4) {
            return this.signum >= 0 ? ZERO : negConst[1];
         } else {
            int[] var10;
            if (var3 == 0) {
               int var6 = var4 - var2;
               var10 = new int[var6];

               for(int var7 = 0; var7 < var6; ++var7) {
                  var10[var7] = this.mag[var7];
               }
            } else {
               int var11 = 0;
               int var13 = this.mag[0] >>> var3;
               if (var13 != 0) {
                  var10 = new int[var4 - var2];
                  var10[var11++] = var13;
               } else {
                  var10 = new int[var4 - var2 - 1];
               }

               int var8 = 32 - var3;

               for(int var9 = 0; var9 < var4 - var2 - 1; var10[var11++] = this.mag[var9++] << var8 | this.mag[var9] >>> var3) {
               }
            }

            if (this.signum < 0) {
               boolean var12 = false;
               int var14 = var4 - 1;

               for(int var15 = var4 - var2; var14 >= var15 && !var12; --var14) {
                  var12 = this.mag[var14] != 0;
               }

               if (!var12 && var3 != 0) {
                  var12 = this.mag[var4 - var2 - 1] << 32 - var3 != 0;
               }

               if (var12) {
                  var10 = this.javaIncrement(var10);
               }
            }

            return new BigInteger(var10, this.signum);
         }
      }
   }

   int[] javaIncrement(int[] var1) {
      boolean var2 = false;
      int var3 = 0;

      for(int var4 = var1.length - 1; var4 >= 0 && var3 == 0; --var4) {
         var3 = ++var1[var4];
      }

      if (var3 == 0) {
         var1 = new int[var1.length + 1];
         var1[0] = 1;
      }

      return var1;
   }

   public BigInteger and(BigInteger var1) {
      int[] var2 = new int[Math.max(this.intLength(), var1.intLength())];

      for(int var3 = 0; var3 < var2.length; ++var3) {
         var2[var3] = this.getInt(var2.length - var3 - 1) & var1.getInt(var2.length - var3 - 1);
      }

      return valueOf(var2);
   }

   // $FF: renamed from: or (java.math.BigInteger) java.math.BigInteger
   public BigInteger method_0(BigInteger var1) {
      int[] var2 = new int[Math.max(this.intLength(), var1.intLength())];

      for(int var3 = 0; var3 < var2.length; ++var3) {
         var2[var3] = this.getInt(var2.length - var3 - 1) | var1.getInt(var2.length - var3 - 1);
      }

      return valueOf(var2);
   }

   public BigInteger xor(BigInteger var1) {
      int[] var2 = new int[Math.max(this.intLength(), var1.intLength())];

      for(int var3 = 0; var3 < var2.length; ++var3) {
         var2[var3] = this.getInt(var2.length - var3 - 1) ^ var1.getInt(var2.length - var3 - 1);
      }

      return valueOf(var2);
   }

   public BigInteger not() {
      int[] var1 = new int[this.intLength()];

      for(int var2 = 0; var2 < var1.length; ++var2) {
         var1[var2] = ~this.getInt(var1.length - var2 - 1);
      }

      return valueOf(var1);
   }

   public BigInteger andNot(BigInteger var1) {
      int[] var2 = new int[Math.max(this.intLength(), var1.intLength())];

      for(int var3 = 0; var3 < var2.length; ++var3) {
         var2[var3] = this.getInt(var2.length - var3 - 1) & ~var1.getInt(var2.length - var3 - 1);
      }

      return valueOf(var2);
   }

   public boolean testBit(int var1) {
      if (var1 < 0) {
         throw new ArithmeticException("Negative bit address");
      } else {
         return (this.getInt(var1 / 32) & 1 << var1 % 32) != 0;
      }
   }

   public BigInteger setBit(int var1) {
      if (var1 < 0) {
         throw new ArithmeticException("Negative bit address");
      } else {
         int var2 = var1 / 32;
         int[] var3 = new int[Math.max(this.intLength(), var2 + 2)];

         for(int var4 = 0; var4 < var3.length; ++var4) {
            var3[var3.length - var4 - 1] = this.getInt(var4);
         }

         var3[var3.length - var2 - 1] |= 1 << var1 % 32;
         return valueOf(var3);
      }
   }

   public BigInteger clearBit(int var1) {
      if (var1 < 0) {
         throw new ArithmeticException("Negative bit address");
      } else {
         int var2 = var1 / 32;
         int[] var3 = new int[Math.max(this.intLength(), (var1 + 1) / 32 + 1)];

         for(int var4 = 0; var4 < var3.length; ++var4) {
            var3[var3.length - var4 - 1] = this.getInt(var4);
         }

         var3[var3.length - var2 - 1] &= ~(1 << var1 % 32);
         return valueOf(var3);
      }
   }

   public BigInteger flipBit(int var1) {
      if (var1 < 0) {
         throw new ArithmeticException("Negative bit address");
      } else {
         int var2 = var1 / 32;
         int[] var3 = new int[Math.max(this.intLength(), var2 + 2)];

         for(int var4 = 0; var4 < var3.length; ++var4) {
            var3[var3.length - var4 - 1] = this.getInt(var4);
         }

         var3[var3.length - var2 - 1] ^= 1 << var1 % 32;
         return valueOf(var3);
      }
   }

   public int getLowestSetBit() {
      if (this.lowestSetBit == -2) {
         if (this.signum == 0) {
            this.lowestSetBit = -1;
         } else {
            int var1;
            int var2;
            for(var1 = 0; (var2 = this.getInt(var1)) == 0; ++var1) {
            }

            this.lowestSetBit = (var1 << 5) + trailingZeroCnt(var2);
         }
      }

      return this.lowestSetBit;
   }

   public int bitLength() {
      if (this.bitLength == -1) {
         if (this.signum == 0) {
            this.bitLength = 0;
         } else {
            int var1 = (this.mag.length - 1 << 5) + bitLen(this.mag[0]);
            if (this.signum < 0) {
               boolean var2 = bitCnt(this.mag[0]) == 1;

               for(int var3 = 1; var3 < this.mag.length && var2; ++var3) {
                  var2 = this.mag[var3] == 0;
               }

               this.bitLength = var2 ? var1 - 1 : var1;
            } else {
               this.bitLength = var1;
            }
         }
      }

      return this.bitLength;
   }

   static int bitLen(int var0) {
      return var0 < 32768 ? (var0 < 128 ? (var0 < 8 ? (var0 < 2 ? (var0 < 1 ? (var0 < 0 ? 32 : 0) : 1) : (var0 < 4 ? 2 : 3)) : (var0 < 32 ? (var0 < 16 ? 4 : 5) : (var0 < 64 ? 6 : 7))) : (var0 < 2048 ? (var0 < 512 ? (var0 < 256 ? 8 : 9) : (var0 < 1024 ? 10 : 11)) : (var0 < 8192 ? (var0 < 4096 ? 12 : 13) : (var0 < 16384 ? 14 : 15)))) : (var0 < 8388608 ? (var0 < 524288 ? (var0 < 131072 ? (var0 < 65536 ? 16 : 17) : (var0 < 262144 ? 18 : 19)) : (var0 < 2097152 ? (var0 < 1048576 ? 20 : 21) : (var0 < 4194304 ? 22 : 23))) : (var0 < 134217728 ? (var0 < 33554432 ? (var0 < 16777216 ? 24 : 25) : (var0 < 67108864 ? 26 : 27)) : (var0 < 536870912 ? (var0 < 268435456 ? 28 : 29) : (var0 < 1073741824 ? 30 : 31))));
   }

   public int bitCount() {
      if (this.bitCount == -1) {
         int var1 = 0;

         for(int var2 = 0; var2 < this.mag.length; ++var2) {
            var1 += bitCnt(this.mag[var2]);
         }

         if (this.signum < 0) {
            int var3 = 0;

            int var4;
            for(var4 = this.mag.length - 1; this.mag[var4] == 0; --var4) {
               var3 += 32;
            }

            var3 += trailingZeroCnt(this.mag[var4]);
            this.bitCount = var1 + var3 - 1;
         } else {
            this.bitCount = var1;
         }
      }

      return this.bitCount;
   }

   static int bitCnt(int var0) {
      var0 -= (-1431655766 & var0) >>> 1;
      var0 = (var0 & 858993459) + (var0 >>> 2 & 858993459);
      var0 = var0 + (var0 >>> 4) & 252645135;
      var0 += var0 >>> 8;
      var0 += var0 >>> 16;
      return var0 & 255;
   }

   static int trailingZeroCnt(int var0) {
      int var1 = var0 & 255;
      if (var1 != 0) {
         return trailingZeroTable[var1];
      } else {
         var1 = var0 >>> 8 & 255;
         if (var1 != 0) {
            return trailingZeroTable[var1] + 8;
         } else {
            var1 = var0 >>> 16 & 255;
            if (var1 != 0) {
               return trailingZeroTable[var1] + 16;
            } else {
               var1 = var0 >>> 24 & 255;
               return trailingZeroTable[var1] + 24;
            }
         }
      }
   }

   public boolean isProbablePrime(int var1) {
      int var2 = (var1 + 1) / 2;
      if (var2 <= 0) {
         return true;
      } else {
         BigInteger var3 = this.abs();
         if (var3.equals(TWO)) {
            return true;
         } else if (var3.testBit(0) && !var3.equals(ONE)) {
            BigInteger var4 = var3.subtract(ONE);
            int var5 = var4.getLowestSetBit();
            var4 = var4.shiftRight(var5);
            Random var6 = new Random();

            for(int var7 = 0; var7 < var2; ++var7) {
               BigInteger var8;
               do {
                  var8 = new BigInteger(var3.bitLength(), var6);
               } while(var8.compareTo(ONE) <= 0 || var8.compareTo(var3) >= 0);

               int var9 = 0;

               for(BigInteger var10 = var8.modPow(var4, var3); (var9 != 0 || !var10.equals(ONE)) && !var10.equals(var3.subtract(ONE)); var10 = var10.modPow(TWO, var3)) {
                  if (var9 > 0 && var10.equals(ONE)) {
                     return false;
                  }

                  ++var9;
                  if (var9 == var5) {
                     return false;
                  }
               }
            }

            return true;
         } else {
            return false;
         }
      }
   }

   public int compareTo(BigInteger var1) {
      return this.signum == var1.signum ? this.signum * intArrayCmp(this.mag, var1.mag) : (this.signum > var1.signum ? 1 : -1);
   }

   public int compareTo(Object var1) {
      return this.compareTo((BigInteger)var1);
   }

   private static int intArrayCmp(int[] var0, int[] var1) {
      if (var0.length < var1.length) {
         return -1;
      } else if (var0.length > var1.length) {
         return 1;
      } else {
         for(int var2 = 0; var2 < var0.length; ++var2) {
            long var3 = (long)var0[var2] & 4294967295L;
            long var5 = (long)var1[var2] & 4294967295L;
            if (var3 < var5) {
               return -1;
            }

            if (var3 > var5) {
               return 1;
            }
         }

         return 0;
      }
   }

   public boolean equals(Object var1) {
      if (var1 == this) {
         return true;
      } else if (!(var1 instanceof BigInteger)) {
         return false;
      } else {
         BigInteger var2 = (BigInteger)var1;
         if (var2.signum == this.signum && var2.mag.length == this.mag.length) {
            for(int var3 = 0; var3 < this.mag.length; ++var3) {
               if (var2.mag[var3] != this.mag[var3]) {
                  return false;
               }
            }

            return true;
         } else {
            return false;
         }
      }
   }

   public BigInteger min(BigInteger var1) {
      return this.compareTo(var1) < 0 ? this : var1;
   }

   public BigInteger max(BigInteger var1) {
      return this.compareTo(var1) > 0 ? this : var1;
   }

   public int hashCode() {
      int var1 = 0;

      for(int var2 = 0; var2 < this.mag.length; ++var2) {
         var1 = (int)((long)(31 * var1) + ((long)this.mag[var2] & 4294967295L));
      }

      return var1 * this.signum;
   }

   public String toString(int var1) {
      if (this.signum == 0) {
         return "0";
      } else {
         if (var1 < 2 || var1 > 36) {
            var1 = 10;
         }

         int var2 = (4 * this.mag.length + 6) / 7;
         String[] var3 = new String[var2];
         BigInteger var4 = this.abs();

         int var5;
         BigInteger var11;
         for(var5 = 0; var4.signum != 0; var4 = var11) {
            BigInteger var6 = longRadix[var1];
            MutableBigInteger var7 = new MutableBigInteger();
            MutableBigInteger var8 = new MutableBigInteger();
            MutableBigInteger var9 = new MutableBigInteger(var4.mag);
            MutableBigInteger var10 = new MutableBigInteger(var6.mag);
            var9.divide(var10, var7, var8);
            var11 = new BigInteger(var7, var4.signum * var6.signum);
            BigInteger var12 = new BigInteger(var8, var4.signum * var6.signum);
            var3[var5++] = Long.toString(var12.longValue(), var1);
         }

         StringBuffer var13 = new StringBuffer(var5 * digitsPerLong[var1] + 1);
         if (this.signum < 0) {
            var13.append('-');
         }

         var13.append(var3[var5 - 1]);

         for(int var14 = var5 - 2; var14 >= 0; --var14) {
            int var15 = digitsPerLong[var1] - var3[var14].length();
            if (var15 != 0) {
               var13.append(zeros[var15]);
            }

            var13.append(var3[var14]);
         }

         return var13.toString();
      }
   }

   public String toString() {
      return this.toString(10);
   }

   public byte[] toByteArray() {
      int var1 = this.bitLength() / 8 + 1;
      byte[] var2 = new byte[var1];
      int var3 = var1 - 1;
      int var4 = 4;
      int var5 = 0;

      for(int var6 = 0; var3 >= 0; --var3) {
         if (var4 == 4) {
            var5 = this.getInt(var6++);
            var4 = 1;
         } else {
            var5 >>>= 8;
            ++var4;
         }

         var2[var3] = (byte)var5;
      }

      return var2;
   }

   public int intValue() {
      int var1 = 0;
      var1 = this.getInt(0);
      return var1;
   }

   public long longValue() {
      long var1 = 0L;

      for(int var3 = 1; var3 >= 0; --var3) {
         var1 = (var1 << 32) + ((long)this.getInt(var3) & 4294967295L);
      }

      return var1;
   }

   public float floatValue() {
      return Float.valueOf(this.toString());
   }

   public double doubleValue() {
      return Double.valueOf(this.toString());
   }

   private static int[] stripLeadingZeroInts(int[] var0) {
      int var1 = var0.length;

      int var2;
      for(var2 = 0; var2 < var0.length && var0[var2] == 0; ++var2) {
      }

      int[] var3 = new int[var0.length - var2];

      for(int var4 = 0; var4 < var0.length - var2; ++var4) {
         var3[var4] = var0[var2 + var4];
      }

      return var3;
   }

   private static int[] trustedStripLeadingZeroInts(int[] var0) {
      int var1 = var0.length;

      int var2;
      for(var2 = 0; var2 < var0.length && var0[var2] == 0; ++var2) {
      }

      if (var2 <= 0) {
         return var0;
      } else {
         int[] var3 = new int[var0.length - var2];

         for(int var4 = 0; var4 < var0.length - var2; ++var4) {
            var3[var4] = var0[var2 + var4];
         }

         return var3;
      }
   }

   private static int[] stripLeadingZeroBytes(byte[] var0) {
      int var1 = var0.length;

      int var2;
      for(var2 = 0; var2 < var0.length && var0[var2] == 0; ++var2) {
      }

      int var3 = (var1 - var2 + 3) / 4;
      int[] var4 = new int[var3];
      int var5 = var1 - 1;

      for(int var6 = var3 - 1; var6 >= 0; --var6) {
         var4[var6] = var0[var5--] & 255;
         int var7 = var5 - var2 + 1;
         int var8 = Math.min(3, var7);

         for(int var9 = 8; var9 <= 8 * var8; var9 += 8) {
            var4[var6] |= (var0[var5--] & 255) << var9;
         }
      }

      return var4;
   }

   private static int[] makePositive(byte[] var0) {
      int var3 = var0.length;

      int var1;
      for(var1 = 0; var1 < var3 && var0[var1] == -1; ++var1) {
      }

      int var2;
      for(var2 = var1; var2 < var3 && var0[var2] == 0; ++var2) {
      }

      int var4 = var2 == var3 ? 1 : 0;
      int var5 = (var3 - var1 + var4 + 3) / 4;
      int[] var6 = new int[var5];
      int var7 = var3 - 1;

      for(int var8 = var5 - 1; var8 >= 0; --var8) {
         var6[var8] = var0[var7--] & 255;
         int var9 = Math.min(3, var7 - var1 + 1);
         if (var9 < 0) {
            var9 = 0;
         }

         for(int var10 = 8; var10 <= 8 * var9; var10 += 8) {
            var6[var8] |= (var0[var7--] & 255) << var10;
         }

         int var11 = -1 >>> 8 * (3 - var9);
         var6[var8] = ~var6[var8] & var11;
      }

      for(int var12 = var6.length - 1; var12 >= 0; --var12) {
         var6[var12] = (int)(((long)var6[var12] & 4294967295L) + 1L);
         if (var6[var12] != 0) {
            break;
         }
      }

      return var6;
   }

   private static int[] makePositive(int[] var0) {
      int var1;
      for(var1 = 0; var1 < var0.length && var0[var1] == -1; ++var1) {
      }

      int var2;
      for(var2 = var1; var2 < var0.length && var0[var2] == 0; ++var2) {
      }

      int var3 = var2 == var0.length ? 1 : 0;
      int[] var4 = new int[var0.length - var1 + var3];

      for(int var5 = var1; var5 < var0.length; ++var5) {
         var4[var5 - var1 + var3] = ~var0[var5];
      }

      for(int var6 = var4.length - 1; ++var4[var6] == 0; --var6) {
      }

      return var4;
   }

   private int intLength() {
      return this.bitLength() / 32 + 1;
   }

   private int signBit() {
      return this.signum < 0 ? 1 : 0;
   }

   private int signInt() {
      return this.signum < 0 ? -1 : 0;
   }

   private int getInt(int var1) {
      if (var1 < 0) {
         return 0;
      } else if (var1 >= this.mag.length) {
         return this.signInt();
      } else {
         int var2 = this.mag[this.mag.length - var1 - 1];
         return this.signum >= 0 ? var2 : (var1 <= this.firstNonzeroIntNum() ? -var2 : ~var2);
      }
   }

   private int firstNonzeroIntNum() {
      if (this.firstNonzeroIntNum == -2) {
         int var1;
         for(var1 = this.mag.length - 1; var1 >= 0 && this.mag[var1] == 0; --var1) {
         }

         this.firstNonzeroIntNum = this.mag.length - var1 - 1;
      }

      return this.firstNonzeroIntNum;
   }

   private void readObject(ObjectInputStream var1) throws IOException, ClassNotFoundException {
      var1.defaultReadObject();
      if (this.signum >= -1 && this.signum <= 1) {
         if (this.magnitude.length == 0 != (this.signum == 0)) {
            throw new StreamCorruptedException("BigInteger: signum-magnitude mismatch");
         } else {
            this.bitCount = this.bitLength = -1;
            this.lowestSetBit = this.firstNonzeroByteNum = -2;
            this.mag = stripLeadingZeroBytes(this.magnitude);
            this.magnitude = null;
         }
      } else {
         throw new StreamCorruptedException("BigInteger: Invalid signum value");
      }
   }

   private synchronized Object writeReplace() {
      if (this.magnitude == null) {
         this.magnitude = this.magSerializedForm();
      }

      return this;
   }

   private byte[] magSerializedForm() {
      int var1 = this.mag.length == 0 ? 0 : (this.mag.length - 1 << 5) + bitLen(this.mag[0]);
      int var2 = (var1 + 7) / 8;
      byte[] var3 = new byte[var2];
      int var4 = var2 - 1;
      int var5 = 4;
      int var6 = this.mag.length - 1;

      for(int var7 = 0; var4 >= 0; --var4) {
         if (var5 == 4) {
            var7 = this.mag[var6--];
            var5 = 1;
         } else {
            var7 >>>= 8;
            ++var5;
         }

         var3[var4] = (byte)var7;
      }

      return var3;
   }

   static {
      for(int var0 = 1; var0 <= 16; ++var0) {
         int[] var1 = new int[]{var0};
         posConst[var0] = new BigInteger(var1, 1);
         negConst[var0] = new BigInteger(var1, -1);
      }

      ZERO = new BigInteger(new int[0], 0);
      ONE = valueOf(1L);
      TWO = valueOf(2L);
      bnExpModThreshTable = new int[]{7, 25, 81, 241, 673, 1793, Integer.MAX_VALUE};
      trailingZeroTable = new byte[]{-25, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 7, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0};
      zeros = new String[64];
      zeros[63] = "000000000000000000000000000000000000000000000000000000000000000";

      for(int var2 = 0; var2 < 63; ++var2) {
         zeros[var2] = zeros[63].substring(0, var2);
      }

      digitsPerLong = new int[]{0, 0, 62, 39, 31, 27, 24, 22, 20, 19, 18, 18, 17, 17, 16, 16, 15, 15, 15, 14, 14, 14, 14, 13, 13, 13, 13, 13, 13, 12, 12, 12, 12, 12, 12, 12, 12};
      longRadix = new BigInteger[]{null, null, valueOf(4611686018427387904L), valueOf(4052555153018976267L), valueOf(4611686018427387904L), valueOf(7450580596923828125L), valueOf(4738381338321616896L), valueOf(3909821048582988049L), valueOf(1152921504606846976L), valueOf(1350851717672992089L), valueOf(1000000000000000000L), valueOf(5559917313492231481L), valueOf(2218611106740436992L), valueOf(8650415919381337933L), valueOf(2177953337809371136L), valueOf(6568408355712890625L), valueOf(1152921504606846976L), valueOf(2862423051509815793L), valueOf(6746640616477458432L), valueOf(799006685782884121L), valueOf(1638400000000000000L), valueOf(3243919932521508681L), valueOf(6221821273427820544L), valueOf(504036361936467383L), valueOf(876488338465357824L), valueOf(1490116119384765625L), valueOf(2481152873203736576L), valueOf(4052555153018976267L), valueOf(6502111422497947648L), valueOf(353814783205469041L), valueOf(531441000000000000L), valueOf(787662783788549761L), valueOf(1152921504606846976L), valueOf(1667889514952984961L), valueOf(2386420683693101056L), valueOf(3379220508056640625L), valueOf(4738381338321616896L)};
   }
}