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