home *** CD-ROM | disk | FTP | other *** search
/ Sky at Night 2007 June / SAN CD 6-2007 CD-ROM 25.iso / pc / Software / AstroGrav_Win / Java / jre1.6.0 / lib / rt.jar / java / math / BigInteger.class (.txt) < prev    next >
Encoding:
Java Class File  |  2006-11-29  |  24.9 KB  |  2,133 lines

  1. package java.math;
  2.  
  3. import java.io.IOException;
  4. import java.io.ObjectInputStream;
  5. import java.io.ObjectOutputStream;
  6. import java.io.ObjectStreamField;
  7. import java.io.StreamCorruptedException;
  8. import java.security.SecureRandom;
  9. import java.util.Random;
  10.  
  11. public class BigInteger extends Number implements Comparable<BigInteger> {
  12.    int signum;
  13.    int[] mag;
  14.    private int bitCount;
  15.    private int bitLength;
  16.    private int lowestSetBit;
  17.    private int firstNonzeroByteNum;
  18.    private int firstNonzeroIntNum;
  19.    private static final long LONG_MASK = 4294967295L;
  20.    private static long[] bitsPerDigit = new long[]{0L, 0L, 1024L, 1624L, 2048L, 2378L, 2648L, 2875L, 3072L, 3247L, 3402L, 3543L, 3672L, 3790L, 3899L, 4001L, 4096L, 4186L, 4271L, 4350L, 4426L, 4498L, 4567L, 4633L, 4696L, 4756L, 4814L, 4870L, 4923L, 4975L, 5025L, 5074L, 5120L, 5166L, 5210L, 5253L, 5295L};
  21.    private static final int SMALL_PRIME_THRESHOLD = 95;
  22.    private static final int DEFAULT_PRIME_CERTAINTY = 100;
  23.    private static final BigInteger SMALL_PRIME_PRODUCT = valueOf(152125131763605L);
  24.    private static volatile Random staticRandom;
  25.    private static final int MAX_CONSTANT = 16;
  26.    private static BigInteger[] posConst = new BigInteger[17];
  27.    private static BigInteger[] negConst = new BigInteger[17];
  28.    public static final BigInteger ZERO;
  29.    public static final BigInteger ONE;
  30.    private static final BigInteger TWO;
  31.    public static final BigInteger TEN;
  32.    static int[] bnExpModThreshTable;
  33.    static final byte[] trailingZeroTable;
  34.    private static String[] zeros;
  35.    private static int[] digitsPerLong;
  36.    private static BigInteger[] longRadix;
  37.    private static int[] digitsPerInt;
  38.    private static int[] intRadix;
  39.    private static final long serialVersionUID = -8287574255936472291L;
  40.    private static final ObjectStreamField[] serialPersistentFields;
  41.  
  42.    public BigInteger(byte[] var1) {
  43.       this.bitCount = -1;
  44.       this.bitLength = -1;
  45.       this.lowestSetBit = -2;
  46.       this.firstNonzeroByteNum = -2;
  47.       this.firstNonzeroIntNum = -2;
  48.       if (var1.length == 0) {
  49.          throw new NumberFormatException("Zero length BigInteger");
  50.       } else {
  51.          if (var1[0] < 0) {
  52.             this.mag = makePositive(var1);
  53.             this.signum = -1;
  54.          } else {
  55.             this.mag = stripLeadingZeroBytes(var1);
  56.             this.signum = this.mag.length == 0 ? 0 : 1;
  57.          }
  58.  
  59.       }
  60.    }
  61.  
  62.    private BigInteger(int[] var1) {
  63.       this.bitCount = -1;
  64.       this.bitLength = -1;
  65.       this.lowestSetBit = -2;
  66.       this.firstNonzeroByteNum = -2;
  67.       this.firstNonzeroIntNum = -2;
  68.       if (var1.length == 0) {
  69.          throw new NumberFormatException("Zero length BigInteger");
  70.       } else {
  71.          if (var1[0] < 0) {
  72.             this.mag = makePositive(var1);
  73.             this.signum = -1;
  74.          } else {
  75.             this.mag = trustedStripLeadingZeroInts(var1);
  76.             this.signum = this.mag.length == 0 ? 0 : 1;
  77.          }
  78.  
  79.       }
  80.    }
  81.  
  82.    public BigInteger(int var1, byte[] var2) {
  83.       this.bitCount = -1;
  84.       this.bitLength = -1;
  85.       this.lowestSetBit = -2;
  86.       this.firstNonzeroByteNum = -2;
  87.       this.firstNonzeroIntNum = -2;
  88.       this.mag = stripLeadingZeroBytes(var2);
  89.       if (var1 >= -1 && var1 <= 1) {
  90.          if (this.mag.length == 0) {
  91.             this.signum = 0;
  92.          } else {
  93.             if (var1 == 0) {
  94.                throw new NumberFormatException("signum-magnitude mismatch");
  95.             }
  96.  
  97.             this.signum = var1;
  98.          }
  99.  
  100.       } else {
  101.          throw new NumberFormatException("Invalid signum value");
  102.       }
  103.    }
  104.  
  105.    private BigInteger(int var1, int[] var2) {
  106.       this.bitCount = -1;
  107.       this.bitLength = -1;
  108.       this.lowestSetBit = -2;
  109.       this.firstNonzeroByteNum = -2;
  110.       this.firstNonzeroIntNum = -2;
  111.       this.mag = stripLeadingZeroInts(var2);
  112.       if (var1 >= -1 && var1 <= 1) {
  113.          if (this.mag.length == 0) {
  114.             this.signum = 0;
  115.          } else {
  116.             if (var1 == 0) {
  117.                throw new NumberFormatException("signum-magnitude mismatch");
  118.             }
  119.  
  120.             this.signum = var1;
  121.          }
  122.  
  123.       } else {
  124.          throw new NumberFormatException("Invalid signum value");
  125.       }
  126.    }
  127.  
  128.    public BigInteger(String var1, int var2) {
  129.       this.bitCount = -1;
  130.       this.bitLength = -1;
  131.       this.lowestSetBit = -2;
  132.       this.firstNonzeroByteNum = -2;
  133.       this.firstNonzeroIntNum = -2;
  134.       int var3 = 0;
  135.       int var5 = var1.length();
  136.       if (var2 >= 2 && var2 <= 36) {
  137.          if (var1.length() == 0) {
  138.             throw new NumberFormatException("Zero length BigInteger");
  139.          } else {
  140.             this.signum = 1;
  141.             int var6 = var1.lastIndexOf("-");
  142.             if (var6 != -1) {
  143.                if (var6 != 0) {
  144.                   throw new NumberFormatException("Illegal embedded minus sign");
  145.                }
  146.  
  147.                if (var1.length() == 1) {
  148.                   throw new NumberFormatException("Zero length BigInteger");
  149.                }
  150.  
  151.                this.signum = -1;
  152.                var3 = 1;
  153.             }
  154.  
  155.             while(var3 < var5 && Character.digit(var1.charAt(var3), var2) == 0) {
  156.                ++var3;
  157.             }
  158.  
  159.             if (var3 == var5) {
  160.                this.signum = 0;
  161.                this.mag = ZERO.mag;
  162.             } else {
  163.                int var4 = var5 - var3;
  164.                int var7 = (int)(((long)var4 * bitsPerDigit[var2] >>> 10) + 1L);
  165.                int var8 = (var7 + 31) / 32;
  166.                this.mag = new int[var8];
  167.                int var9 = var4 % digitsPerInt[var2];
  168.                if (var9 == 0) {
  169.                   var9 = digitsPerInt[var2];
  170.                }
  171.  
  172.                int var13;
  173.                String var10 = var1.substring(var3, var13 = var3 + var9);
  174.                this.mag[this.mag.length - 1] = Integer.parseInt(var10, var2);
  175.                if (this.mag[this.mag.length - 1] < 0) {
  176.                   throw new NumberFormatException("Illegal digit");
  177.                } else {
  178.                   int var11 = intRadix[var2];
  179.                   int var12 = 0;
  180.  
  181.                   while(var13 < var1.length()) {
  182.                      var10 = var1.substring(var13, var13 += digitsPerInt[var2]);
  183.                      var12 = Integer.parseInt(var10, var2);
  184.                      if (var12 < 0) {
  185.                         throw new NumberFormatException("Illegal digit");
  186.                      }
  187.  
  188.                      destructiveMulAdd(this.mag, var11, var12);
  189.                   }
  190.  
  191.                   this.mag = trustedStripLeadingZeroInts(this.mag);
  192.                }
  193.             }
  194.          }
  195.       } else {
  196.          throw new NumberFormatException("Radix out of range");
  197.       }
  198.    }
  199.  
  200.    BigInteger(char[] var1) {
  201.       this.bitCount = -1;
  202.       this.bitLength = -1;
  203.       this.lowestSetBit = -2;
  204.       this.firstNonzeroByteNum = -2;
  205.       this.firstNonzeroIntNum = -2;
  206.       int var2 = 0;
  207.       int var4 = var1.length;
  208.       this.signum = 1;
  209.       if (var1[0] == '-') {
  210.          if (var4 == 1) {
  211.             throw new NumberFormatException("Zero length BigInteger");
  212.          }
  213.  
  214.          this.signum = -1;
  215.          var2 = 1;
  216.       }
  217.  
  218.       while(var2 < var4 && Character.digit(var1[var2], 10) == 0) {
  219.          ++var2;
  220.       }
  221.  
  222.       if (var2 == var4) {
  223.          this.signum = 0;
  224.          this.mag = ZERO.mag;
  225.       } else {
  226.          int var3 = var4 - var2;
  227.          int var5;
  228.          if (var4 < 10) {
  229.             var5 = 1;
  230.          } else {
  231.             int var6 = (int)(((long)var3 * bitsPerDigit[10] >>> 10) + 1L);
  232.             var5 = (var6 + 31) / 32;
  233.          }
  234.  
  235.          this.mag = new int[var5];
  236.          int var9 = var3 % digitsPerInt[10];
  237.          if (var9 == 0) {
  238.             var9 = digitsPerInt[10];
  239.          }
  240.  
  241.          int var8;
  242.          this.mag[this.mag.length - 1] = this.parseInt(var1, var2, var8 = var2 + var9);
  243.  
  244.          while(var8 < var4) {
  245.             int var7 = this.parseInt(var1, var8, var8 += digitsPerInt[10]);
  246.             destructiveMulAdd(this.mag, intRadix[10], var7);
  247.          }
  248.  
  249.          this.mag = trustedStripLeadingZeroInts(this.mag);
  250.       }
  251.    }
  252.  
  253.    private int parseInt(char[] var1, int var2, int var3) {
  254.       int var4 = Character.digit(var1[var2++], 10);
  255.       if (var4 == -1) {
  256.          throw new NumberFormatException(new String(var1));
  257.       } else {
  258.          for(int var5 = var2; var5 < var3; ++var5) {
  259.             int var6 = Character.digit(var1[var5], 10);
  260.             if (var6 == -1) {
  261.                throw new NumberFormatException(new String(var1));
  262.             }
  263.  
  264.             var4 = 10 * var4 + var6;
  265.          }
  266.  
  267.          return var4;
  268.       }
  269.    }
  270.  
  271.    private static void destructiveMulAdd(int[] var0, int var1, int var2) {
  272.       long var3 = (long)var1 & 4294967295L;
  273.       long var5 = (long)var2 & 4294967295L;
  274.       int var7 = var0.length;
  275.       long var8 = 0L;
  276.       long var10 = 0L;
  277.  
  278.       for(int var12 = var7 - 1; var12 >= 0; --var12) {
  279.          var8 = var3 * ((long)var0[var12] & 4294967295L) + var10;
  280.          var0[var12] = (int)var8;
  281.          var10 = var8 >>> 32;
  282.       }
  283.  
  284.       long var17 = ((long)var0[var7 - 1] & 4294967295L) + var5;
  285.       var0[var7 - 1] = (int)var17;
  286.       var10 = var17 >>> 32;
  287.  
  288.       for(int var14 = var7 - 2; var14 >= 0; --var14) {
  289.          var17 = ((long)var0[var14] & 4294967295L) + var10;
  290.          var0[var14] = (int)var17;
  291.          var10 = var17 >>> 32;
  292.       }
  293.  
  294.    }
  295.  
  296.    public BigInteger(String var1) {
  297.       this((String)var1, 10);
  298.    }
  299.  
  300.    public BigInteger(int var1, Random var2) {
  301.       this(1, (byte[])randomBits(var1, var2));
  302.    }
  303.  
  304.    private static byte[] randomBits(int var0, Random var1) {
  305.       if (var0 < 0) {
  306.          throw new IllegalArgumentException("numBits must be non-negative");
  307.       } else {
  308.          int var2 = (int)(((long)var0 + 7L) / 8L);
  309.          byte[] var3 = new byte[var2];
  310.          if (var2 > 0) {
  311.             var1.nextBytes(var3);
  312.             int var4 = 8 * var2 - var0;
  313.             var3[0] = (byte)(var3[0] & (1 << 8 - var4) - 1);
  314.          }
  315.  
  316.          return var3;
  317.       }
  318.    }
  319.  
  320.    public BigInteger(int var1, int var2, Random var3) {
  321.       this.bitCount = -1;
  322.       this.bitLength = -1;
  323.       this.lowestSetBit = -2;
  324.       this.firstNonzeroByteNum = -2;
  325.       this.firstNonzeroIntNum = -2;
  326.       if (var1 < 2) {
  327.          throw new ArithmeticException("bitLength < 2");
  328.       } else {
  329.          BigInteger var4 = var1 < 95 ? smallPrime(var1, var2, var3) : largePrime(var1, var2, var3);
  330.          this.signum = 1;
  331.          this.mag = var4.mag;
  332.       }
  333.    }
  334.  
  335.    public static BigInteger probablePrime(int var0, Random var1) {
  336.       if (var0 < 2) {
  337.          throw new ArithmeticException("bitLength < 2");
  338.       } else {
  339.          return var0 < 95 ? smallPrime(var0, 100, var1) : largePrime(var0, 100, var1);
  340.       }
  341.    }
  342.  
  343.    private static BigInteger smallPrime(int var0, int var1, Random var2) {
  344.       int var3 = var0 + 31 >>> 5;
  345.       int[] var4 = new int[var3];
  346.       int var5 = 1 << (var0 + 31 & 31);
  347.       int var6 = (var5 << 1) - 1;
  348.  
  349.       while(true) {
  350.          for(int var7 = 0; var7 < var3; ++var7) {
  351.             var4[var7] = var2.nextInt();
  352.          }
  353.  
  354.          var4[0] = var4[0] & var6 | var5;
  355.          if (var0 > 2) {
  356.             var4[var3 - 1] |= 1;
  357.          }
  358.  
  359.          BigInteger var10 = new BigInteger(var4, 1);
  360.          if (var0 > 6) {
  361.             long var8 = var10.remainder(SMALL_PRIME_PRODUCT).longValue();
  362.             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) {
  363.                continue;
  364.             }
  365.          }
  366.  
  367.          if (var0 < 4) {
  368.             return var10;
  369.          }
  370.  
  371.          if (var10.primeToCertainty(var1, var2)) {
  372.             return var10;
  373.          }
  374.       }
  375.    }
  376.  
  377.    private static BigInteger largePrime(int var0, int var1, Random var2) {
  378.       BigInteger var3 = (new BigInteger(var0, var2)).setBit(var0 - 1);
  379.       int[] var10000 = var3.mag;
  380.       int var10001 = var3.mag.length - 1;
  381.       var10000[var10001] &= -2;
  382.       int var4 = var0 / 20 * 64;
  383.       BitSieve var5 = new BitSieve(var3, var4);
  384.  
  385.       BigInteger var6;
  386.       for(var6 = var5.retrieve(var3, var1, var2); var6 == null || var6.bitLength() != var0; var6 = var5.retrieve(var3, var1, var2)) {
  387.          var3 = var3.add(valueOf((long)(2 * var4)));
  388.          if (var3.bitLength() != var0) {
  389.             var3 = (new BigInteger(var0, var2)).setBit(var0 - 1);
  390.          }
  391.  
  392.          var10000 = var3.mag;
  393.          var10001 = var3.mag.length - 1;
  394.          var10000[var10001] &= -2;
  395.          var5 = new BitSieve(var3, var4);
  396.       }
  397.  
  398.       return var6;
  399.    }
  400.  
  401.    public BigInteger nextProbablePrime() {
  402.       if (this.signum < 0) {
  403.          throw new ArithmeticException("start < 0: " + this);
  404.       } else if (this.signum != 0 && !this.equals(ONE)) {
  405.          BigInteger var1 = this.add(ONE);
  406.          if (var1.bitLength() < 95) {
  407.             if (!var1.testBit(0)) {
  408.                var1 = var1.add(ONE);
  409.             }
  410.  
  411.             while(true) {
  412.                if (var1.bitLength() > 6) {
  413.                   long var5 = var1.remainder(SMALL_PRIME_PRODUCT).longValue();
  414.                   if (var5 % 3L == 0L || var5 % 5L == 0L || var5 % 7L == 0L || var5 % 11L == 0L || var5 % 13L == 0L || var5 % 17L == 0L || var5 % 19L == 0L || var5 % 23L == 0L || var5 % 29L == 0L || var5 % 31L == 0L || var5 % 37L == 0L || var5 % 41L == 0L) {
  415.                      var1 = var1.add(TWO);
  416.                      continue;
  417.                   }
  418.                }
  419.  
  420.                if (var1.bitLength() < 4) {
  421.                   return var1;
  422.                }
  423.  
  424.                if (var1.primeToCertainty(100, (Random)null)) {
  425.                   return var1;
  426.                }
  427.  
  428.                var1 = var1.add(TWO);
  429.             }
  430.          } else {
  431.             if (var1.testBit(0)) {
  432.                var1 = var1.subtract(ONE);
  433.             }
  434.  
  435.             int var2 = var1.bitLength() / 20 * 64;
  436.  
  437.             while(true) {
  438.                BitSieve var3 = new BitSieve(var1, var2);
  439.                BigInteger var4 = var3.retrieve(var1, 100, (Random)null);
  440.                if (var4 != null) {
  441.                   return var4;
  442.                }
  443.  
  444.                var1 = var1.add(valueOf((long)(2 * var2)));
  445.             }
  446.          }
  447.       } else {
  448.          return TWO;
  449.       }
  450.    }
  451.  
  452.    boolean primeToCertainty(int var1, Random var2) {
  453.       int var3 = 0;
  454.       int var4 = (Math.min(var1, 2147483646) + 1) / 2;
  455.       int var5 = this.bitLength();
  456.       if (var5 < 100) {
  457.          var3 = (byte)50;
  458.          var3 = var4 < var3 ? var4 : var3;
  459.          return this.passesMillerRabin(var3, var2);
  460.       } else {
  461.          if (var5 < 256) {
  462.             var3 = 27;
  463.          } else if (var5 < 512) {
  464.             var3 = 15;
  465.          } else if (var5 < 768) {
  466.             var3 = 8;
  467.          } else if (var5 < 1024) {
  468.             var3 = 4;
  469.          } else {
  470.             var3 = 2;
  471.          }
  472.  
  473.          var3 = var4 < var3 ? var4 : var3;
  474.          return this.passesMillerRabin(var3, var2) && this.passesLucasLehmer();
  475.       }
  476.    }
  477.  
  478.    private boolean passesLucasLehmer() {
  479.       BigInteger var1 = this.add(ONE);
  480.  
  481.       int var2;
  482.       for(var2 = 5; jacobiSymbol(var2, this) != -1; var2 = var2 < 0 ? Math.abs(var2) + 2 : -(var2 + 2)) {
  483.       }
  484.  
  485.       BigInteger var3 = lucasLehmerSequence(var2, var1, this);
  486.       return var3.mod(this).equals(ZERO);
  487.    }
  488.  
  489.    private static int jacobiSymbol(int var0, BigInteger var1) {
  490.       if (var0 == 0) {
  491.          return 0;
  492.       } else {
  493.          int var2 = 1;
  494.          int var3 = var1.mag[var1.mag.length - 1];
  495.          if (var0 < 0) {
  496.             var0 = -var0;
  497.             int var4 = var3 & 7;
  498.             if (var4 == 3 || var4 == 7) {
  499.                var2 = -var2;
  500.             }
  501.          }
  502.  
  503.          while((var0 & 3) == 0) {
  504.             var0 >>= 2;
  505.          }
  506.  
  507.          if ((var0 & 1) == 0) {
  508.             var0 >>= 1;
  509.             if (((var3 ^ var3 >> 1) & 2) != 0) {
  510.                var2 = -var2;
  511.             }
  512.          }
  513.  
  514.          if (var0 == 1) {
  515.             return var2;
  516.          } else {
  517.             if ((var0 & var3 & 2) != 0) {
  518.                var2 = -var2;
  519.             }
  520.  
  521.             int var7;
  522.             for(var3 = var1.mod(valueOf((long)var0)).intValue(); var3 != 0; var3 %= var7) {
  523.                while((var3 & 3) == 0) {
  524.                   var3 >>= 2;
  525.                }
  526.  
  527.                if ((var3 & 1) == 0) {
  528.                   var3 >>= 1;
  529.                   if (((var0 ^ var0 >> 1) & 2) != 0) {
  530.                      var2 = -var2;
  531.                   }
  532.                }
  533.  
  534.                if (var3 == 1) {
  535.                   return var2;
  536.                }
  537.  
  538.                assert var3 < var0;
  539.  
  540.                var7 = var3;
  541.                var3 = var0;
  542.                var0 = var7;
  543.                if ((var3 & var7 & 2) != 0) {
  544.                   var2 = -var2;
  545.                }
  546.             }
  547.  
  548.             return 0;
  549.          }
  550.       }
  551.    }
  552.  
  553.    private static BigInteger lucasLehmerSequence(int var0, BigInteger var1, BigInteger var2) {
  554.       BigInteger var3 = valueOf((long)var0);
  555.       BigInteger var4 = ONE;
  556.       BigInteger var6 = ONE;
  557.  
  558.       for(int var8 = var1.bitLength() - 2; var8 >= 0; --var8) {
  559.          BigInteger var5 = var4.multiply(var6).mod(var2);
  560.          BigInteger var7 = var6.square().add(var3.multiply(var4.square())).mod(var2);
  561.          if (var7.testBit(0)) {
  562.             var7 = var2.subtract(var7);
  563.             var7.signum = -var7.signum;
  564.          }
  565.  
  566.          var7 = var7.shiftRight(1);
  567.          var4 = var5;
  568.          var6 = var7;
  569.          if (var1.testBit(var8)) {
  570.             var5 = var5.add(var7).mod(var2);
  571.             if (var5.testBit(0)) {
  572.                var5 = var2.subtract(var5);
  573.                var5.signum = -var5.signum;
  574.             }
  575.  
  576.             BigInteger var10 = var5.shiftRight(1);
  577.             var7 = var7.add(var3.multiply(var5)).mod(var2);
  578.             if (var7.testBit(0)) {
  579.                var7 = var2.subtract(var7);
  580.                var7.signum = -var7.signum;
  581.             }
  582.  
  583.             var7 = var7.shiftRight(1);
  584.             var4 = var10;
  585.             var6 = var7;
  586.          }
  587.       }
  588.  
  589.       return var4;
  590.    }
  591.  
  592.    private static Random getSecureRandom() {
  593.       if (staticRandom == null) {
  594.          staticRandom = new SecureRandom();
  595.       }
  596.  
  597.       return staticRandom;
  598.    }
  599.  
  600.    private boolean passesMillerRabin(int var1, Random var2) {
  601.       BigInteger var3 = this.subtract(ONE);
  602.       int var5 = var3.getLowestSetBit();
  603.       BigInteger var4 = var3.shiftRight(var5);
  604.       if (var2 == null) {
  605.          var2 = getSecureRandom();
  606.       }
  607.  
  608.       for(int var6 = 0; var6 < var1; ++var6) {
  609.          BigInteger var7;
  610.          do {
  611.             var7 = new BigInteger(this.bitLength(), var2);
  612.          } while(var7.compareTo(ONE) <= 0 || var7.compareTo(this) >= 0);
  613.  
  614.          int var8 = 0;
  615.  
  616.          for(BigInteger var9 = var7.modPow(var4, this); (var8 != 0 || !var9.equals(ONE)) && !var9.equals(var3); var9 = var9.modPow(TWO, this)) {
  617.             if (var8 > 0 && var9.equals(ONE)) {
  618.                return false;
  619.             }
  620.  
  621.             ++var8;
  622.             if (var8 == var5) {
  623.                return false;
  624.             }
  625.          }
  626.       }
  627.  
  628.       return true;
  629.    }
  630.  
  631.    private BigInteger(int[] var1, int var2) {
  632.       this.bitCount = -1;
  633.       this.bitLength = -1;
  634.       this.lowestSetBit = -2;
  635.       this.firstNonzeroByteNum = -2;
  636.       this.firstNonzeroIntNum = -2;
  637.       this.signum = var1.length == 0 ? 0 : var2;
  638.       this.mag = var1;
  639.    }
  640.  
  641.    private BigInteger(byte[] var1, int var2) {
  642.       this.bitCount = -1;
  643.       this.bitLength = -1;
  644.       this.lowestSetBit = -2;
  645.       this.firstNonzeroByteNum = -2;
  646.       this.firstNonzeroIntNum = -2;
  647.       this.signum = var1.length == 0 ? 0 : var2;
  648.       this.mag = stripLeadingZeroBytes(var1);
  649.    }
  650.  
  651.    BigInteger(MutableBigInteger var1, int var2) {
  652.       this.bitCount = -1;
  653.       this.bitLength = -1;
  654.       this.lowestSetBit = -2;
  655.       this.firstNonzeroByteNum = -2;
  656.       this.firstNonzeroIntNum = -2;
  657.       if (var1.offset <= 0 && var1.value.length == var1.intLen) {
  658.          this.mag = var1.value;
  659.       } else {
  660.          this.mag = new int[var1.intLen];
  661.  
  662.          for(int var3 = 0; var3 < var1.intLen; ++var3) {
  663.             this.mag[var3] = var1.value[var1.offset + var3];
  664.          }
  665.       }
  666.  
  667.       this.signum = var1.intLen == 0 ? 0 : var2;
  668.    }
  669.  
  670.    public static BigInteger valueOf(long var0) {
  671.       if (var0 == 0L) {
  672.          return ZERO;
  673.       } else if (var0 > 0L && var0 <= 16L) {
  674.          return posConst[(int)var0];
  675.       } else {
  676.          return var0 < 0L && var0 >= -16L ? negConst[(int)(-var0)] : new BigInteger(var0);
  677.       }
  678.    }
  679.  
  680.    private BigInteger(long var1) {
  681.       this.bitCount = -1;
  682.       this.bitLength = -1;
  683.       this.lowestSetBit = -2;
  684.       this.firstNonzeroByteNum = -2;
  685.       this.firstNonzeroIntNum = -2;
  686.       if (var1 < 0L) {
  687.          this.signum = -1;
  688.          var1 = -var1;
  689.       } else {
  690.          this.signum = 1;
  691.       }
  692.  
  693.       int var3 = (int)(var1 >>> 32);
  694.       if (var3 == 0) {
  695.          this.mag = new int[1];
  696.          this.mag[0] = (int)var1;
  697.       } else {
  698.          this.mag = new int[2];
  699.          this.mag[0] = var3;
  700.          this.mag[1] = (int)var1;
  701.       }
  702.  
  703.    }
  704.  
  705.    private static BigInteger valueOf(int[] var0) {
  706.       return var0[0] > 0 ? new BigInteger(var0, 1) : new BigInteger(var0);
  707.    }
  708.  
  709.    public BigInteger add(BigInteger var1) {
  710.       if (var1.signum == 0) {
  711.          return this;
  712.       } else if (this.signum == 0) {
  713.          return var1;
  714.       } else if (var1.signum == this.signum) {
  715.          return new BigInteger(add(this.mag, var1.mag), this.signum);
  716.       } else {
  717.          int var3 = intArrayCmp(this.mag, var1.mag);
  718.          if (var3 == 0) {
  719.             return ZERO;
  720.          } else {
  721.             int[] var2 = var3 > 0 ? subtract(this.mag, var1.mag) : subtract(var1.mag, this.mag);
  722.             var2 = trustedStripLeadingZeroInts(var2);
  723.             return new BigInteger(var2, var3 * this.signum);
  724.          }
  725.       }
  726.    }
  727.  
  728.    private static int[] add(int[] var0, int[] var1) {
  729.       if (var0.length < var1.length) {
  730.          int[] var2 = var0;
  731.          var0 = var1;
  732.          var1 = var2;
  733.       }
  734.  
  735.       int var11 = var0.length;
  736.       int var3 = var1.length;
  737.       int[] var4 = new int[var11];
  738.  
  739.       long var5;
  740.       for(var5 = 0L; var3 > 0; var4[var11] = (int)var5) {
  741.          --var11;
  742.          long var10000 = (long)var0[var11] & 4294967295L;
  743.          --var3;
  744.          var5 = var10000 + ((long)var1[var3] & 4294967295L) + (var5 >>> 32);
  745.       }
  746.  
  747.       boolean var7;
  748.       for(var7 = var5 >>> 32 != 0L; var11 > 0 && var7; var7 = (var4[var11] = var0[var11] + 1) == 0) {
  749.          --var11;
  750.       }
  751.  
  752.       while(var11 > 0) {
  753.          --var11;
  754.          var4[var11] = var0[var11];
  755.       }
  756.  
  757.       if (var7) {
  758.          int var8 = var4.length + 1;
  759.          int[] var9 = new int[var8];
  760.  
  761.          for(int var10 = 1; var10 < var8; ++var10) {
  762.             var9[var10] = var4[var10 - 1];
  763.          }
  764.  
  765.          var9[0] = 1;
  766.          var4 = var9;
  767.       }
  768.  
  769.       return var4;
  770.    }
  771.  
  772.    public BigInteger subtract(BigInteger var1) {
  773.       if (var1.signum == 0) {
  774.          return this;
  775.       } else if (this.signum == 0) {
  776.          return var1.negate();
  777.       } else if (var1.signum != this.signum) {
  778.          return new BigInteger(add(this.mag, var1.mag), this.signum);
  779.       } else {
  780.          int var3 = intArrayCmp(this.mag, var1.mag);
  781.          if (var3 == 0) {
  782.             return ZERO;
  783.          } else {
  784.             int[] var2 = var3 > 0 ? subtract(this.mag, var1.mag) : subtract(var1.mag, this.mag);
  785.             var2 = trustedStripLeadingZeroInts(var2);
  786.             return new BigInteger(var2, var3 * this.signum);
  787.          }
  788.       }
  789.    }
  790.  
  791.    private static int[] subtract(int[] var0, int[] var1) {
  792.       int var2 = var0.length;
  793.       int[] var3 = new int[var2];
  794.       int var4 = var1.length;
  795.  
  796.       long var5;
  797.       for(var5 = 0L; var4 > 0; var3[var2] = (int)var5) {
  798.          --var2;
  799.          long var10000 = (long)var0[var2] & 4294967295L;
  800.          --var4;
  801.          var5 = var10000 - ((long)var1[var4] & 4294967295L) + (var5 >> 32);
  802.       }
  803.  
  804.       for(boolean var7 = var5 >> 32 != 0L; var2 > 0 && var7; var7 = (var3[var2] = var0[var2] - 1) == -1) {
  805.          --var2;
  806.       }
  807.  
  808.       while(var2 > 0) {
  809.          --var2;
  810.          var3[var2] = var0[var2];
  811.       }
  812.  
  813.       return var3;
  814.    }
  815.  
  816.    public BigInteger multiply(BigInteger var1) {
  817.       if (this.signum != 0 && var1.signum != 0) {
  818.          int[] var2 = this.multiplyToLen(this.mag, this.mag.length, var1.mag, var1.mag.length, (int[])null);
  819.          var2 = trustedStripLeadingZeroInts(var2);
  820.          return new BigInteger(var2, this.signum * var1.signum);
  821.       } else {
  822.          return ZERO;
  823.       }
  824.    }
  825.  
  826.    private int[] multiplyToLen(int[] var1, int var2, int[] var3, int var4, int[] var5) {
  827.       int var6 = var2 - 1;
  828.       int var7 = var4 - 1;
  829.       if (var5 == null || var5.length < var2 + var4) {
  830.          var5 = new int[var2 + var4];
  831.       }
  832.  
  833.       long var8 = 0L;
  834.       int var10 = var7;
  835.  
  836.       for(int var11 = var7 + 1 + var6; var10 >= 0; --var11) {
  837.          long var12 = ((long)var3[var10] & 4294967295L) * ((long)var1[var6] & 4294967295L) + var8;
  838.          var5[var11] = (int)var12;
  839.          var8 = var12 >>> 32;
  840.          --var10;
  841.       }
  842.  
  843.       var5[var6] = (int)var8;
  844.  
  845.       for(int var16 = var6 - 1; var16 >= 0; --var16) {
  846.          var8 = 0L;
  847.          int var17 = var7;
  848.  
  849.          for(int var18 = var7 + 1 + var16; var17 >= 0; --var18) {
  850.             long var13 = ((long)var3[var17] & 4294967295L) * ((long)var1[var16] & 4294967295L) + ((long)var5[var18] & 4294967295L) + var8;
  851.             var5[var18] = (int)var13;
  852.             var8 = var13 >>> 32;
  853.             --var17;
  854.          }
  855.  
  856.          var5[var16] = (int)var8;
  857.       }
  858.  
  859.       return var5;
  860.    }
  861.  
  862.    private BigInteger square() {
  863.       if (this.signum == 0) {
  864.          return ZERO;
  865.       } else {
  866.          int[] var1 = squareToLen(this.mag, this.mag.length, (int[])null);
  867.          return new BigInteger(trustedStripLeadingZeroInts(var1), 1);
  868.       }
  869.    }
  870.  
  871.    private static final int[] squareToLen(int[] var0, int var1, int[] var2) {
  872.       int var3 = var1 << 1;
  873.       if (var2 == null || var2.length < var3) {
  874.          var2 = new int[var3];
  875.       }
  876.  
  877.       int var4 = 0;
  878.       int var5 = 0;
  879.  
  880.       for(int var6 = 0; var5 < var1; ++var5) {
  881.          long var7 = (long)var0[var5] & 4294967295L;
  882.          long var9 = var7 * var7;
  883.          var2[var6++] = var4 << 31 | (int)(var9 >>> 33);
  884.          var2[var6++] = (int)(var9 >>> 1);
  885.          var4 = (int)var9;
  886.       }
  887.  
  888.       var5 = var1;
  889.  
  890.       for(int var13 = 1; var5 > 0; var13 += 2) {
  891.          int var14 = var0[var5 - 1];
  892.          var14 = mulAdd(var2, var0, var13, var5 - 1, var14);
  893.          addOne(var2, var13 - 1, var5, var14);
  894.          --var5;
  895.       }
  896.  
  897.       primitiveLeftShift(var2, var3, 1);
  898.       var2[var3 - 1] |= var0[var1 - 1] & 1;
  899.       return var2;
  900.    }
  901.  
  902.    public BigInteger divide(BigInteger var1) {
  903.       MutableBigInteger var2 = new MutableBigInteger();
  904.       MutableBigInteger var3 = new MutableBigInteger();
  905.       MutableBigInteger var4 = new MutableBigInteger(this.mag);
  906.       MutableBigInteger var5 = new MutableBigInteger(var1.mag);
  907.       var4.divide(var5, var2, var3);
  908.       return new BigInteger(var2, this.signum * var1.signum);
  909.    }
  910.  
  911.    public BigInteger[] divideAndRemainder(BigInteger var1) {
  912.       BigInteger[] var2 = new BigInteger[2];
  913.       MutableBigInteger var3 = new MutableBigInteger();
  914.       MutableBigInteger var4 = new MutableBigInteger();
  915.       MutableBigInteger var5 = new MutableBigInteger(this.mag);
  916.       MutableBigInteger var6 = new MutableBigInteger(var1.mag);
  917.       var5.divide(var6, var3, var4);
  918.       var2[0] = new BigInteger(var3, this.signum * var1.signum);
  919.       var2[1] = new BigInteger(var4, this.signum);
  920.       return var2;
  921.    }
  922.  
  923.    public BigInteger remainder(BigInteger var1) {
  924.       MutableBigInteger var2 = new MutableBigInteger();
  925.       MutableBigInteger var3 = new MutableBigInteger();
  926.       MutableBigInteger var4 = new MutableBigInteger(this.mag);
  927.       MutableBigInteger var5 = new MutableBigInteger(var1.mag);
  928.       var4.divide(var5, var2, var3);
  929.       return new BigInteger(var3, this.signum);
  930.    }
  931.  
  932.    public BigInteger pow(int var1) {
  933.       if (var1 < 0) {
  934.          throw new ArithmeticException("Negative exponent");
  935.       } else if (this.signum == 0) {
  936.          return var1 == 0 ? ONE : this;
  937.       } else {
  938.          int var2 = this.signum < 0 && (var1 & 1) == 1 ? -1 : 1;
  939.          int[] var3 = this.mag;
  940.          int[] var4 = new int[]{1};
  941.  
  942.          while(var1 != 0) {
  943.             if ((var1 & 1) == 1) {
  944.                var4 = this.multiplyToLen(var4, var4.length, var3, var3.length, (int[])null);
  945.                var4 = trustedStripLeadingZeroInts(var4);
  946.             }
  947.  
  948.             if ((var1 >>>= 1) != 0) {
  949.                var3 = squareToLen(var3, var3.length, (int[])null);
  950.                var3 = trustedStripLeadingZeroInts(var3);
  951.             }
  952.          }
  953.  
  954.          return new BigInteger(var4, var2);
  955.       }
  956.    }
  957.  
  958.    public BigInteger gcd(BigInteger var1) {
  959.       if (var1.signum == 0) {
  960.          return this.abs();
  961.       } else if (this.signum == 0) {
  962.          return var1.abs();
  963.       } else {
  964.          MutableBigInteger var2 = new MutableBigInteger(this);
  965.          MutableBigInteger var3 = new MutableBigInteger(var1);
  966.          MutableBigInteger var4 = var2.hybridGCD(var3);
  967.          return new BigInteger(var4, 1);
  968.       }
  969.    }
  970.  
  971.    private static int[] leftShift(int[] var0, int var1, int var2) {
  972.       int var3 = var2 >>> 5;
  973.       int var4 = var2 & 31;
  974.       int var5 = bitLen(var0[0]);
  975.       if (var2 <= 32 - var5) {
  976.          primitiveLeftShift(var0, var1, var4);
  977.          return var0;
  978.       } else if (var4 <= 32 - var5) {
  979.          int[] var8 = new int[var3 + var1];
  980.  
  981.          for(int var9 = 0; var9 < var1; ++var9) {
  982.             var8[var9] = var0[var9];
  983.          }
  984.  
  985.          primitiveLeftShift(var8, var8.length, var4);
  986.          return var8;
  987.       } else {
  988.          int[] var6 = new int[var3 + var1 + 1];
  989.  
  990.          for(int var7 = 0; var7 < var1; ++var7) {
  991.             var6[var7] = var0[var7];
  992.          }
  993.  
  994.          primitiveRightShift(var6, var6.length, 32 - var4);
  995.          return var6;
  996.       }
  997.    }
  998.  
  999.    static void primitiveRightShift(int[] var0, int var1, int var2) {
  1000.       int var3 = 32 - var2;
  1001.       int var4 = var1 - 1;
  1002.  
  1003.       for(int var5 = var0[var4]; var4 > 0; --var4) {
  1004.          int var6 = var5;
  1005.          var5 = var0[var4 - 1];
  1006.          var0[var4] = var5 << var3 | var6 >>> var2;
  1007.       }
  1008.  
  1009.       var0[0] >>>= var2;
  1010.    }
  1011.  
  1012.    static void primitiveLeftShift(int[] var0, int var1, int var2) {
  1013.       if (var1 != 0 && var2 != 0) {
  1014.          int var3 = 32 - var2;
  1015.          int var4 = 0;
  1016.          int var5 = var0[var4];
  1017.  
  1018.          for(int var6 = var4 + var1 - 1; var4 < var6; ++var4) {
  1019.             int var7 = var5;
  1020.             var5 = var0[var4 + 1];
  1021.             var0[var4] = var7 << var2 | var5 >>> var3;
  1022.          }
  1023.  
  1024.          var0[var1 - 1] <<= var2;
  1025.       }
  1026.    }
  1027.  
  1028.    private static int bitLength(int[] var0, int var1) {
  1029.       return var1 == 0 ? 0 : (var1 - 1 << 5) + bitLen(var0[0]);
  1030.    }
  1031.  
  1032.    public BigInteger abs() {
  1033.       return this.signum >= 0 ? this : this.negate();
  1034.    }
  1035.  
  1036.    public BigInteger negate() {
  1037.       return new BigInteger(this.mag, -this.signum);
  1038.    }
  1039.  
  1040.    public int signum() {
  1041.       return this.signum;
  1042.    }
  1043.  
  1044.    public BigInteger mod(BigInteger var1) {
  1045.       if (var1.signum <= 0) {
  1046.          throw new ArithmeticException("BigInteger: modulus not positive");
  1047.       } else {
  1048.          BigInteger var2 = this.remainder(var1);
  1049.          return var2.signum >= 0 ? var2 : var2.add(var1);
  1050.       }
  1051.    }
  1052.  
  1053.    public BigInteger modPow(BigInteger var1, BigInteger var2) {
  1054.       if (var2.signum <= 0) {
  1055.          throw new ArithmeticException("BigInteger: modulus not positive");
  1056.       } else if (var1.signum == 0) {
  1057.          return var2.equals(ONE) ? ZERO : ONE;
  1058.       } else if (this.equals(ONE)) {
  1059.          return var2.equals(ONE) ? ZERO : ONE;
  1060.       } else if (this.equals(ZERO) && var1.signum >= 0) {
  1061.          return ZERO;
  1062.       } else if (this.equals(negConst[1]) && !var1.testBit(0)) {
  1063.          return var2.equals(ONE) ? ZERO : ONE;
  1064.       } else {
  1065.          boolean var3;
  1066.          if (var3 = var1.signum < 0) {
  1067.             var1 = var1.negate();
  1068.          }
  1069.  
  1070.          BigInteger var4 = this.signum >= 0 && this.compareTo(var2) < 0 ? this : this.mod(var2);
  1071.          BigInteger var5;
  1072.          if (var2.testBit(0)) {
  1073.             var5 = var4.oddModPow(var1, var2);
  1074.          } else {
  1075.             int var6 = var2.getLowestSetBit();
  1076.             BigInteger var7 = var2.shiftRight(var6);
  1077.             BigInteger var8 = ONE.shiftLeft(var6);
  1078.             BigInteger var9 = this.signum >= 0 && this.compareTo(var7) < 0 ? this : this.mod(var7);
  1079.             BigInteger var10 = var7.equals(ONE) ? ZERO : var9.oddModPow(var1, var7);
  1080.             BigInteger var11 = var4.modPow2(var1, var6);
  1081.             BigInteger var12 = var8.modInverse(var7);
  1082.             BigInteger var13 = var7.modInverse(var8);
  1083.             var5 = var10.multiply(var8).multiply(var12).add(var11.multiply(var7).multiply(var13)).mod(var2);
  1084.          }
  1085.  
  1086.          return var3 ? var5.modInverse(var2) : var5;
  1087.       }
  1088.    }
  1089.  
  1090.    private BigInteger oddModPow(BigInteger var1, BigInteger var2) {
  1091.       if (var1.equals(ONE)) {
  1092.          return this;
  1093.       } else if (this.signum == 0) {
  1094.          return ZERO;
  1095.       } else {
  1096.          int[] var3 = (int[])this.mag.clone();
  1097.          int[] var4 = var1.mag;
  1098.          int[] var5 = var2.mag;
  1099.          int var6 = var5.length;
  1100.          int var7 = 0;
  1101.          int var8 = bitLength(var4, var4.length);
  1102.          if (var8 != 17 || var4[0] != 65537) {
  1103.             while(var8 > bnExpModThreshTable[var7]) {
  1104.                ++var7;
  1105.             }
  1106.          }
  1107.  
  1108.          int var9 = 1 << var7;
  1109.          int[][] var10 = new int[var9][];
  1110.  
  1111.          for(int var11 = 0; var11 < var9; ++var11) {
  1112.             var10[var11] = new int[var6];
  1113.          }
  1114.  
  1115.          int var29 = -MutableBigInteger.inverseMod32(var5[var6 - 1]);
  1116.          int[] var12 = leftShift(var3, var3.length, var6 << 5);
  1117.          MutableBigInteger var13 = new MutableBigInteger();
  1118.          MutableBigInteger var14 = new MutableBigInteger();
  1119.          MutableBigInteger var15 = new MutableBigInteger(var12);
  1120.          MutableBigInteger var16 = new MutableBigInteger(var5);
  1121.          var15.divide(var16, var13, var14);
  1122.          var10[0] = var14.toIntArray();
  1123.          if (var10[0].length < var6) {
  1124.             int var17 = var6 - var10[0].length;
  1125.             int[] var18 = new int[var6];
  1126.  
  1127.             for(int var19 = 0; var19 < var10[0].length; ++var19) {
  1128.                var18[var19 + var17] = var10[0][var19];
  1129.             }
  1130.  
  1131.             var10[0] = var18;
  1132.          }
  1133.  
  1134.          int[] var34 = squareToLen(var10[0], var6, (int[])null);
  1135.          var34 = montReduce(var34, var5, var6, var29);
  1136.          int[] var37 = new int[var6];
  1137.  
  1138.          for(int var40 = 0; var40 < var6; ++var40) {
  1139.             var37[var40] = var34[var40];
  1140.          }
  1141.  
  1142.          for(int var41 = 1; var41 < var9; ++var41) {
  1143.             int[] var20 = this.multiplyToLen(var37, var6, var10[var41 - 1], var6, (int[])null);
  1144.             var10[var41] = montReduce(var20, var5, var6, var29);
  1145.          }
  1146.  
  1147.          int var42 = 1 << (var8 - 1 & 31);
  1148.          int var43 = 0;
  1149.          int var21 = var4.length;
  1150.          int var22 = 0;
  1151.  
  1152.          for(int var23 = 0; var23 <= var7; ++var23) {
  1153.             var43 = var43 << 1 | ((var4[var22] & var42) != 0 ? 1 : 0);
  1154.             var42 >>>= 1;
  1155.             if (var42 == 0) {
  1156.                ++var22;
  1157.                var42 = Integer.MIN_VALUE;
  1158.                --var21;
  1159.             }
  1160.          }
  1161.  
  1162.          --var8;
  1163.          boolean var24 = true;
  1164.  
  1165.          int var45;
  1166.          for(var45 = var8 - var7; (var43 & 1) == 0; ++var45) {
  1167.             var43 >>>= 1;
  1168.          }
  1169.  
  1170.          int[] var25 = var10[var43 >>> 1];
  1171.          var43 = 0;
  1172.          if (var45 == var8) {
  1173.             var24 = false;
  1174.          }
  1175.  
  1176.          while(true) {
  1177.             --var8;
  1178.             var43 <<= 1;
  1179.             if (var21 != 0) {
  1180.                var43 |= (var4[var22] & var42) != 0 ? 1 : 0;
  1181.                var42 >>>= 1;
  1182.                if (var42 == 0) {
  1183.                   ++var22;
  1184.                   var42 = Integer.MIN_VALUE;
  1185.                   --var21;
  1186.                }
  1187.             }
  1188.  
  1189.             if ((var43 & var9) != 0) {
  1190.                for(var45 = var8 - var7; (var43 & 1) == 0; ++var45) {
  1191.                   var43 >>>= 1;
  1192.                }
  1193.  
  1194.                var25 = var10[var43 >>> 1];
  1195.                var43 = 0;
  1196.             }
  1197.  
  1198.             if (var8 == var45) {
  1199.                if (var24) {
  1200.                   var34 = (int[])(([I)var25).clone();
  1201.                   var24 = false;
  1202.                } else {
  1203.                   var12 = this.multiplyToLen(var34, var6, var25, var6, var12);
  1204.                   var12 = montReduce(var12, var5, var6, var29);
  1205.                   var12 = var34;
  1206.                   var34 = var12;
  1207.                }
  1208.             }
  1209.  
  1210.             if (var8 == 0) {
  1211.                int[] var26 = new int[2 * var6];
  1212.  
  1213.                for(int var27 = 0; var27 < var6; ++var27) {
  1214.                   var26[var27 + var6] = var34[var27];
  1215.                }
  1216.  
  1217.                var34 = montReduce(var26, var5, var6, var29);
  1218.                var26 = new int[var6];
  1219.  
  1220.                for(int var47 = 0; var47 < var6; ++var47) {
  1221.                   var26[var47] = var34[var47];
  1222.                }
  1223.  
  1224.                return new BigInteger(1, var26);
  1225.             }
  1226.  
  1227.             if (!var24) {
  1228.                var12 = squareToLen(var34, var6, var12);
  1229.                var12 = montReduce(var12, var5, var6, var29);
  1230.                var12 = var34;
  1231.                var34 = var12;
  1232.             }
  1233.          }
  1234.       }
  1235.    }
  1236.  
  1237.    private static int[] montReduce(int[] var0, int[] var1, int var2, int var3) {
  1238.       int var4 = 0;
  1239.       int var5 = var2;
  1240.       int var6 = 0;
  1241.  
  1242.       do {
  1243.          int var7 = var0[var0.length - 1 - var6];
  1244.          int var8 = mulAdd(var0, var1, var6, var2, var3 * var7);
  1245.          var4 += addOne(var0, var6, var2, var8);
  1246.          ++var6;
  1247.          --var5;
  1248.       } while(var5 > 0);
  1249.  
  1250.       while(var4 > 0) {
  1251.          var4 += subN(var0, var1, var2);
  1252.       }
  1253.  
  1254.       while(intArrayCmpToLen(var0, var1, var2) >= 0) {
  1255.          subN(var0, var1, var2);
  1256.       }
  1257.  
  1258.       return var0;
  1259.    }
  1260.  
  1261.    private static int intArrayCmpToLen(int[] var0, int[] var1, int var2) {
  1262.       for(int var3 = 0; var3 < var2; ++var3) {
  1263.          long var4 = (long)var0[var3] & 4294967295L;
  1264.          long var6 = (long)var1[var3] & 4294967295L;
  1265.          if (var4 < var6) {
  1266.             return -1;
  1267.          }
  1268.  
  1269.          if (var4 > var6) {
  1270.             return 1;
  1271.          }
  1272.       }
  1273.  
  1274.       return 0;
  1275.    }
  1276.  
  1277.    private static int subN(int[] var0, int[] var1, int var2) {
  1278.       long var3 = 0L;
  1279.  
  1280.       while(true) {
  1281.          --var2;
  1282.          if (var2 < 0) {
  1283.             return (int)(var3 >> 32);
  1284.          }
  1285.  
  1286.          var3 = ((long)var0[var2] & 4294967295L) - ((long)var1[var2] & 4294967295L) + (var3 >> 32);
  1287.          var0[var2] = (int)var3;
  1288.       }
  1289.    }
  1290.  
  1291.    static int mulAdd(int[] var0, int[] var1, int var2, int var3, int var4) {
  1292.       long var5 = (long)var4 & 4294967295L;
  1293.       long var7 = 0L;
  1294.       var2 = var0.length - var2 - 1;
  1295.  
  1296.       for(int var9 = var3 - 1; var9 >= 0; --var9) {
  1297.          long var10 = ((long)var1[var9] & 4294967295L) * var5 + ((long)var0[var2] & 4294967295L) + var7;
  1298.          var0[var2--] = (int)var10;
  1299.          var7 = var10 >>> 32;
  1300.       }
  1301.  
  1302.       return (int)var7;
  1303.    }
  1304.  
  1305.    static int addOne(int[] var0, int var1, int var2, int var3) {
  1306.       var1 = var0.length - 1 - var2 - var1;
  1307.       long var4 = ((long)var0[var1] & 4294967295L) + ((long)var3 & 4294967295L);
  1308.       var0[var1] = (int)var4;
  1309.       if (var4 >>> 32 == 0L) {
  1310.          return 0;
  1311.       } else {
  1312.          do {
  1313.             --var2;
  1314.             if (var2 < 0) {
  1315.                return 1;
  1316.             }
  1317.  
  1318.             --var1;
  1319.             if (var1 < 0) {
  1320.                return 1;
  1321.             }
  1322.  
  1323.             int var10002 = var0[var1]++;
  1324.          } while(var0[var1] == 0);
  1325.  
  1326.          return 0;
  1327.       }
  1328.    }
  1329.  
  1330.    private BigInteger modPow2(BigInteger var1, int var2) {
  1331.       BigInteger var3 = valueOf(1L);
  1332.       BigInteger var4 = this.mod2(var2);
  1333.       int var5 = 0;
  1334.       int var6 = var1.bitLength();
  1335.       if (this.testBit(0)) {
  1336.          var6 = var2 - 1 < var6 ? var2 - 1 : var6;
  1337.       }
  1338.  
  1339.       while(var5 < var6) {
  1340.          if (var1.testBit(var5)) {
  1341.             var3 = var3.multiply(var4).mod2(var2);
  1342.          }
  1343.  
  1344.          ++var5;
  1345.          if (var5 < var6) {
  1346.             var4 = var4.square().mod2(var2);
  1347.          }
  1348.       }
  1349.  
  1350.       return var3;
  1351.    }
  1352.  
  1353.    private BigInteger mod2(int var1) {
  1354.       if (this.bitLength() <= var1) {
  1355.          return this;
  1356.       } else {
  1357.          int var2 = (var1 + 31) / 32;
  1358.          int[] var3 = new int[var2];
  1359.  
  1360.          for(int var4 = 0; var4 < var2; ++var4) {
  1361.             var3[var4] = this.mag[var4 + (this.mag.length - var2)];
  1362.          }
  1363.  
  1364.          int var5 = (var2 << 5) - var1;
  1365.          var3[0] = (int)((long)var3[0] & (1L << 32 - var5) - 1L);
  1366.          return var3[0] == 0 ? new BigInteger(1, var3) : new BigInteger(var3, 1);
  1367.       }
  1368.    }
  1369.  
  1370.    public BigInteger modInverse(BigInteger var1) {
  1371.       if (var1.signum != 1) {
  1372.          throw new ArithmeticException("BigInteger: modulus not positive");
  1373.       } else if (var1.equals(ONE)) {
  1374.          return ZERO;
  1375.       } else {
  1376.          BigInteger var2 = this;
  1377.          if (this.signum < 0 || intArrayCmp(this.mag, var1.mag) >= 0) {
  1378.             var2 = this.mod(var1);
  1379.          }
  1380.  
  1381.          if (var2.equals(ONE)) {
  1382.             return ONE;
  1383.          } else {
  1384.             MutableBigInteger var3 = new MutableBigInteger(var2);
  1385.             MutableBigInteger var4 = new MutableBigInteger(var1);
  1386.             MutableBigInteger var5 = var3.mutableModInverse(var4);
  1387.             return new BigInteger(var5, 1);
  1388.          }
  1389.       }
  1390.    }
  1391.  
  1392.    public BigInteger shiftLeft(int var1) {
  1393.       if (this.signum == 0) {
  1394.          return ZERO;
  1395.       } else if (var1 == 0) {
  1396.          return this;
  1397.       } else if (var1 < 0) {
  1398.          return this.shiftRight(-var1);
  1399.       } else {
  1400.          int var2 = var1 >>> 5;
  1401.          int var3 = var1 & 31;
  1402.          int var4 = this.mag.length;
  1403.          Object var5 = null;
  1404.          int[] var10;
  1405.          if (var3 == 0) {
  1406.             var10 = new int[var4 + var2];
  1407.  
  1408.             for(int var6 = 0; var6 < var4; ++var6) {
  1409.                var10[var6] = this.mag[var6];
  1410.             }
  1411.          } else {
  1412.             int var11 = 0;
  1413.             int var7 = 32 - var3;
  1414.             int var8 = this.mag[0] >>> var7;
  1415.             if (var8 != 0) {
  1416.                var10 = new int[var4 + var2 + 1];
  1417.                var10[var11++] = var8;
  1418.             } else {
  1419.                var10 = new int[var4 + var2];
  1420.             }
  1421.  
  1422.             int var9;
  1423.             for(var9 = 0; var9 < var4 - 1; var10[var11++] = this.mag[var9++] << var3 | this.mag[var9] >>> var7) {
  1424.             }
  1425.  
  1426.             var10[var11] = this.mag[var9] << var3;
  1427.          }
  1428.  
  1429.          return new BigInteger(var10, this.signum);
  1430.       }
  1431.    }
  1432.  
  1433.    public BigInteger shiftRight(int var1) {
  1434.       if (var1 == 0) {
  1435.          return this;
  1436.       } else if (var1 < 0) {
  1437.          return this.shiftLeft(-var1);
  1438.       } else {
  1439.          int var2 = var1 >>> 5;
  1440.          int var3 = var1 & 31;
  1441.          int var4 = this.mag.length;
  1442.          Object var5 = null;
  1443.          if (var2 >= var4) {
  1444.             return this.signum >= 0 ? ZERO : negConst[1];
  1445.          } else {
  1446.             int[] var10;
  1447.             if (var3 == 0) {
  1448.                int var6 = var4 - var2;
  1449.                var10 = new int[var6];
  1450.  
  1451.                for(int var7 = 0; var7 < var6; ++var7) {
  1452.                   var10[var7] = this.mag[var7];
  1453.                }
  1454.             } else {
  1455.                int var11 = 0;
  1456.                int var13 = this.mag[0] >>> var3;
  1457.                if (var13 != 0) {
  1458.                   var10 = new int[var4 - var2];
  1459.                   var10[var11++] = var13;
  1460.                } else {
  1461.                   var10 = new int[var4 - var2 - 1];
  1462.                }
  1463.  
  1464.                int var8 = 32 - var3;
  1465.  
  1466.                for(int var9 = 0; var9 < var4 - var2 - 1; var10[var11++] = this.mag[var9++] << var8 | this.mag[var9] >>> var3) {
  1467.                }
  1468.             }
  1469.  
  1470.             if (this.signum < 0) {
  1471.                boolean var12 = false;
  1472.                int var14 = var4 - 1;
  1473.  
  1474.                for(int var15 = var4 - var2; var14 >= var15 && !var12; --var14) {
  1475.                   var12 = this.mag[var14] != 0;
  1476.                }
  1477.  
  1478.                if (!var12 && var3 != 0) {
  1479.                   var12 = this.mag[var4 - var2 - 1] << 32 - var3 != 0;
  1480.                }
  1481.  
  1482.                if (var12) {
  1483.                   var10 = this.javaIncrement(var10);
  1484.                }
  1485.             }
  1486.  
  1487.             return new BigInteger(var10, this.signum);
  1488.          }
  1489.       }
  1490.    }
  1491.  
  1492.    int[] javaIncrement(int[] var1) {
  1493.       int var2 = 0;
  1494.  
  1495.       for(int var3 = var1.length - 1; var3 >= 0 && var2 == 0; --var3) {
  1496.          var2 = ++var1[var3];
  1497.       }
  1498.  
  1499.       if (var2 == 0) {
  1500.          var1 = new int[var1.length + 1];
  1501.          var1[0] = 1;
  1502.       }
  1503.  
  1504.       return var1;
  1505.    }
  1506.  
  1507.    public BigInteger and(BigInteger var1) {
  1508.       int[] var2 = new int[Math.max(this.intLength(), var1.intLength())];
  1509.  
  1510.       for(int var3 = 0; var3 < var2.length; ++var3) {
  1511.          var2[var3] = this.getInt(var2.length - var3 - 1) & var1.getInt(var2.length - var3 - 1);
  1512.       }
  1513.  
  1514.       return valueOf(var2);
  1515.    }
  1516.  
  1517.    // $FF: renamed from: or (java.math.BigInteger) java.math.BigInteger
  1518.    public BigInteger method_0(BigInteger var1) {
  1519.       int[] var2 = new int[Math.max(this.intLength(), var1.intLength())];
  1520.  
  1521.       for(int var3 = 0; var3 < var2.length; ++var3) {
  1522.          var2[var3] = this.getInt(var2.length - var3 - 1) | var1.getInt(var2.length - var3 - 1);
  1523.       }
  1524.  
  1525.       return valueOf(var2);
  1526.    }
  1527.  
  1528.    public BigInteger xor(BigInteger var1) {
  1529.       int[] var2 = new int[Math.max(this.intLength(), var1.intLength())];
  1530.  
  1531.       for(int var3 = 0; var3 < var2.length; ++var3) {
  1532.          var2[var3] = this.getInt(var2.length - var3 - 1) ^ var1.getInt(var2.length - var3 - 1);
  1533.       }
  1534.  
  1535.       return valueOf(var2);
  1536.    }
  1537.  
  1538.    public BigInteger not() {
  1539.       int[] var1 = new int[this.intLength()];
  1540.  
  1541.       for(int var2 = 0; var2 < var1.length; ++var2) {
  1542.          var1[var2] = ~this.getInt(var1.length - var2 - 1);
  1543.       }
  1544.  
  1545.       return valueOf(var1);
  1546.    }
  1547.  
  1548.    public BigInteger andNot(BigInteger var1) {
  1549.       int[] var2 = new int[Math.max(this.intLength(), var1.intLength())];
  1550.  
  1551.       for(int var3 = 0; var3 < var2.length; ++var3) {
  1552.          var2[var3] = this.getInt(var2.length - var3 - 1) & ~var1.getInt(var2.length - var3 - 1);
  1553.       }
  1554.  
  1555.       return valueOf(var2);
  1556.    }
  1557.  
  1558.    public boolean testBit(int var1) {
  1559.       if (var1 < 0) {
  1560.          throw new ArithmeticException("Negative bit address");
  1561.       } else {
  1562.          return (this.getInt(var1 / 32) & 1 << var1 % 32) != 0;
  1563.       }
  1564.    }
  1565.  
  1566.    public BigInteger setBit(int var1) {
  1567.       if (var1 < 0) {
  1568.          throw new ArithmeticException("Negative bit address");
  1569.       } else {
  1570.          int var2 = var1 / 32;
  1571.          int[] var3 = new int[Math.max(this.intLength(), var2 + 2)];
  1572.  
  1573.          for(int var4 = 0; var4 < var3.length; ++var4) {
  1574.             var3[var3.length - var4 - 1] = this.getInt(var4);
  1575.          }
  1576.  
  1577.          var3[var3.length - var2 - 1] |= 1 << var1 % 32;
  1578.          return valueOf(var3);
  1579.       }
  1580.    }
  1581.  
  1582.    public BigInteger clearBit(int var1) {
  1583.       if (var1 < 0) {
  1584.          throw new ArithmeticException("Negative bit address");
  1585.       } else {
  1586.          int var2 = var1 / 32;
  1587.          int[] var3 = new int[Math.max(this.intLength(), (var1 + 1) / 32 + 1)];
  1588.  
  1589.          for(int var4 = 0; var4 < var3.length; ++var4) {
  1590.             var3[var3.length - var4 - 1] = this.getInt(var4);
  1591.          }
  1592.  
  1593.          var3[var3.length - var2 - 1] &= ~(1 << var1 % 32);
  1594.          return valueOf(var3);
  1595.       }
  1596.    }
  1597.  
  1598.    public BigInteger flipBit(int var1) {
  1599.       if (var1 < 0) {
  1600.          throw new ArithmeticException("Negative bit address");
  1601.       } else {
  1602.          int var2 = var1 / 32;
  1603.          int[] var3 = new int[Math.max(this.intLength(), var2 + 2)];
  1604.  
  1605.          for(int var4 = 0; var4 < var3.length; ++var4) {
  1606.             var3[var3.length - var4 - 1] = this.getInt(var4);
  1607.          }
  1608.  
  1609.          var3[var3.length - var2 - 1] ^= 1 << var1 % 32;
  1610.          return valueOf(var3);
  1611.       }
  1612.    }
  1613.  
  1614.    public int getLowestSetBit() {
  1615.       if (this.lowestSetBit == -2) {
  1616.          if (this.signum == 0) {
  1617.             this.lowestSetBit = -1;
  1618.          } else {
  1619.             int var1;
  1620.             int var2;
  1621.             for(var1 = 0; (var2 = this.getInt(var1)) == 0; ++var1) {
  1622.             }
  1623.  
  1624.             this.lowestSetBit = (var1 << 5) + trailingZeroCnt(var2);
  1625.          }
  1626.       }
  1627.  
  1628.       return this.lowestSetBit;
  1629.    }
  1630.  
  1631.    public int bitLength() {
  1632.       if (this.bitLength == -1) {
  1633.          if (this.signum == 0) {
  1634.             this.bitLength = 0;
  1635.          } else {
  1636.             int var1 = (this.mag.length - 1 << 5) + bitLen(this.mag[0]);
  1637.             if (this.signum < 0) {
  1638.                boolean var2 = bitCnt(this.mag[0]) == 1;
  1639.  
  1640.                for(int var3 = 1; var3 < this.mag.length && var2; ++var3) {
  1641.                   var2 = this.mag[var3] == 0;
  1642.                }
  1643.  
  1644.                this.bitLength = var2 ? var1 - 1 : var1;
  1645.             } else {
  1646.                this.bitLength = var1;
  1647.             }
  1648.          }
  1649.       }
  1650.  
  1651.       return this.bitLength;
  1652.    }
  1653.  
  1654.    static int bitLen(int var0) {
  1655.       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))));
  1656.    }
  1657.  
  1658.    public int bitCount() {
  1659.       if (this.bitCount == -1) {
  1660.          int var1 = 0;
  1661.  
  1662.          for(int var2 = 0; var2 < this.mag.length; ++var2) {
  1663.             var1 += bitCnt(this.mag[var2]);
  1664.          }
  1665.  
  1666.          if (this.signum < 0) {
  1667.             int var4 = 0;
  1668.  
  1669.             int var3;
  1670.             for(var3 = this.mag.length - 1; this.mag[var3] == 0; --var3) {
  1671.                var4 += 32;
  1672.             }
  1673.  
  1674.             var4 += trailingZeroCnt(this.mag[var3]);
  1675.             this.bitCount = var1 + var4 - 1;
  1676.          } else {
  1677.             this.bitCount = var1;
  1678.          }
  1679.       }
  1680.  
  1681.       return this.bitCount;
  1682.    }
  1683.  
  1684.    static int bitCnt(int var0) {
  1685.       var0 -= (-1431655766 & var0) >>> 1;
  1686.       var0 = (var0 & 858993459) + (var0 >>> 2 & 858993459);
  1687.       var0 = var0 + (var0 >>> 4) & 252645135;
  1688.       var0 += var0 >>> 8;
  1689.       var0 += var0 >>> 16;
  1690.       return var0 & 255;
  1691.    }
  1692.  
  1693.    static int trailingZeroCnt(int var0) {
  1694.       int var1 = var0 & 255;
  1695.       if (var1 != 0) {
  1696.          return trailingZeroTable[var1];
  1697.       } else {
  1698.          var1 = var0 >>> 8 & 255;
  1699.          if (var1 != 0) {
  1700.             return trailingZeroTable[var1] + 8;
  1701.          } else {
  1702.             var1 = var0 >>> 16 & 255;
  1703.             if (var1 != 0) {
  1704.                return trailingZeroTable[var1] + 16;
  1705.             } else {
  1706.                var1 = var0 >>> 24 & 255;
  1707.                return trailingZeroTable[var1] + 24;
  1708.             }
  1709.          }
  1710.       }
  1711.    }
  1712.  
  1713.    public boolean isProbablePrime(int var1) {
  1714.       if (var1 <= 0) {
  1715.          return true;
  1716.       } else {
  1717.          BigInteger var2 = this.abs();
  1718.          if (var2.equals(TWO)) {
  1719.             return true;
  1720.          } else {
  1721.             return var2.testBit(0) && !var2.equals(ONE) ? var2.primeToCertainty(var1, (Random)null) : false;
  1722.          }
  1723.       }
  1724.    }
  1725.  
  1726.    public int compareTo(BigInteger var1) {
  1727.       return this.signum == var1.signum ? this.signum * intArrayCmp(this.mag, var1.mag) : (this.signum > var1.signum ? 1 : -1);
  1728.    }
  1729.  
  1730.    private static int intArrayCmp(int[] var0, int[] var1) {
  1731.       if (var0.length < var1.length) {
  1732.          return -1;
  1733.       } else if (var0.length > var1.length) {
  1734.          return 1;
  1735.       } else {
  1736.          for(int var2 = 0; var2 < var0.length; ++var2) {
  1737.             long var3 = (long)var0[var2] & 4294967295L;
  1738.             long var5 = (long)var1[var2] & 4294967295L;
  1739.             if (var3 < var5) {
  1740.                return -1;
  1741.             }
  1742.  
  1743.             if (var3 > var5) {
  1744.                return 1;
  1745.             }
  1746.          }
  1747.  
  1748.          return 0;
  1749.       }
  1750.    }
  1751.  
  1752.    public boolean equals(Object var1) {
  1753.       if (var1 == this) {
  1754.          return true;
  1755.       } else if (!(var1 instanceof BigInteger)) {
  1756.          return false;
  1757.       } else {
  1758.          BigInteger var2 = (BigInteger)var1;
  1759.          if (var2.signum == this.signum && var2.mag.length == this.mag.length) {
  1760.             for(int var3 = 0; var3 < this.mag.length; ++var3) {
  1761.                if (var2.mag[var3] != this.mag[var3]) {
  1762.                   return false;
  1763.                }
  1764.             }
  1765.  
  1766.             return true;
  1767.          } else {
  1768.             return false;
  1769.          }
  1770.       }
  1771.    }
  1772.  
  1773.    public BigInteger min(BigInteger var1) {
  1774.       return this.compareTo(var1) < 0 ? this : var1;
  1775.    }
  1776.  
  1777.    public BigInteger max(BigInteger var1) {
  1778.       return this.compareTo(var1) > 0 ? this : var1;
  1779.    }
  1780.  
  1781.    public int hashCode() {
  1782.       int var1 = 0;
  1783.  
  1784.       for(int var2 = 0; var2 < this.mag.length; ++var2) {
  1785.          var1 = (int)((long)(31 * var1) + ((long)this.mag[var2] & 4294967295L));
  1786.       }
  1787.  
  1788.       return var1 * this.signum;
  1789.    }
  1790.  
  1791.    public String toString(int var1) {
  1792.       if (this.signum == 0) {
  1793.          return "0";
  1794.       } else {
  1795.          if (var1 < 2 || var1 > 36) {
  1796.             var1 = 10;
  1797.          }
  1798.  
  1799.          int var2 = (4 * this.mag.length + 6) / 7;
  1800.          String[] var3 = new String[var2];
  1801.          BigInteger var4 = this.abs();
  1802.  
  1803.          int var5;
  1804.          BigInteger var11;
  1805.          for(var5 = 0; var4.signum != 0; var4 = var11) {
  1806.             BigInteger var6 = longRadix[var1];
  1807.             MutableBigInteger var7 = new MutableBigInteger();
  1808.             MutableBigInteger var8 = new MutableBigInteger();
  1809.             MutableBigInteger var9 = new MutableBigInteger(var4.mag);
  1810.             MutableBigInteger var10 = new MutableBigInteger(var6.mag);
  1811.             var9.divide(var10, var7, var8);
  1812.             var11 = new BigInteger(var7, var4.signum * var6.signum);
  1813.             BigInteger var12 = new BigInteger(var8, var4.signum * var6.signum);
  1814.             var3[var5++] = Long.toString(var12.longValue(), var1);
  1815.          }
  1816.  
  1817.          StringBuilder var13 = new StringBuilder(var5 * digitsPerLong[var1] + 1);
  1818.          if (this.signum < 0) {
  1819.             var13.append('-');
  1820.          }
  1821.  
  1822.          var13.append(var3[var5 - 1]);
  1823.  
  1824.          for(int var14 = var5 - 2; var14 >= 0; --var14) {
  1825.             int var15 = digitsPerLong[var1] - var3[var14].length();
  1826.             if (var15 != 0) {
  1827.                var13.append(zeros[var15]);
  1828.             }
  1829.  
  1830.             var13.append(var3[var14]);
  1831.          }
  1832.  
  1833.          return var13.toString();
  1834.       }
  1835.    }
  1836.  
  1837.    public String toString() {
  1838.       return this.toString(10);
  1839.    }
  1840.  
  1841.    public byte[] toByteArray() {
  1842.       int var1 = this.bitLength() / 8 + 1;
  1843.       byte[] var2 = new byte[var1];
  1844.       int var3 = var1 - 1;
  1845.       int var4 = 4;
  1846.       int var5 = 0;
  1847.  
  1848.       for(int var6 = 0; var3 >= 0; --var3) {
  1849.          if (var4 == 4) {
  1850.             var5 = this.getInt(var6++);
  1851.             var4 = 1;
  1852.          } else {
  1853.             var5 >>>= 8;
  1854.             ++var4;
  1855.          }
  1856.  
  1857.          var2[var3] = (byte)var5;
  1858.       }
  1859.  
  1860.       return var2;
  1861.    }
  1862.  
  1863.    public int intValue() {
  1864.       int var1 = 0;
  1865.       var1 = this.getInt(0);
  1866.       return var1;
  1867.    }
  1868.  
  1869.    public long longValue() {
  1870.       long var1 = 0L;
  1871.  
  1872.       for(int var3 = 1; var3 >= 0; --var3) {
  1873.          var1 = (var1 << 32) + ((long)this.getInt(var3) & 4294967295L);
  1874.       }
  1875.  
  1876.       return var1;
  1877.    }
  1878.  
  1879.    public float floatValue() {
  1880.       return Float.parseFloat(this.toString());
  1881.    }
  1882.  
  1883.    public double doubleValue() {
  1884.       return Double.parseDouble(this.toString());
  1885.    }
  1886.  
  1887.    private static int[] stripLeadingZeroInts(int[] var0) {
  1888.       int var1 = var0.length;
  1889.  
  1890.       int var2;
  1891.       for(var2 = 0; var2 < var0.length && var0[var2] == 0; ++var2) {
  1892.       }
  1893.  
  1894.       int[] var3 = new int[var0.length - var2];
  1895.  
  1896.       for(int var4 = 0; var4 < var0.length - var2; ++var4) {
  1897.          var3[var4] = var0[var2 + var4];
  1898.       }
  1899.  
  1900.       return var3;
  1901.    }
  1902.  
  1903.    private static int[] trustedStripLeadingZeroInts(int[] var0) {
  1904.       int var1 = var0.length;
  1905.  
  1906.       int var2;
  1907.       for(var2 = 0; var2 < var0.length && var0[var2] == 0; ++var2) {
  1908.       }
  1909.  
  1910.       if (var2 <= 0) {
  1911.          return var0;
  1912.       } else {
  1913.          int[] var3 = new int[var0.length - var2];
  1914.  
  1915.          for(int var4 = 0; var4 < var0.length - var2; ++var4) {
  1916.             var3[var4] = var0[var2 + var4];
  1917.          }
  1918.  
  1919.          return var3;
  1920.       }
  1921.    }
  1922.  
  1923.    private static int[] stripLeadingZeroBytes(byte[] var0) {
  1924.       int var1 = var0.length;
  1925.  
  1926.       int var2;
  1927.       for(var2 = 0; var2 < var0.length && var0[var2] == 0; ++var2) {
  1928.       }
  1929.  
  1930.       int var3 = (var1 - var2 + 3) / 4;
  1931.       int[] var4 = new int[var3];
  1932.       int var5 = var1 - 1;
  1933.  
  1934.       for(int var6 = var3 - 1; var6 >= 0; --var6) {
  1935.          var4[var6] = var0[var5--] & 255;
  1936.          int var7 = var5 - var2 + 1;
  1937.          int var8 = Math.min(3, var7);
  1938.  
  1939.          for(int var9 = 8; var9 <= 8 * var8; var9 += 8) {
  1940.             var4[var6] |= (var0[var5--] & 255) << var9;
  1941.          }
  1942.       }
  1943.  
  1944.       return var4;
  1945.    }
  1946.  
  1947.    private static int[] makePositive(byte[] var0) {
  1948.       int var3 = var0.length;
  1949.  
  1950.       int var1;
  1951.       for(var1 = 0; var1 < var3 && var0[var1] == -1; ++var1) {
  1952.       }
  1953.  
  1954.       int var2;
  1955.       for(var2 = var1; var2 < var3 && var0[var2] == 0; ++var2) {
  1956.       }
  1957.  
  1958.       int var4 = var2 == var3 ? 1 : 0;
  1959.       int var5 = (var3 - var1 + var4 + 3) / 4;
  1960.       int[] var6 = new int[var5];
  1961.       int var7 = var3 - 1;
  1962.  
  1963.       for(int var8 = var5 - 1; var8 >= 0; --var8) {
  1964.          var6[var8] = var0[var7--] & 255;
  1965.          int var9 = Math.min(3, var7 - var1 + 1);
  1966.          if (var9 < 0) {
  1967.             var9 = 0;
  1968.          }
  1969.  
  1970.          for(int var10 = 8; var10 <= 8 * var9; var10 += 8) {
  1971.             var6[var8] |= (var0[var7--] & 255) << var10;
  1972.          }
  1973.  
  1974.          int var12 = -1 >>> 8 * (3 - var9);
  1975.          var6[var8] = ~var6[var8] & var12;
  1976.       }
  1977.  
  1978.       for(int var11 = var6.length - 1; var11 >= 0; --var11) {
  1979.          var6[var11] = (int)(((long)var6[var11] & 4294967295L) + 1L);
  1980.          if (var6[var11] != 0) {
  1981.             break;
  1982.          }
  1983.       }
  1984.  
  1985.       return var6;
  1986.    }
  1987.  
  1988.    private static int[] makePositive(int[] var0) {
  1989.       int var1;
  1990.       for(var1 = 0; var1 < var0.length && var0[var1] == -1; ++var1) {
  1991.       }
  1992.  
  1993.       int var2;
  1994.       for(var2 = var1; var2 < var0.length && var0[var2] == 0; ++var2) {
  1995.       }
  1996.  
  1997.       int var3 = var2 == var0.length ? 1 : 0;
  1998.       int[] var4 = new int[var0.length - var1 + var3];
  1999.  
  2000.       for(int var5 = var1; var5 < var0.length; ++var5) {
  2001.          var4[var5 - var1 + var3] = ~var0[var5];
  2002.       }
  2003.  
  2004.       for(int var6 = var4.length - 1; ++var4[var6] == 0; --var6) {
  2005.       }
  2006.  
  2007.       return var4;
  2008.    }
  2009.  
  2010.    private int intLength() {
  2011.       return this.bitLength() / 32 + 1;
  2012.    }
  2013.  
  2014.    private int signBit() {
  2015.       return this.signum < 0 ? 1 : 0;
  2016.    }
  2017.  
  2018.    private int signInt() {
  2019.       return this.signum < 0 ? -1 : 0;
  2020.    }
  2021.  
  2022.    private int getInt(int var1) {
  2023.       if (var1 < 0) {
  2024.          return 0;
  2025.       } else if (var1 >= this.mag.length) {
  2026.          return this.signInt();
  2027.       } else {
  2028.          int var2 = this.mag[this.mag.length - var1 - 1];
  2029.          return this.signum >= 0 ? var2 : (var1 <= this.firstNonzeroIntNum() ? -var2 : ~var2);
  2030.       }
  2031.    }
  2032.  
  2033.    private int firstNonzeroIntNum() {
  2034.       if (this.firstNonzeroIntNum == -2) {
  2035.          int var1;
  2036.          for(var1 = this.mag.length - 1; var1 >= 0 && this.mag[var1] == 0; --var1) {
  2037.          }
  2038.  
  2039.          this.firstNonzeroIntNum = this.mag.length - var1 - 1;
  2040.       }
  2041.  
  2042.       return this.firstNonzeroIntNum;
  2043.    }
  2044.  
  2045.    private void readObject(ObjectInputStream var1) throws IOException, ClassNotFoundException {
  2046.       ObjectInputStream.GetField var2 = var1.readFields();
  2047.       this.signum = var2.get("signum", -2);
  2048.       byte[] var3 = (byte[])var2.get("magnitude", (Object)null);
  2049.       if (this.signum >= -1 && this.signum <= 1) {
  2050.          if (var3.length == 0 != (this.signum == 0)) {
  2051.             String var5 = "BigInteger: signum-magnitude mismatch";
  2052.             if (var2.defaulted("magnitude")) {
  2053.                var5 = "BigInteger: Magnitude not present in stream";
  2054.             }
  2055.  
  2056.             throw new StreamCorruptedException(var5);
  2057.          } else {
  2058.             this.bitCount = this.bitLength = -1;
  2059.             this.lowestSetBit = this.firstNonzeroByteNum = this.firstNonzeroIntNum = -2;
  2060.             this.mag = stripLeadingZeroBytes(var3);
  2061.          }
  2062.       } else {
  2063.          String var4 = "BigInteger: Invalid signum value";
  2064.          if (var2.defaulted("signum")) {
  2065.             var4 = "BigInteger: Signum not present in stream";
  2066.          }
  2067.  
  2068.          throw new StreamCorruptedException(var4);
  2069.       }
  2070.    }
  2071.  
  2072.    private void writeObject(ObjectOutputStream var1) throws IOException {
  2073.       ObjectOutputStream.PutField var2 = var1.putFields();
  2074.       var2.put("signum", this.signum);
  2075.       var2.put("magnitude", this.magSerializedForm());
  2076.       var2.put("bitCount", -1);
  2077.       var2.put("bitLength", -1);
  2078.       var2.put("lowestSetBit", -2);
  2079.       var2.put("firstNonzeroByteNum", -2);
  2080.       var1.writeFields();
  2081.    }
  2082.  
  2083.    private byte[] magSerializedForm() {
  2084.       int var1 = this.mag.length == 0 ? 0 : (this.mag.length - 1 << 5) + bitLen(this.mag[0]);
  2085.       int var2 = (var1 + 7) / 8;
  2086.       byte[] var3 = new byte[var2];
  2087.       int var4 = var2 - 1;
  2088.       int var5 = 4;
  2089.       int var6 = this.mag.length - 1;
  2090.  
  2091.       for(int var7 = 0; var4 >= 0; --var4) {
  2092.          if (var5 == 4) {
  2093.             var7 = this.mag[var6--];
  2094.             var5 = 1;
  2095.          } else {
  2096.             var7 >>>= 8;
  2097.             ++var5;
  2098.          }
  2099.  
  2100.          var3[var4] = (byte)var7;
  2101.       }
  2102.  
  2103.       return var3;
  2104.    }
  2105.  
  2106.    static {
  2107.       for(int var0 = 1; var0 <= 16; ++var0) {
  2108.          int[] var1 = new int[]{var0};
  2109.          posConst[var0] = new BigInteger(var1, 1);
  2110.          negConst[var0] = new BigInteger(var1, -1);
  2111.       }
  2112.  
  2113.       ZERO = new BigInteger(new int[0], 0);
  2114.       ONE = valueOf(1L);
  2115.       TWO = valueOf(2L);
  2116.       TEN = valueOf(10L);
  2117.       bnExpModThreshTable = new int[]{7, 25, 81, 241, 673, 1793, Integer.MAX_VALUE};
  2118.       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};
  2119.       zeros = new String[64];
  2120.       zeros[63] = "000000000000000000000000000000000000000000000000000000000000000";
  2121.  
  2122.       for(int var2 = 0; var2 < 63; ++var2) {
  2123.          zeros[var2] = zeros[63].substring(0, var2);
  2124.       }
  2125.  
  2126.       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};
  2127.       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)};
  2128.       digitsPerInt = new int[]{0, 0, 30, 19, 15, 13, 11, 11, 10, 9, 9, 8, 8, 8, 8, 7, 7, 7, 7, 7, 7, 7, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5};
  2129.       intRadix = new int[]{0, 0, 1073741824, 1162261467, 1073741824, 1220703125, 362797056, 1977326743, 1073741824, 387420489, 1000000000, 214358881, 429981696, 815730721, 1475789056, 170859375, 268435456, 410338673, 612220032, 893871739, 1280000000, 1801088541, 113379904, 148035889, 191102976, 244140625, 308915776, 387420489, 481890304, 594823321, 729000000, 887503681, 1073741824, 1291467969, 1544804416, 1838265625, 60466176};
  2130.       serialPersistentFields = new ObjectStreamField[]{new ObjectStreamField("signum", Integer.TYPE), new ObjectStreamField("magnitude", byte[].class), new ObjectStreamField("bitCount", Integer.TYPE), new ObjectStreamField("bitLength", Integer.TYPE), new ObjectStreamField("firstNonzeroByteNum", Integer.TYPE), new ObjectStreamField("lowestSetBit", Integer.TYPE)};
  2131.    }
  2132. }
  2133.