home *** CD-ROM | disk | FTP | other *** search
/ PC Plus SuperCD 31 / SUPERCDa.iso / Inet / HotJava / hjava.exe / Windows / resource / jre / lib / rt.jar / java / math / BigInteger.class (.txt) < prev   
Encoding:
Java Class File  |  1998-11-11  |  23.5 KB  |  935 lines
  1. package java.math;
  2.  
  3. import java.io.IOException;
  4. import java.io.ObjectInputStream;
  5. import java.io.StreamCorruptedException;
  6. import java.util.Random;
  7.  
  8. public class BigInteger extends Number {
  9.    private int signum;
  10.    private byte[] magnitude;
  11.    private int bitCount;
  12.    private int bitLength;
  13.    private int firstNonzeroByteNum;
  14.    private int lowestSetBit;
  15.    private static final BigInteger ZERO = new BigInteger(new byte[0], 0);
  16.    private static final int MAX_CONSTANT = 16;
  17.    private static BigInteger[] posConst = new BigInteger[17];
  18.    private static BigInteger[] negConst = new BigInteger[17];
  19.    private static final byte[] bitLen;
  20.    private static final byte[] bitCnt;
  21.    private static final byte[] trailingZeroCnt;
  22.    private static String[] zeros;
  23.    private static final BigInteger ONE;
  24.    private static final BigInteger TWO;
  25.    private static final char ZERO_CHAR;
  26.    private static int[] digitsPerLong;
  27.    private static BigInteger[] longRadix;
  28.    private static final long serialVersionUID = -8287574255936472291L;
  29.  
  30.    public BigInteger(byte[] var1) throws NumberFormatException {
  31.       this.bitCount = -1;
  32.       this.bitLength = -1;
  33.       this.firstNonzeroByteNum = -2;
  34.       this.lowestSetBit = -2;
  35.       if (var1.length == 0) {
  36.          throw new NumberFormatException("Zero length BigInteger");
  37.       } else if (var1[0] < 0) {
  38.          this.magnitude = makePositive(var1);
  39.          this.signum = -1;
  40.       } else {
  41.          this.magnitude = stripLeadingZeroBytes(var1);
  42.          this.signum = this.magnitude.length == 0 ? 0 : 1;
  43.       }
  44.    }
  45.  
  46.    public BigInteger(int var1, byte[] var2) throws NumberFormatException {
  47.       this.bitCount = -1;
  48.       this.bitLength = -1;
  49.       this.firstNonzeroByteNum = -2;
  50.       this.lowestSetBit = -2;
  51.       this.magnitude = stripLeadingZeroBytes(var2);
  52.       if (var1 >= -1 && var1 <= 1) {
  53.          if (this.magnitude.length == 0) {
  54.             this.signum = 0;
  55.          } else if (var1 == 0) {
  56.             throw new NumberFormatException("signum-magnitude mismatch");
  57.          } else {
  58.             this.signum = var1;
  59.          }
  60.       } else {
  61.          throw new NumberFormatException("Invalid signum value");
  62.       }
  63.    }
  64.  
  65.    public BigInteger(String var1, int var2) throws NumberFormatException {
  66.       this.bitCount = -1;
  67.       this.bitLength = -1;
  68.       this.firstNonzeroByteNum = -2;
  69.       this.lowestSetBit = -2;
  70.       int var3 = 0;
  71.       if (var2 >= 2 && var2 <= 36) {
  72.          if (var1.length() == 0) {
  73.             throw new NumberFormatException("Zero length BigInteger");
  74.          } else {
  75.             this.signum = 1;
  76.             if (var1.charAt(0) == '-') {
  77.                if (var1.length() == 1) {
  78.                   throw new NumberFormatException("Zero length BigInteger");
  79.                }
  80.  
  81.                this.signum = -1;
  82.                var3 = 1;
  83.             }
  84.  
  85.             while(var3 < var1.length() && var1.charAt(var3) == ZERO_CHAR) {
  86.                ++var3;
  87.             }
  88.  
  89.             if (var3 == var1.length()) {
  90.                this.signum = 0;
  91.                this.magnitude = new byte[0];
  92.             } else {
  93.                int var4 = var1.length() - var3;
  94.                int var5 = var4 % digitsPerLong[var2];
  95.                if (var5 == 0) {
  96.                   var5 = digitsPerLong[var2];
  97.                }
  98.  
  99.                int var10;
  100.                String var6 = var1.substring(var3, var10 = var3 + var5);
  101.  
  102.                BigInteger var7;
  103.                long var8;
  104.                for(var7 = valueOf(Long.parseLong(var6, var2)); var10 < var1.length(); var7 = var7.multiply(longRadix[var2]).add(valueOf(var8))) {
  105.                   var6 = var1.substring(var10, var10 += digitsPerLong[var2]);
  106.                   var8 = Long.parseLong(var6, var2);
  107.                   if (var8 < 0L) {
  108.                      throw new NumberFormatException("Illegal digit");
  109.                   }
  110.                }
  111.  
  112.                this.magnitude = var7.magnitude;
  113.             }
  114.          }
  115.       } else {
  116.          throw new NumberFormatException("Radix out of range");
  117.       }
  118.    }
  119.  
  120.    public BigInteger(String var1) throws NumberFormatException {
  121.       this((String)var1, 10);
  122.    }
  123.  
  124.    public BigInteger(int var1, Random var2) throws IllegalArgumentException {
  125.       this(1, (byte[])randomBits(var1, var2));
  126.    }
  127.  
  128.    private static byte[] randomBits(int var0, Random var1) throws IllegalArgumentException {
  129.       if (var0 < 0) {
  130.          throw new IllegalArgumentException("numBits must be non-negative");
  131.       } else {
  132.          int var2 = (var0 + 7) / 8;
  133.          byte[] var3 = new byte[var2];
  134.          if (var2 > 0) {
  135.             var1.nextBytes(var3);
  136.             int var4 = 8 * var2 - var0;
  137.             var3[0] = (byte)(var3[0] & (1 << 8 - var4) - 1);
  138.          }
  139.  
  140.          return var3;
  141.       }
  142.    }
  143.  
  144.    public BigInteger(int var1, int var2, Random var3) {
  145.       this.bitCount = -1;
  146.       this.bitLength = -1;
  147.       this.firstNonzeroByteNum = -2;
  148.       this.lowestSetBit = -2;
  149.       if (var1 < 2) {
  150.          throw new ArithmeticException("bitLength < 2");
  151.       } else {
  152.          BigInteger var5;
  153.          do {
  154.             var5 = (new BigInteger(var1 - 1, var3)).setBit(var1 - 1);
  155.             var5 = var1 <= 16 ? (var1 > 2 ? var5.setBit(0) : var5) : new BigInteger(plumbGeneratePrime(var5.magnitude), 1);
  156.          } while(var5.bitLength() != var1 || !var5.isProbablePrime(var2));
  157.  
  158.          this.signum = 1;
  159.          this.magnitude = var5.magnitude;
  160.       }
  161.    }
  162.  
  163.    private BigInteger(byte[] var1, int var2) {
  164.       this.bitCount = -1;
  165.       this.bitLength = -1;
  166.       this.firstNonzeroByteNum = -2;
  167.       this.lowestSetBit = -2;
  168.       this.signum = var1.length == 0 ? 0 : var2;
  169.       this.magnitude = var1;
  170.    }
  171.  
  172.    public static BigInteger valueOf(long var0) {
  173.       if (var0 == 0L) {
  174.          return ZERO;
  175.       } else if (var0 > 0L && var0 <= 16L) {
  176.          return posConst[(int)var0];
  177.       } else if (var0 < 0L && var0 >= -16L) {
  178.          return negConst[(int)(-var0)];
  179.       } else {
  180.          byte[] var2 = new byte[8];
  181.  
  182.          for(int var3 = 0; var3 < 8; var0 >>= 8) {
  183.             var2[7 - var3] = (byte)((int)var0);
  184.             ++var3;
  185.          }
  186.  
  187.          return new BigInteger(var2);
  188.       }
  189.    }
  190.  
  191.    private static BigInteger valueOf(byte[] var0) {
  192.       return var0[0] > 0 ? new BigInteger(var0, 1) : new BigInteger(var0);
  193.    }
  194.  
  195.    public BigInteger add(BigInteger var1) throws ArithmeticException {
  196.       if (var1.signum == 0) {
  197.          return this;
  198.       } else if (this.signum == 0) {
  199.          return var1;
  200.       } else if (var1.signum == this.signum) {
  201.          return new BigInteger(plumbAdd(this.magnitude, var1.magnitude), this.signum);
  202.       } else {
  203.          return this.signum < 0 ? plumbSubtract(var1.magnitude, this.magnitude) : plumbSubtract(this.magnitude, var1.magnitude);
  204.       }
  205.    }
  206.  
  207.    public BigInteger subtract(BigInteger var1) {
  208.       return this.add(new BigInteger(var1.magnitude, -var1.signum));
  209.    }
  210.  
  211.    public BigInteger multiply(BigInteger var1) {
  212.       return var1.signum != 0 && this.signum != 0 ? new BigInteger(plumbMultiply(this.magnitude, var1.magnitude), this.signum * var1.signum) : ZERO;
  213.    }
  214.  
  215.    public BigInteger divide(BigInteger var1) throws ArithmeticException {
  216.       if (var1.signum == 0) {
  217.          throw new ArithmeticException("BigInteger divide by zero");
  218.       } else {
  219.          return this.signum == 0 ? ZERO : new BigInteger(plumbDivide(this.magnitude, var1.magnitude), this.signum * var1.signum);
  220.       }
  221.    }
  222.  
  223.    public BigInteger remainder(BigInteger var1) throws ArithmeticException {
  224.       if (var1.signum == 0) {
  225.          throw new ArithmeticException("BigInteger divide by zero");
  226.       } else if (this.signum == 0) {
  227.          return ZERO;
  228.       } else {
  229.          return this.magnitude.length < var1.magnitude.length ? this : new BigInteger(plumbRemainder(this.magnitude, var1.magnitude), this.signum);
  230.       }
  231.    }
  232.  
  233.    public BigInteger[] divideAndRemainder(BigInteger var1) throws ArithmeticException {
  234.       BigInteger[] var2 = new BigInteger[2];
  235.       if (var1.signum == 0) {
  236.          throw new ArithmeticException("BigInteger divide by zero");
  237.       } else {
  238.          if (this.signum == 0) {
  239.             var2[0] = var2[1] = ZERO;
  240.          } else if (this.magnitude.length < var1.magnitude.length) {
  241.             var2[0] = ZERO;
  242.             var2[1] = this;
  243.          } else {
  244.             byte[][] var3 = plumbDivideAndRemainder(this.magnitude, var1.magnitude);
  245.             var2[0] = new BigInteger(var3[0], this.signum * var1.signum);
  246.             var2[1] = new BigInteger(var3[1], this.signum);
  247.          }
  248.  
  249.          return var2;
  250.       }
  251.    }
  252.  
  253.    public BigInteger pow(int var1) throws ArithmeticException {
  254.       if (var1 < 0) {
  255.          throw new ArithmeticException("Negative exponent");
  256.       } else if (this.signum == 0) {
  257.          return var1 == 0 ? ONE : this;
  258.       } else {
  259.          BigInteger var2 = valueOf((long)(var1 < 0 && (var1 & 1) == 1 ? -1 : 1));
  260.          BigInteger var3 = this;
  261.  
  262.          while(var1 != 0) {
  263.             if ((var1 & 1) == 1) {
  264.                var2 = var2.multiply(var3);
  265.             }
  266.  
  267.             if ((var1 >>= 1) != 0) {
  268.                var3 = new BigInteger(plumbSquare(var3.magnitude), 1);
  269.             }
  270.          }
  271.  
  272.          return var2;
  273.       }
  274.    }
  275.  
  276.    public BigInteger gcd(BigInteger var1) {
  277.       if (var1.signum == 0) {
  278.          return this.abs();
  279.       } else {
  280.          return this.signum == 0 ? var1.abs() : new BigInteger(plumbGcd(this.magnitude, var1.magnitude), 1);
  281.       }
  282.    }
  283.  
  284.    public BigInteger abs() {
  285.       return this.signum >= 0 ? this : this.negate();
  286.    }
  287.  
  288.    public BigInteger negate() {
  289.       return new BigInteger(this.magnitude, -this.signum);
  290.    }
  291.  
  292.    public int signum() {
  293.       return this.signum;
  294.    }
  295.  
  296.    public BigInteger mod(BigInteger var1) {
  297.       if (var1.signum <= 0) {
  298.          throw new ArithmeticException("BigInteger: modulus not positive");
  299.       } else {
  300.          BigInteger var2 = this.remainder(var1);
  301.          return var2.signum >= 0 ? var2 : var2.add(var1);
  302.       }
  303.    }
  304.  
  305.    public BigInteger modPow(BigInteger var1, BigInteger var2) {
  306.       if (var2.signum <= 0) {
  307.          throw new ArithmeticException("BigInteger: modulus not positive");
  308.       } else if (var1.signum == 0) {
  309.          return ONE;
  310.       } else {
  311.          boolean var3;
  312.          if (var3 = var1.signum < 0) {
  313.             var1 = var1.negate();
  314.          }
  315.  
  316.          BigInteger var4 = this.signum >= 0 && this.compareTo(var2) < 0 ? this : this.mod(var2);
  317.          BigInteger var5;
  318.          if (var2.testBit(0)) {
  319.             var5 = new BigInteger(plumbModPow(var4.magnitude, var1.magnitude, var2.magnitude), 1);
  320.          } else {
  321.             int var6 = var2.getLowestSetBit();
  322.             BigInteger var7 = var2.shiftRight(var6);
  323.             BigInteger var8 = ONE.shiftLeft(var6);
  324.             BigInteger var9 = new BigInteger(plumbModPow(var4.magnitude, var1.magnitude, var7.magnitude), 1);
  325.             BigInteger var10 = var4.modPow2(var1, var6);
  326.             BigInteger var11 = var8.modInverse(var7);
  327.             BigInteger var12 = var7.modInverse(var8);
  328.             var5 = var9.multiply(var8).multiply(var11).add(var10.multiply(var7).multiply(var12)).mod(var2);
  329.          }
  330.  
  331.          return var3 ? var5.modInverse(var2) : var5;
  332.       }
  333.    }
  334.  
  335.    private BigInteger modPow2(BigInteger var1, int var2) {
  336.       BigInteger var3 = valueOf(1L);
  337.       BigInteger var4 = this.mod2(var2);
  338.  
  339.       while(var1.signum != 0) {
  340.          if (var1.testBit(0)) {
  341.             var3 = var3.multiply(var4).mod2(var2);
  342.          }
  343.  
  344.          var1 = var1.shiftRight(1);
  345.          if (var1.signum != 0) {
  346.             var4 = (new BigInteger(plumbSquare(var4.magnitude), 1)).mod2(var2);
  347.          }
  348.       }
  349.  
  350.       return var3;
  351.    }
  352.  
  353.    private BigInteger mod2(int var1) {
  354.       if (this.bitLength() <= var1) {
  355.          return this;
  356.       } else {
  357.          int var2 = (var1 + 7) / 8;
  358.          byte[] var3 = new byte[var2];
  359.  
  360.          for(int var4 = 0; var4 < var2; ++var4) {
  361.             var3[var4] = this.magnitude[var4 + (this.magnitude.length - var2)];
  362.          }
  363.  
  364.          int var5 = 8 * var2 - var1;
  365.          var3[0] = (byte)(var3[0] & (1 << 8 - var5) - 1);
  366.          return var3[0] == 0 ? new BigInteger(1, var3) : new BigInteger(var3, 1);
  367.       }
  368.    }
  369.  
  370.    public BigInteger modInverse(BigInteger var1) throws ArithmeticException {
  371.       if (var1.signum != 1) {
  372.          throw new ArithmeticException("BigInteger: modulus not positive");
  373.       } else {
  374.          BigInteger var2 = this.remainder(var1);
  375.          if (var2.signum < 0) {
  376.             var2 = var2.add(var1);
  377.          }
  378.  
  379.          if (!var2.gcd(var1).equals(ONE)) {
  380.             throw new ArithmeticException("BigInteger not invertible");
  381.          } else {
  382.             return new BigInteger(plumbModInverse(var2.magnitude, var1.magnitude), 1);
  383.          }
  384.       }
  385.    }
  386.  
  387.    public BigInteger shiftLeft(int var1) {
  388.       if (var1 == 0) {
  389.          return this;
  390.       } else if (var1 < 0) {
  391.          return this.shiftRight(-var1);
  392.       } else {
  393.          int var2 = var1 / 8;
  394.          int var3 = var1 % 8;
  395.          byte[] var4 = new byte[(this.bitLength() + var1) / 8 + 1];
  396.          if (var3 == 0) {
  397.             for(int var5 = var2; var5 < var4.length; ++var5) {
  398.                var4[var4.length - 1 - var5] = this.getByte(var5 - var2);
  399.             }
  400.          } else {
  401.             for(int var6 = var2; var6 < var4.length; ++var6) {
  402.                var4[var4.length - 1 - var6] = (byte)(this.getByte(var6 - var2) << var3 | (var6 == var2 ? 0 : (this.getByte(var6 - var2 - 1) & 255) >> 8 - var3));
  403.             }
  404.          }
  405.  
  406.          return valueOf(var4);
  407.       }
  408.    }
  409.  
  410.    public BigInteger shiftRight(int var1) {
  411.       if (var1 == 0) {
  412.          return this;
  413.       } else if (var1 < 0) {
  414.          return this.shiftLeft(-var1);
  415.       } else if (var1 >= this.bitLength()) {
  416.          return this.signum < 0 ? valueOf(-1L) : ZERO;
  417.       } else {
  418.          int var2 = var1 / 8;
  419.          int var3 = var1 % 8;
  420.          byte[] var4 = new byte[(this.bitLength - var1) / 8 + 1];
  421.          if (var3 == 0) {
  422.             for(int var5 = 0; var5 < var4.length; ++var5) {
  423.                var4[var4.length - 1 - var5] = this.getByte(var2 + var5);
  424.             }
  425.          } else {
  426.             for(int var6 = 0; var6 < var4.length; ++var6) {
  427.                var4[var4.length - 1 - var6] = (byte)((this.getByte(var2 + var6 + 1) << 8 | this.getByte(var2 + var6) & 255) >> var3);
  428.             }
  429.          }
  430.  
  431.          return valueOf(var4);
  432.       }
  433.    }
  434.  
  435.    public BigInteger and(BigInteger var1) {
  436.       byte[] var2 = new byte[Math.max(this.byteLength(), var1.byteLength())];
  437.  
  438.       for(int var3 = 0; var3 < var2.length; ++var3) {
  439.          var2[var3] = (byte)(this.getByte(var2.length - var3 - 1) & var1.getByte(var2.length - var3 - 1));
  440.       }
  441.  
  442.       return valueOf(var2);
  443.    }
  444.  
  445.    // $FF: renamed from: or (java.math.BigInteger) java.math.BigInteger
  446.    public BigInteger method_0(BigInteger var1) {
  447.       byte[] var2 = new byte[Math.max(this.byteLength(), var1.byteLength())];
  448.  
  449.       for(int var3 = 0; var3 < var2.length; ++var3) {
  450.          var2[var3] = (byte)(this.getByte(var2.length - var3 - 1) | var1.getByte(var2.length - var3 - 1));
  451.       }
  452.  
  453.       return valueOf(var2);
  454.    }
  455.  
  456.    public BigInteger xor(BigInteger var1) {
  457.       byte[] var2 = new byte[Math.max(this.byteLength(), var1.byteLength())];
  458.  
  459.       for(int var3 = 0; var3 < var2.length; ++var3) {
  460.          var2[var3] = (byte)(this.getByte(var2.length - var3 - 1) ^ var1.getByte(var2.length - var3 - 1));
  461.       }
  462.  
  463.       return valueOf(var2);
  464.    }
  465.  
  466.    public BigInteger not() {
  467.       byte[] var1 = new byte[this.byteLength()];
  468.  
  469.       for(int var2 = 0; var2 < var1.length; ++var2) {
  470.          var1[var2] = (byte)(~this.getByte(var1.length - var2 - 1));
  471.       }
  472.  
  473.       return valueOf(var1);
  474.    }
  475.  
  476.    public BigInteger andNot(BigInteger var1) {
  477.       byte[] var2 = new byte[Math.max(this.byteLength(), var1.byteLength())];
  478.  
  479.       for(int var3 = 0; var3 < var2.length; ++var3) {
  480.          var2[var3] = (byte)(this.getByte(var2.length - var3 - 1) & ~var1.getByte(var2.length - var3 - 1));
  481.       }
  482.  
  483.       return valueOf(var2);
  484.    }
  485.  
  486.    public boolean testBit(int var1) throws ArithmeticException {
  487.       if (var1 < 0) {
  488.          throw new ArithmeticException("Negative bit address");
  489.       } else {
  490.          return (this.getByte(var1 / 8) & 1 << var1 % 8) != 0;
  491.       }
  492.    }
  493.  
  494.    public BigInteger setBit(int var1) throws ArithmeticException {
  495.       if (var1 < 0) {
  496.          throw new ArithmeticException("Negative bit address");
  497.       } else {
  498.          int var2 = var1 / 8;
  499.          byte[] var3 = new byte[Math.max(this.byteLength(), var2 + 2)];
  500.  
  501.          for(int var4 = 0; var4 < var3.length; ++var4) {
  502.             var3[var3.length - var4 - 1] = this.getByte(var4);
  503.          }
  504.  
  505.          var3[var3.length - var2 - 1] = (byte)(var3[var3.length - var2 - 1] | 1 << var1 % 8);
  506.          return valueOf(var3);
  507.       }
  508.    }
  509.  
  510.    public BigInteger clearBit(int var1) throws ArithmeticException {
  511.       if (var1 < 0) {
  512.          throw new ArithmeticException("Negative bit address");
  513.       } else {
  514.          int var2 = var1 / 8;
  515.          byte[] var3 = new byte[Math.max(this.byteLength(), (var1 + 1) / 8 + 1)];
  516.  
  517.          for(int var4 = 0; var4 < var3.length; ++var4) {
  518.             var3[var3.length - var4 - 1] = this.getByte(var4);
  519.          }
  520.  
  521.          var3[var3.length - var2 - 1] = (byte)(var3[var3.length - var2 - 1] & ~(1 << var1 % 8));
  522.          return valueOf(var3);
  523.       }
  524.    }
  525.  
  526.    public BigInteger flipBit(int var1) throws ArithmeticException {
  527.       if (var1 < 0) {
  528.          throw new ArithmeticException("Negative bit address");
  529.       } else {
  530.          int var2 = var1 / 8;
  531.          byte[] var3 = new byte[Math.max(this.byteLength(), var2 + 2)];
  532.  
  533.          for(int var4 = 0; var4 < var3.length; ++var4) {
  534.             var3[var3.length - var4 - 1] = this.getByte(var4);
  535.          }
  536.  
  537.          var3[var3.length - var2 - 1] = (byte)(var3[var3.length - var2 - 1] ^ 1 << var1 % 8);
  538.          return valueOf(var3);
  539.       }
  540.    }
  541.  
  542.    public int getLowestSetBit() {
  543.       if (this.lowestSetBit == -2) {
  544.          if (this.signum == 0) {
  545.             this.lowestSetBit = -1;
  546.          } else {
  547.             int var1;
  548.             byte var2;
  549.             for(var1 = 0; (var2 = this.getByte(var1)) == 0; ++var1) {
  550.             }
  551.  
  552.             this.lowestSetBit = 8 * var1 + trailingZeroCnt[var2 & 255];
  553.          }
  554.       }
  555.  
  556.       return this.lowestSetBit;
  557.    }
  558.  
  559.    public int bitLength() {
  560.       if (this.bitLength == -1) {
  561.          if (this.signum == 0) {
  562.             this.bitLength = 0;
  563.          } else {
  564.             int var1 = 8 * (this.magnitude.length - 1) + bitLen[this.magnitude[0] & 255];
  565.             if (this.signum < 0) {
  566.                boolean var2 = bitCnt[this.magnitude[0] & 255] == 1;
  567.  
  568.                for(int var3 = 1; var3 < this.magnitude.length && var2; ++var3) {
  569.                   var2 = this.magnitude[var3] == 0;
  570.                }
  571.  
  572.                this.bitLength = var2 ? var1 - 1 : var1;
  573.             } else {
  574.                this.bitLength = var1;
  575.             }
  576.          }
  577.       }
  578.  
  579.       return this.bitLength;
  580.    }
  581.  
  582.    public int bitCount() {
  583.       if (this.bitCount == -1) {
  584.          int var1 = 0;
  585.  
  586.          for(int var2 = 0; var2 < this.magnitude.length; ++var2) {
  587.             var1 += bitCnt[this.magnitude[var2] & 255];
  588.          }
  589.  
  590.          if (this.signum < 0) {
  591.             int var3 = 0;
  592.  
  593.             int var4;
  594.             for(var4 = this.magnitude.length - 1; this.magnitude[var4] == 0; --var4) {
  595.                var3 += 8;
  596.             }
  597.  
  598.             var3 += trailingZeroCnt[this.magnitude[var4] & 255];
  599.             this.bitCount = var1 + var3 - 1;
  600.          } else {
  601.             this.bitCount = var1;
  602.          }
  603.       }
  604.  
  605.       return this.bitCount;
  606.    }
  607.  
  608.    public boolean isProbablePrime(int var1) {
  609.       int var2 = var1 / 2;
  610.       if (var2 <= 0) {
  611.          return true;
  612.       } else {
  613.          BigInteger var3 = this.abs();
  614.          if (var3.equals(TWO)) {
  615.             return true;
  616.          } else if (var3.testBit(0) && !var3.equals(ONE)) {
  617.             BigInteger var4 = var3.subtract(ONE);
  618.             int var5 = var4.getLowestSetBit();
  619.             var4 = var4.shiftRight(var5);
  620.             Random var6 = new Random();
  621.  
  622.             for(int var7 = 0; var7 < var2; ++var7) {
  623.                BigInteger var8;
  624.                do {
  625.                   var8 = new BigInteger(var3.bitLength(), var6);
  626.                } while(var8.compareTo(ONE) <= 0 || var8.compareTo(var3) >= 0);
  627.  
  628.                int var9 = 0;
  629.  
  630.                for(BigInteger var10 = var8.modPow(var4, var3); (var9 != 0 || !var10.equals(ONE)) && !var10.equals(var3.subtract(ONE)); var10 = var10.modPow(TWO, var3)) {
  631.                   if (var9 > 0 && var10.equals(ONE)) {
  632.                      return false;
  633.                   }
  634.  
  635.                   ++var9;
  636.                   if (var9 == var5) {
  637.                      return false;
  638.                   }
  639.                }
  640.             }
  641.  
  642.             return true;
  643.          } else {
  644.             return false;
  645.          }
  646.       }
  647.    }
  648.  
  649.    public int compareTo(BigInteger var1) {
  650.       if (this.signum == var1.signum) {
  651.          return this.signum * byteArrayCmp(this.magnitude, var1.magnitude);
  652.       } else {
  653.          return this.signum > var1.signum ? 1 : -1;
  654.       }
  655.    }
  656.  
  657.    private static int byteArrayCmp(byte[] var0, byte[] var1) {
  658.       if (var0.length < var1.length) {
  659.          return -1;
  660.       } else if (var0.length > var1.length) {
  661.          return 1;
  662.       } else {
  663.          for(int var2 = 0; var2 < var0.length; ++var2) {
  664.             int var3 = var0[var2] & 255;
  665.             int var4 = var1[var2] & 255;
  666.             if (var3 < var4) {
  667.                return -1;
  668.             }
  669.  
  670.             if (var3 > var4) {
  671.                return 1;
  672.             }
  673.          }
  674.  
  675.          return 0;
  676.       }
  677.    }
  678.  
  679.    public boolean equals(Object var1) {
  680.       if (!(var1 instanceof BigInteger)) {
  681.          return false;
  682.       } else {
  683.          BigInteger var2 = (BigInteger)var1;
  684.          if (var2.signum == this.signum && var2.magnitude.length == this.magnitude.length) {
  685.             if (var2 == this) {
  686.                return true;
  687.             } else {
  688.                for(int var3 = 0; var3 < this.magnitude.length; ++var3) {
  689.                   if (var2.magnitude[var3] != this.magnitude[var3]) {
  690.                      return false;
  691.                   }
  692.                }
  693.  
  694.                return true;
  695.             }
  696.          } else {
  697.             return false;
  698.          }
  699.       }
  700.    }
  701.  
  702.    public BigInteger min(BigInteger var1) {
  703.       return this.compareTo(var1) < 0 ? this : var1;
  704.    }
  705.  
  706.    public BigInteger max(BigInteger var1) {
  707.       return this.compareTo(var1) > 0 ? this : var1;
  708.    }
  709.  
  710.    public int hashCode() {
  711.       int var1 = 0;
  712.  
  713.       for(int var2 = 0; var2 < this.magnitude.length; ++var2) {
  714.          var1 = 37 * var1 + (this.magnitude[var2] & 255);
  715.       }
  716.  
  717.       return var1 * this.signum;
  718.    }
  719.  
  720.    public String toString(int var1) {
  721.       if (this.signum == 0) {
  722.          return "0";
  723.       } else {
  724.          if (var1 < 2 || var1 > 36) {
  725.             var1 = 10;
  726.          }
  727.  
  728.          int var2 = (this.magnitude.length + 6) / 7;
  729.          String[] var3 = new String[var2];
  730.          BigInteger var4 = this.abs();
  731.  
  732.          int var5;
  733.          BigInteger[] var6;
  734.          for(var5 = 0; var4.signum != 0; var4 = var6[0]) {
  735.             var6 = var4.divideAndRemainder(longRadix[var1]);
  736.             var3[var5++] = Long.toString(var6[1].longValue(), var1);
  737.          }
  738.  
  739.          StringBuffer var9 = new StringBuffer(var5 * digitsPerLong[var1] + 1);
  740.          if (this.signum < 0) {
  741.             var9.append('-');
  742.          }
  743.  
  744.          var9.append(var3[var5 - 1]);
  745.  
  746.          for(int var7 = var5 - 2; var7 >= 0; --var7) {
  747.             int var8 = digitsPerLong[var1] - var3[var7].length();
  748.             if (var8 != 0) {
  749.                var9.append(zeros[var8]);
  750.             }
  751.  
  752.             var9.append(var3[var7]);
  753.          }
  754.  
  755.          return var9.toString();
  756.       }
  757.    }
  758.  
  759.    public String toString() {
  760.       return this.toString(10);
  761.    }
  762.  
  763.    public byte[] toByteArray() {
  764.       byte[] var1 = new byte[this.byteLength()];
  765.  
  766.       for(int var2 = 0; var2 < var1.length; ++var2) {
  767.          var1[var2] = this.getByte(var1.length - var2 - 1);
  768.       }
  769.  
  770.       return var1;
  771.    }
  772.  
  773.    public int intValue() {
  774.       int var1 = 0;
  775.  
  776.       for(int var2 = 3; var2 >= 0; --var2) {
  777.          var1 = (var1 << 8) + (this.getByte(var2) & 255);
  778.       }
  779.  
  780.       return var1;
  781.    }
  782.  
  783.    public long longValue() {
  784.       long var1 = 0L;
  785.  
  786.       for(int var3 = 7; var3 >= 0; --var3) {
  787.          var1 = (var1 << 8) + (long)(this.getByte(var3) & 255);
  788.       }
  789.  
  790.       return var1;
  791.    }
  792.  
  793.    public float floatValue() {
  794.       return Float.valueOf(this.toString());
  795.    }
  796.  
  797.    public double doubleValue() {
  798.       return Double.valueOf(this.toString());
  799.    }
  800.  
  801.    private static byte[] stripLeadingZeroBytes(byte[] var0) {
  802.       int var1;
  803.       for(var1 = 0; var1 < var0.length && var0[var1] == 0; ++var1) {
  804.       }
  805.  
  806.       byte[] var2 = new byte[var0.length - var1];
  807.  
  808.       for(int var3 = var1; var3 < var0.length; ++var3) {
  809.          var2[var3 - var1] = var0[var3];
  810.       }
  811.  
  812.       return var2;
  813.    }
  814.  
  815.    private static byte[] makePositive(byte[] var0) {
  816.       int var1;
  817.       for(var1 = 0; var1 < var0.length && var0[var1] == -1; ++var1) {
  818.       }
  819.  
  820.       int var2;
  821.       for(var2 = var1; var2 < var0.length && var0[var2] == 0; ++var2) {
  822.       }
  823.  
  824.       int var3 = var2 == var0.length ? 1 : 0;
  825.       byte[] var4 = new byte[var0.length - var1 + var3];
  826.  
  827.       for(int var5 = var1; var5 < var0.length; ++var5) {
  828.          var4[var5 - var1 + var3] = (byte)(~var0[var5]);
  829.       }
  830.  
  831.       for(int var6 = var4.length - 1; ++var4[var6] == 0; --var6) {
  832.       }
  833.  
  834.       return var4;
  835.    }
  836.  
  837.    private int byteLength() {
  838.       return this.bitLength() / 8 + 1;
  839.    }
  840.  
  841.    private int signBit() {
  842.       return this.signum < 0 ? 1 : 0;
  843.    }
  844.  
  845.    private byte signByte() {
  846.       return (byte)(this.signum < 0 ? -1 : 0);
  847.    }
  848.  
  849.    private byte getByte(int var1) {
  850.       if (var1 >= this.magnitude.length) {
  851.          return this.signByte();
  852.       } else {
  853.          byte var2 = this.magnitude[this.magnitude.length - var1 - 1];
  854.          return (byte)(this.signum >= 0 ? var2 : (var1 <= this.firstNonzeroByteNum() ? -var2 : ~var2));
  855.       }
  856.    }
  857.  
  858.    private int firstNonzeroByteNum() {
  859.       if (this.firstNonzeroByteNum == -2) {
  860.          int var1;
  861.          for(var1 = this.magnitude.length - 1; var1 >= 0 && this.magnitude[var1] == 0; --var1) {
  862.          }
  863.  
  864.          this.firstNonzeroByteNum = this.magnitude.length - var1 - 1;
  865.       }
  866.  
  867.       return this.firstNonzeroByteNum;
  868.    }
  869.  
  870.    private static native void plumbInit();
  871.  
  872.    private static native byte[] plumbAdd(byte[] var0, byte[] var1);
  873.  
  874.    private static native BigInteger plumbSubtract(byte[] var0, byte[] var1);
  875.  
  876.    private static native byte[] plumbMultiply(byte[] var0, byte[] var1);
  877.  
  878.    private static native byte[] plumbDivide(byte[] var0, byte[] var1);
  879.  
  880.    private static native byte[] plumbRemainder(byte[] var0, byte[] var1);
  881.  
  882.    private static native byte[][] plumbDivideAndRemainder(byte[] var0, byte[] var1);
  883.  
  884.    private static native byte[] plumbGcd(byte[] var0, byte[] var1);
  885.  
  886.    private static native byte[] plumbModPow(byte[] var0, byte[] var1, byte[] var2);
  887.  
  888.    private static native byte[] plumbModInverse(byte[] var0, byte[] var1);
  889.  
  890.    private static native byte[] plumbSquare(byte[] var0);
  891.  
  892.    private static native byte[] plumbGeneratePrime(byte[] var0);
  893.  
  894.    private synchronized void readObject(ObjectInputStream var1) throws IOException, ClassNotFoundException {
  895.       var1.defaultReadObject();
  896.       this.magnitude = (byte[])this.magnitude.clone();
  897.       if (this.signum >= -1 && this.signum <= 1) {
  898.          if (this.magnitude.length == 0 != (this.signum == 0)) {
  899.             throw new StreamCorruptedException("BigInteger: signum-magnitude mismatch");
  900.          } else {
  901.             this.bitCount = this.bitLength = -1;
  902.             this.lowestSetBit = this.firstNonzeroByteNum = -2;
  903.          }
  904.       } else {
  905.          throw new StreamCorruptedException("BigInteger: Invalid signum value");
  906.       }
  907.    }
  908.  
  909.    static {
  910.       for(int var0 = 1; var0 <= 16; ++var0) {
  911.          byte[] var1 = new byte[]{(byte)var0};
  912.          posConst[var0] = new BigInteger(var1, 1);
  913.          negConst[var0] = new BigInteger(var1, -1);
  914.       }
  915.  
  916.       bitLen = new byte[]{0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8};
  917.       bitCnt = new byte[]{0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8};
  918.       trailingZeroCnt = new byte[]{8, 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};
  919.       zeros = new String[64];
  920.       zeros[63] = "000000000000000000000000000000000000000000000000000000000000000";
  921.  
  922.       for(int var2 = 0; var2 < 63; ++var2) {
  923.          zeros[var2] = zeros[63].substring(0, var2);
  924.       }
  925.  
  926.       System.loadLibrary("math");
  927.       plumbInit();
  928.       ONE = valueOf(1L);
  929.       TWO = valueOf(2L);
  930.       ZERO_CHAR = Character.forDigit(0, 2);
  931.       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};
  932.       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)};
  933.    }
  934. }
  935.