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 / MutableBigInteger.class (.txt) < prev    next >
Encoding:
Java Class File  |  2006-11-29  |  9.4 KB  |  1,060 lines
  1. package java.math;
  2.  
  3. class MutableBigInteger {
  4.    int[] value;
  5.    int intLen;
  6.    int offset = 0;
  7.    private static final long LONG_MASK = 4294967295L;
  8.  
  9.    MutableBigInteger() {
  10.       this.value = new int[1];
  11.       this.intLen = 0;
  12.    }
  13.  
  14.    MutableBigInteger(int var1) {
  15.       this.value = new int[1];
  16.       this.intLen = 1;
  17.       this.value[0] = var1;
  18.    }
  19.  
  20.    MutableBigInteger(int[] var1, int var2) {
  21.       this.value = var1;
  22.       this.intLen = var2;
  23.    }
  24.  
  25.    MutableBigInteger(int[] var1) {
  26.       this.value = var1;
  27.       this.intLen = var1.length;
  28.    }
  29.  
  30.    MutableBigInteger(BigInteger var1) {
  31.       this.value = (int[])var1.mag.clone();
  32.       this.intLen = this.value.length;
  33.    }
  34.  
  35.    MutableBigInteger(MutableBigInteger var1) {
  36.       this.intLen = var1.intLen;
  37.       this.value = new int[this.intLen];
  38.  
  39.       for(int var2 = 0; var2 < this.intLen; ++var2) {
  40.          this.value[var2] = var1.value[var1.offset + var2];
  41.       }
  42.  
  43.    }
  44.  
  45.    void clear() {
  46.       this.offset = this.intLen = 0;
  47.       int var1 = 0;
  48.  
  49.       for(int var2 = this.value.length; var1 < var2; ++var1) {
  50.          this.value[var1] = 0;
  51.       }
  52.  
  53.    }
  54.  
  55.    void reset() {
  56.       this.offset = this.intLen = 0;
  57.    }
  58.  
  59.    final int compare(MutableBigInteger var1) {
  60.       if (this.intLen < var1.intLen) {
  61.          return -1;
  62.       } else if (this.intLen > var1.intLen) {
  63.          return 1;
  64.       } else {
  65.          for(int var2 = 0; var2 < this.intLen; ++var2) {
  66.             int var3 = this.value[this.offset + var2] + Integer.MIN_VALUE;
  67.             int var4 = var1.value[var1.offset + var2] + Integer.MIN_VALUE;
  68.             if (var3 < var4) {
  69.                return -1;
  70.             }
  71.  
  72.             if (var3 > var4) {
  73.                return 1;
  74.             }
  75.          }
  76.  
  77.          return 0;
  78.       }
  79.    }
  80.  
  81.    private final int getLowestSetBit() {
  82.       if (this.intLen == 0) {
  83.          return -1;
  84.       } else {
  85.          int var1;
  86.          for(var1 = this.intLen - 1; var1 > 0 && this.value[var1 + this.offset] == 0; --var1) {
  87.          }
  88.  
  89.          int var2 = this.value[var1 + this.offset];
  90.          return var2 == 0 ? -1 : (this.intLen - 1 - var1 << 5) + BigInteger.trailingZeroCnt(var2);
  91.       }
  92.    }
  93.  
  94.    private final int getInt(int var1) {
  95.       return this.value[this.offset + var1];
  96.    }
  97.  
  98.    private final long getLong(int var1) {
  99.       return (long)this.value[this.offset + var1] & 4294967295L;
  100.    }
  101.  
  102.    final void normalize() {
  103.       if (this.intLen == 0) {
  104.          this.offset = 0;
  105.       } else {
  106.          int var1 = this.offset;
  107.          if (this.value[var1] == 0) {
  108.             int var2 = var1 + this.intLen;
  109.  
  110.             do {
  111.                ++var1;
  112.             } while(var1 < var2 && this.value[var1] == 0);
  113.  
  114.             int var3 = var1 - this.offset;
  115.             this.intLen -= var3;
  116.             this.offset = this.intLen == 0 ? 0 : this.offset + var3;
  117.          }
  118.       }
  119.    }
  120.  
  121.    private final void ensureCapacity(int var1) {
  122.       if (this.value.length < var1) {
  123.          this.value = new int[var1];
  124.          this.offset = 0;
  125.          this.intLen = var1;
  126.       }
  127.  
  128.    }
  129.  
  130.    int[] toIntArray() {
  131.       int[] var1 = new int[this.intLen];
  132.  
  133.       for(int var2 = 0; var2 < this.intLen; ++var2) {
  134.          var1[var2] = this.value[this.offset + var2];
  135.       }
  136.  
  137.       return var1;
  138.    }
  139.  
  140.    void setInt(int var1, int var2) {
  141.       this.value[this.offset + var1] = var2;
  142.    }
  143.  
  144.    void setValue(int[] var1, int var2) {
  145.       this.value = var1;
  146.       this.intLen = var2;
  147.       this.offset = 0;
  148.    }
  149.  
  150.    void copyValue(MutableBigInteger var1) {
  151.       int var2 = var1.intLen;
  152.       if (this.value.length < var2) {
  153.          this.value = new int[var2];
  154.       }
  155.  
  156.       for(int var3 = 0; var3 < var2; ++var3) {
  157.          this.value[var3] = var1.value[var1.offset + var3];
  158.       }
  159.  
  160.       this.intLen = var2;
  161.       this.offset = 0;
  162.    }
  163.  
  164.    void copyValue(int[] var1) {
  165.       int var2 = var1.length;
  166.       if (this.value.length < var2) {
  167.          this.value = new int[var2];
  168.       }
  169.  
  170.       for(int var3 = 0; var3 < var2; ++var3) {
  171.          this.value[var3] = var1[var3];
  172.       }
  173.  
  174.       this.intLen = var2;
  175.       this.offset = 0;
  176.    }
  177.  
  178.    boolean isOne() {
  179.       return this.intLen == 1 && this.value[this.offset] == 1;
  180.    }
  181.  
  182.    boolean isZero() {
  183.       return this.intLen == 0;
  184.    }
  185.  
  186.    boolean isEven() {
  187.       return this.intLen == 0 || (this.value[this.offset + this.intLen - 1] & 1) == 0;
  188.    }
  189.  
  190.    boolean isOdd() {
  191.       return (this.value[this.offset + this.intLen - 1] & 1) == 1;
  192.    }
  193.  
  194.    boolean isNormal() {
  195.       if (this.intLen + this.offset > this.value.length) {
  196.          return false;
  197.       } else if (this.intLen == 0) {
  198.          return true;
  199.       } else {
  200.          return this.value[this.offset] != 0;
  201.       }
  202.    }
  203.  
  204.    public String toString() {
  205.       BigInteger var1 = new BigInteger(this, 1);
  206.       return var1.toString();
  207.    }
  208.  
  209.    void rightShift(int var1) {
  210.       if (this.intLen != 0) {
  211.          int var2 = var1 >>> 5;
  212.          int var3 = var1 & 31;
  213.          this.intLen -= var2;
  214.          if (var3 != 0) {
  215.             int var4 = BigInteger.bitLen(this.value[this.offset]);
  216.             if (var3 >= var4) {
  217.                this.primitiveLeftShift(32 - var3);
  218.                --this.intLen;
  219.             } else {
  220.                this.primitiveRightShift(var3);
  221.             }
  222.  
  223.          }
  224.       }
  225.    }
  226.  
  227.    void leftShift(int var1) {
  228.       if (this.intLen != 0) {
  229.          int var2 = var1 >>> 5;
  230.          int var3 = var1 & 31;
  231.          int var4 = BigInteger.bitLen(this.value[this.offset]);
  232.          if (var1 <= 32 - var4) {
  233.             this.primitiveLeftShift(var3);
  234.          } else {
  235.             int var5 = this.intLen + var2 + 1;
  236.             if (var3 <= 32 - var4) {
  237.                --var5;
  238.             }
  239.  
  240.             if (this.value.length < var5) {
  241.                int[] var6 = new int[var5];
  242.  
  243.                for(int var7 = 0; var7 < this.intLen; ++var7) {
  244.                   var6[var7] = this.value[this.offset + var7];
  245.                }
  246.  
  247.                this.setValue(var6, var5);
  248.             } else if (this.value.length - this.offset >= var5) {
  249.                for(int var8 = 0; var8 < var5 - this.intLen; ++var8) {
  250.                   this.value[this.offset + this.intLen + var8] = 0;
  251.                }
  252.             } else {
  253.                for(int var9 = 0; var9 < this.intLen; ++var9) {
  254.                   this.value[var9] = this.value[this.offset + var9];
  255.                }
  256.  
  257.                for(int var10 = this.intLen; var10 < var5; ++var10) {
  258.                   this.value[var10] = 0;
  259.                }
  260.  
  261.                this.offset = 0;
  262.             }
  263.  
  264.             this.intLen = var5;
  265.             if (var3 != 0) {
  266.                if (var3 <= 32 - var4) {
  267.                   this.primitiveLeftShift(var3);
  268.                } else {
  269.                   this.primitiveRightShift(32 - var3);
  270.                }
  271.  
  272.             }
  273.          }
  274.       }
  275.    }
  276.  
  277.    private int divadd(int[] var1, int[] var2, int var3) {
  278.       long var4 = 0L;
  279.  
  280.       for(int var6 = var1.length - 1; var6 >= 0; --var6) {
  281.          long var7 = ((long)var1[var6] & 4294967295L) + ((long)var2[var6 + var3] & 4294967295L) + var4;
  282.          var2[var6 + var3] = (int)var7;
  283.          var4 = var7 >>> 32;
  284.       }
  285.  
  286.       return (int)var4;
  287.    }
  288.  
  289.    private int mulsub(int[] var1, int[] var2, int var3, int var4, int var5) {
  290.       long var6 = (long)var3 & 4294967295L;
  291.       long var8 = 0L;
  292.       var5 += var4;
  293.  
  294.       for(int var10 = var4 - 1; var10 >= 0; --var10) {
  295.          long var11 = ((long)var2[var10] & 4294967295L) * var6 + var8;
  296.          long var13 = (long)var1[var5] - var11;
  297.          var1[var5--] = (int)var13;
  298.          var8 = (var11 >>> 32) + (long)((var13 & 4294967295L) > ((long)(~((int)var11)) & 4294967295L) ? 1 : 0);
  299.       }
  300.  
  301.       return (int)var8;
  302.    }
  303.  
  304.    private final void primitiveRightShift(int var1) {
  305.       int[] var2 = this.value;
  306.       int var3 = 32 - var1;
  307.       int var4 = this.offset + this.intLen - 1;
  308.  
  309.       for(int var5 = var2[var4]; var4 > this.offset; --var4) {
  310.          int var6 = var5;
  311.          var5 = var2[var4 - 1];
  312.          var2[var4] = var5 << var3 | var6 >>> var1;
  313.       }
  314.  
  315.       int var10001 = this.offset;
  316.       var2[var10001] >>>= var1;
  317.    }
  318.  
  319.    private final void primitiveLeftShift(int var1) {
  320.       int[] var2 = this.value;
  321.       int var3 = 32 - var1;
  322.       int var4 = this.offset;
  323.       int var5 = var2[var4];
  324.  
  325.       for(int var6 = var4 + this.intLen - 1; var4 < var6; ++var4) {
  326.          int var7 = var5;
  327.          var5 = var2[var4 + 1];
  328.          var2[var4] = var7 << var1 | var5 >>> var3;
  329.       }
  330.  
  331.       int var10001 = this.offset + this.intLen - 1;
  332.       var2[var10001] <<= var1;
  333.    }
  334.  
  335.    void add(MutableBigInteger var1) {
  336.       int var2 = this.intLen;
  337.       int var3 = var1.intLen;
  338.       int var4 = this.intLen > var1.intLen ? this.intLen : var1.intLen;
  339.       int[] var5 = this.value.length < var4 ? new int[var4] : this.value;
  340.       int var6 = var5.length - 1;
  341.  
  342.       long var7;
  343.       for(var7 = 0L; var2 > 0 && var3 > 0; var5[var6--] = (int)var7) {
  344.          --var2;
  345.          --var3;
  346.          var7 = ((long)this.value[var2 + this.offset] & 4294967295L) + ((long)var1.value[var3 + var1.offset] & 4294967295L) + (var7 >>> 32);
  347.       }
  348.  
  349.       while(var2 > 0) {
  350.          --var2;
  351.          var7 = ((long)this.value[var2 + this.offset] & 4294967295L) + (var7 >>> 32);
  352.          var5[var6--] = (int)var7;
  353.       }
  354.  
  355.       while(var3 > 0) {
  356.          --var3;
  357.          var7 = ((long)var1.value[var3 + var1.offset] & 4294967295L) + (var7 >>> 32);
  358.          var5[var6--] = (int)var7;
  359.       }
  360.  
  361.       if (var7 >>> 32 > 0L) {
  362.          ++var4;
  363.          if (var5.length < var4) {
  364.             int[] var9 = new int[var4];
  365.  
  366.             for(int var10 = var4 - 1; var10 > 0; --var10) {
  367.                var9[var10] = var5[var10 - 1];
  368.             }
  369.  
  370.             var9[0] = 1;
  371.             var5 = var9;
  372.          } else {
  373.             var5[var6--] = 1;
  374.          }
  375.       }
  376.  
  377.       this.value = var5;
  378.       this.intLen = var4;
  379.       this.offset = var5.length - var4;
  380.    }
  381.  
  382.    int subtract(MutableBigInteger var1) {
  383.       MutableBigInteger var2 = this;
  384.       int[] var3 = this.value;
  385.       int var4 = this.compare(var1);
  386.       if (var4 == 0) {
  387.          this.reset();
  388.          return 0;
  389.       } else {
  390.          if (var4 < 0) {
  391.             var2 = var1;
  392.             var1 = this;
  393.          }
  394.  
  395.          int var5 = var2.intLen;
  396.          if (var3.length < var5) {
  397.             var3 = new int[var5];
  398.          }
  399.  
  400.          long var6 = 0L;
  401.          int var8 = var2.intLen;
  402.          int var9 = var1.intLen;
  403.  
  404.          int var10;
  405.          for(var10 = var3.length - 1; var9 > 0; var3[var10--] = (int)var6) {
  406.             --var8;
  407.             --var9;
  408.             var6 = ((long)var2.value[var8 + var2.offset] & 4294967295L) - ((long)var1.value[var9 + var1.offset] & 4294967295L) - (long)((int)(-(var6 >> 32)));
  409.          }
  410.  
  411.          while(var8 > 0) {
  412.             --var8;
  413.             var6 = ((long)var2.value[var8 + var2.offset] & 4294967295L) - (long)((int)(-(var6 >> 32)));
  414.             var3[var10--] = (int)var6;
  415.          }
  416.  
  417.          this.value = var3;
  418.          this.intLen = var5;
  419.          this.offset = this.value.length - var5;
  420.          this.normalize();
  421.          return var4;
  422.       }
  423.    }
  424.  
  425.    private int difference(MutableBigInteger var1) {
  426.       MutableBigInteger var2 = this;
  427.       int var3 = this.compare(var1);
  428.       if (var3 == 0) {
  429.          return 0;
  430.       } else {
  431.          if (var3 < 0) {
  432.             var2 = var1;
  433.             var1 = this;
  434.          }
  435.  
  436.          long var4 = 0L;
  437.          int var6 = var2.intLen;
  438.  
  439.          for(int var7 = var1.intLen; var7 > 0; var2.value[var2.offset + var6] = (int)var4) {
  440.             --var6;
  441.             --var7;
  442.             var4 = ((long)var2.value[var2.offset + var6] & 4294967295L) - ((long)var1.value[var1.offset + var7] & 4294967295L) - (long)((int)(-(var4 >> 32)));
  443.          }
  444.  
  445.          while(var6 > 0) {
  446.             --var6;
  447.             var4 = ((long)var2.value[var2.offset + var6] & 4294967295L) - (long)((int)(-(var4 >> 32)));
  448.             var2.value[var2.offset + var6] = (int)var4;
  449.          }
  450.  
  451.          var2.normalize();
  452.          return var3;
  453.       }
  454.    }
  455.  
  456.    void multiply(MutableBigInteger var1, MutableBigInteger var2) {
  457.       int var3 = this.intLen;
  458.       int var4 = var1.intLen;
  459.       int var5 = var3 + var4;
  460.       if (var2.value.length < var5) {
  461.          var2.value = new int[var5];
  462.       }
  463.  
  464.       var2.offset = 0;
  465.       var2.intLen = var5;
  466.       long var6 = 0L;
  467.       int var8 = var4 - 1;
  468.  
  469.       for(int var9 = var4 + var3 - 1; var8 >= 0; --var9) {
  470.          long var10 = ((long)var1.value[var8 + var1.offset] & 4294967295L) * ((long)this.value[var3 - 1 + this.offset] & 4294967295L) + var6;
  471.          var2.value[var9] = (int)var10;
  472.          var6 = var10 >>> 32;
  473.          --var8;
  474.       }
  475.  
  476.       var2.value[var3 - 1] = (int)var6;
  477.  
  478.       for(int var14 = var3 - 2; var14 >= 0; --var14) {
  479.          var6 = 0L;
  480.          int var15 = var4 - 1;
  481.  
  482.          for(int var16 = var4 + var14; var15 >= 0; --var16) {
  483.             long var11 = ((long)var1.value[var15 + var1.offset] & 4294967295L) * ((long)this.value[var14 + this.offset] & 4294967295L) + ((long)var2.value[var16] & 4294967295L) + var6;
  484.             var2.value[var16] = (int)var11;
  485.             var6 = var11 >>> 32;
  486.             --var15;
  487.          }
  488.  
  489.          var2.value[var14] = (int)var6;
  490.       }
  491.  
  492.       var2.normalize();
  493.    }
  494.  
  495.    void mul(int var1, MutableBigInteger var2) {
  496.       if (var1 == 1) {
  497.          var2.copyValue(this);
  498.       } else if (var1 == 0) {
  499.          var2.clear();
  500.       } else {
  501.          long var3 = (long)var1 & 4294967295L;
  502.          int[] var5 = var2.value.length < this.intLen + 1 ? new int[this.intLen + 1] : var2.value;
  503.          long var6 = 0L;
  504.  
  505.          for(int var8 = this.intLen - 1; var8 >= 0; --var8) {
  506.             long var9 = var3 * ((long)this.value[var8 + this.offset] & 4294967295L) + var6;
  507.             var5[var8 + 1] = (int)var9;
  508.             var6 = var9 >>> 32;
  509.          }
  510.  
  511.          if (var6 == 0L) {
  512.             var2.offset = 1;
  513.             var2.intLen = this.intLen;
  514.          } else {
  515.             var2.offset = 0;
  516.             var2.intLen = this.intLen + 1;
  517.             var5[0] = (int)var6;
  518.          }
  519.  
  520.          var2.value = var5;
  521.       }
  522.    }
  523.  
  524.    void divideOneWord(int var1, MutableBigInteger var2) {
  525.       long var3 = (long)var1 & 4294967295L;
  526.       if (this.intLen == 1) {
  527.          long var13 = (long)this.value[this.offset] & 4294967295L;
  528.          var2.value[0] = (int)(var13 / var3);
  529.          var2.intLen = var2.value[0] == 0 ? 0 : 1;
  530.          var2.offset = 0;
  531.          this.value[0] = (int)(var13 - (long)var2.value[0] * var3);
  532.          this.offset = 0;
  533.          this.intLen = this.value[0] == 0 ? 0 : 1;
  534.       } else {
  535.          if (var2.value.length < this.intLen) {
  536.             var2.value = new int[this.intLen];
  537.          }
  538.  
  539.          var2.offset = 0;
  540.          var2.intLen = this.intLen;
  541.          int var5 = 32 - BigInteger.bitLen(var1);
  542.          int var6 = this.value[this.offset];
  543.          long var7 = (long)var6 & 4294967295L;
  544.          if (var7 < var3) {
  545.             var2.value[0] = 0;
  546.          } else {
  547.             var2.value[0] = (int)(var7 / var3);
  548.             var6 = (int)(var7 - (long)var2.value[0] * var3);
  549.             var7 = (long)var6 & 4294967295L;
  550.          }
  551.  
  552.          int var9 = this.intLen;
  553.          int[] var10 = new int[2];
  554.  
  555.          while(true) {
  556.             --var9;
  557.             if (var9 <= 0) {
  558.                if (var5 > 0) {
  559.                   this.value[0] = var6 % var1;
  560.                } else {
  561.                   this.value[0] = var6;
  562.                }
  563.  
  564.                this.intLen = this.value[0] == 0 ? 0 : 1;
  565.                var2.normalize();
  566.                return;
  567.             }
  568.  
  569.             long var11 = var7 << 32 | (long)this.value[this.offset + this.intLen - var9] & 4294967295L;
  570.             if (var11 >= 0L) {
  571.                var10[0] = (int)(var11 / var3);
  572.                var10[1] = (int)(var11 - (long)var10[0] * var3);
  573.             } else {
  574.                this.divWord(var10, var11, var1);
  575.             }
  576.  
  577.             var2.value[this.intLen - var9] = var10[0];
  578.             var6 = var10[1];
  579.             var7 = (long)var6 & 4294967295L;
  580.          }
  581.       }
  582.    }
  583.  
  584.    void divide(MutableBigInteger var1, MutableBigInteger var2, MutableBigInteger var3) {
  585.       if (var1.intLen == 0) {
  586.          throw new ArithmeticException("BigInteger divide by zero");
  587.       } else if (this.intLen == 0) {
  588.          var2.intLen = var2.offset = var3.intLen = var3.offset = 0;
  589.       } else {
  590.          int var4 = this.compare(var1);
  591.          if (var4 < 0) {
  592.             var2.intLen = var2.offset = 0;
  593.             var3.copyValue(this);
  594.          } else if (var4 == 0) {
  595.             var2.value[0] = var2.intLen = 1;
  596.             var2.offset = var3.intLen = var3.offset = 0;
  597.          } else {
  598.             var2.clear();
  599.             if (var1.intLen == 1) {
  600.                var3.copyValue(this);
  601.                var3.divideOneWord(var1.value[var1.offset], var2);
  602.             } else {
  603.                int[] var5 = new int[var1.intLen];
  604.  
  605.                for(int var6 = 0; var6 < var1.intLen; ++var6) {
  606.                   var5[var6] = var1.value[var1.offset + var6];
  607.                }
  608.  
  609.                int var29 = var1.intLen;
  610.                if (var3.value.length < this.intLen + 1) {
  611.                   var3.value = new int[this.intLen + 1];
  612.                }
  613.  
  614.                for(int var7 = 0; var7 < this.intLen; ++var7) {
  615.                   var3.value[var7 + 1] = this.value[var7 + this.offset];
  616.                }
  617.  
  618.                var3.intLen = this.intLen;
  619.                var3.offset = 1;
  620.                int var30 = var3.intLen;
  621.                int var8 = var30 - var29 + 1;
  622.                if (var2.value.length < var8) {
  623.                   var2.value = new int[var8];
  624.                   var2.offset = 0;
  625.                }
  626.  
  627.                var2.intLen = var8;
  628.                int[] var9 = var2.value;
  629.                int var10 = 32 - BigInteger.bitLen(var5[0]);
  630.                if (var10 > 0) {
  631.                   BigInteger.primitiveLeftShift(var5, var29, var10);
  632.                   var3.leftShift(var10);
  633.                }
  634.  
  635.                if (var3.intLen == var30) {
  636.                   var3.offset = 0;
  637.                   var3.value[0] = 0;
  638.                   ++var3.intLen;
  639.                }
  640.  
  641.                int var11 = var5[0];
  642.                long var12 = (long)var11 & 4294967295L;
  643.                int var14 = var5[1];
  644.                int[] var15 = new int[2];
  645.  
  646.                for(int var16 = 0; var16 < var8; ++var16) {
  647.                   int var17 = 0;
  648.                   int var18 = 0;
  649.                   boolean var19 = false;
  650.                   int var20 = var3.value[var16 + var3.offset];
  651.                   int var21 = var20 + Integer.MIN_VALUE;
  652.                   int var22 = var3.value[var16 + 1 + var3.offset];
  653.                   if (var20 == var11) {
  654.                      var17 = -1;
  655.                      var18 = var20 + var22;
  656.                      var19 = var18 + Integer.MIN_VALUE < var21;
  657.                   } else {
  658.                      long var23 = (long)var20 << 32 | (long)var22 & 4294967295L;
  659.                      if (var23 >= 0L) {
  660.                         var17 = (int)(var23 / var12);
  661.                         var18 = (int)(var23 - (long)var17 * var12);
  662.                      } else {
  663.                         this.divWord(var15, var23, var11);
  664.                         var17 = var15[0];
  665.                         var18 = var15[1];
  666.                      }
  667.                   }
  668.  
  669.                   if (var17 != 0) {
  670.                      if (!var19) {
  671.                         long var34 = (long)var3.value[var16 + 2 + var3.offset] & 4294967295L;
  672.                         long var25 = ((long)var18 & 4294967295L) << 32 | var34;
  673.                         long var27 = ((long)var14 & 4294967295L) * ((long)var17 & 4294967295L);
  674.                         if (this.unsignedLongCompare(var27, var25)) {
  675.                            --var17;
  676.                            var18 = (int)(((long)var18 & 4294967295L) + var12);
  677.                            if (((long)var18 & 4294967295L) >= var12) {
  678.                               var27 = ((long)var14 & 4294967295L) * ((long)var17 & 4294967295L);
  679.                               var25 = ((long)var18 & 4294967295L) << 32 | var34;
  680.                               if (this.unsignedLongCompare(var27, var25)) {
  681.                                  --var17;
  682.                               }
  683.                            }
  684.                         }
  685.                      }
  686.  
  687.                      var3.value[var16 + var3.offset] = 0;
  688.                      int var35 = this.mulsub(var3.value, var5, var17, var29, var16 + var3.offset);
  689.                      if (var35 + Integer.MIN_VALUE > var21) {
  690.                         this.divadd(var5, var3.value, var16 + 1 + var3.offset);
  691.                         --var17;
  692.                      }
  693.  
  694.                      var9[var16] = var17;
  695.                   }
  696.                }
  697.  
  698.                if (var10 > 0) {
  699.                   var3.rightShift(var10);
  700.                }
  701.  
  702.                var3.normalize();
  703.                var2.normalize();
  704.             }
  705.          }
  706.       }
  707.    }
  708.  
  709.    private boolean unsignedLongCompare(long var1, long var3) {
  710.       return var1 + Long.MIN_VALUE > var3 + Long.MIN_VALUE;
  711.    }
  712.  
  713.    private void divWord(int[] var1, long var2, int var4) {
  714.       long var5 = (long)var4 & 4294967295L;
  715.       if (var5 == 1L) {
  716.          var1[0] = (int)var2;
  717.          var1[1] = 0;
  718.       } else {
  719.          long var7 = (var2 >>> 1) / (var5 >>> 1);
  720.  
  721.          long var9;
  722.          for(var9 = var2 - var7 * var5; var9 < 0L; --var7) {
  723.             var9 += var5;
  724.          }
  725.  
  726.          while(var9 >= var5) {
  727.             var9 -= var5;
  728.             ++var7;
  729.          }
  730.  
  731.          var1[0] = (int)var7;
  732.          var1[1] = (int)var9;
  733.       }
  734.    }
  735.  
  736.    MutableBigInteger hybridGCD(MutableBigInteger var1) {
  737.       MutableBigInteger var2 = this;
  738.       MutableBigInteger var3 = new MutableBigInteger();
  739.  
  740.       MutableBigInteger var5;
  741.       for(MutableBigInteger var4 = new MutableBigInteger(); var1.intLen != 0; var4 = var5) {
  742.          if (Math.abs(var2.intLen - var1.intLen) < 2) {
  743.             return var2.binaryGCD(var1);
  744.          }
  745.  
  746.          var2.divide(var1, var3, var4);
  747.          var5 = var2;
  748.          var2 = var1;
  749.          var1 = var4;
  750.       }
  751.  
  752.       return var2;
  753.    }
  754.  
  755.    private MutableBigInteger binaryGCD(MutableBigInteger var1) {
  756.       MutableBigInteger var2 = this;
  757.       MutableBigInteger var3 = new MutableBigInteger();
  758.       int var4 = this.getLowestSetBit();
  759.       int var5 = var1.getLowestSetBit();
  760.       int var6 = var4 < var5 ? var4 : var5;
  761.       if (var6 != 0) {
  762.          this.rightShift(var6);
  763.          var1.rightShift(var6);
  764.       }
  765.  
  766.       boolean var7 = var6 == var4;
  767.       MutableBigInteger var8 = var7 ? var1 : this;
  768.  
  769.       int var10;
  770.       for(int var9 = var7 ? -1 : 1; (var10 = var8.getLowestSetBit()) >= 0; var8 = var9 >= 0 ? var2 : var1) {
  771.          var8.rightShift(var10);
  772.          if (var9 > 0) {
  773.             var2 = var8;
  774.          } else {
  775.             var1 = var8;
  776.          }
  777.  
  778.          if (var2.intLen < 2 && var1.intLen < 2) {
  779.             int var11 = var2.value[var2.offset];
  780.             int var12 = var1.value[var1.offset];
  781.             var11 = binaryGcd(var11, var12);
  782.             var3.value[0] = var11;
  783.             var3.intLen = 1;
  784.             var3.offset = 0;
  785.             if (var6 > 0) {
  786.                var3.leftShift(var6);
  787.             }
  788.  
  789.             return var3;
  790.          }
  791.  
  792.          if ((var9 = var2.difference(var1)) == 0) {
  793.             break;
  794.          }
  795.       }
  796.  
  797.       if (var6 > 0) {
  798.          var2.leftShift(var6);
  799.       }
  800.  
  801.       return var2;
  802.    }
  803.  
  804.    static int binaryGcd(int var0, int var1) {
  805.       if (var1 == 0) {
  806.          return var0;
  807.       } else if (var0 == 0) {
  808.          return var1;
  809.       } else {
  810.          int var2;
  811.          int var3;
  812.          for(var3 = 0; (var2 = var0 & 255) == 0; var3 += 8) {
  813.             var0 >>>= 8;
  814.          }
  815.  
  816.          byte var4 = BigInteger.trailingZeroTable[var2];
  817.          var3 += var4;
  818.          var0 >>>= var4;
  819.  
  820.          int var5;
  821.          for(var5 = 0; (var2 = var1 & 255) == 0; var5 += 8) {
  822.             var1 >>>= 8;
  823.          }
  824.  
  825.          var4 = BigInteger.trailingZeroTable[var2];
  826.          var5 += var4;
  827.          var1 >>>= var4;
  828.          int var6 = var3 < var5 ? var3 : var5;
  829.  
  830.          while(var0 != var1) {
  831.             if (var0 + Integer.MIN_VALUE > var1 + Integer.MIN_VALUE) {
  832.                for(var0 -= var1; (var2 = var0 & 255) == 0; var0 >>>= 8) {
  833.                }
  834.  
  835.                var0 >>>= BigInteger.trailingZeroTable[var2];
  836.             } else {
  837.                for(var1 -= var0; (var2 = var1 & 255) == 0; var1 >>>= 8) {
  838.                }
  839.  
  840.                var1 >>>= BigInteger.trailingZeroTable[var2];
  841.             }
  842.          }
  843.  
  844.          return var0 << var6;
  845.       }
  846.    }
  847.  
  848.    MutableBigInteger mutableModInverse(MutableBigInteger var1) {
  849.       if (var1.isOdd()) {
  850.          return this.modInverse(var1);
  851.       } else if (this.isEven()) {
  852.          throw new ArithmeticException("BigInteger not invertible.");
  853.       } else {
  854.          int var2 = var1.getLowestSetBit();
  855.          MutableBigInteger var3 = new MutableBigInteger(var1);
  856.          var3.rightShift(var2);
  857.          if (var3.isOne()) {
  858.             return this.modInverseMP2(var2);
  859.          } else {
  860.             MutableBigInteger var4 = this.modInverse(var3);
  861.             MutableBigInteger var5 = this.modInverseMP2(var2);
  862.             MutableBigInteger var6 = modInverseBP2(var3, var2);
  863.             MutableBigInteger var7 = var3.modInverseMP2(var2);
  864.             MutableBigInteger var8 = new MutableBigInteger();
  865.             MutableBigInteger var9 = new MutableBigInteger();
  866.             MutableBigInteger var10 = new MutableBigInteger();
  867.             var4.leftShift(var2);
  868.             var4.multiply(var6, var10);
  869.             var5.multiply(var3, var8);
  870.             var8.multiply(var7, var9);
  871.             var10.add(var9);
  872.             var10.divide(var1, var8, var9);
  873.             return var9;
  874.          }
  875.       }
  876.    }
  877.  
  878.    MutableBigInteger modInverseMP2(int var1) {
  879.       if (this.isEven()) {
  880.          throw new ArithmeticException("Non-invertible. (GCD != 1)");
  881.       } else if (var1 > 64) {
  882.          return this.euclidModInverse(var1);
  883.       } else {
  884.          int var2 = inverseMod32(this.value[this.offset + this.intLen - 1]);
  885.          if (var1 < 33) {
  886.             var2 = var1 == 32 ? var2 : var2 & (1 << var1) - 1;
  887.             return new MutableBigInteger(var2);
  888.          } else {
  889.             long var3 = (long)this.value[this.offset + this.intLen - 1] & 4294967295L;
  890.             if (this.intLen > 1) {
  891.                var3 |= (long)this.value[this.offset + this.intLen - 2] << 32;
  892.             }
  893.  
  894.             long var5 = (long)var2 & 4294967295L;
  895.             var5 *= 2L - var3 * var5;
  896.             var5 = var1 == 64 ? var5 : var5 & (1L << var1) - 1L;
  897.             MutableBigInteger var7 = new MutableBigInteger(new int[2]);
  898.             var7.value[0] = (int)(var5 >>> 32);
  899.             var7.value[1] = (int)var5;
  900.             var7.intLen = 2;
  901.             var7.normalize();
  902.             return var7;
  903.          }
  904.       }
  905.    }
  906.  
  907.    static int inverseMod32(int var0) {
  908.       int var1 = var0 * (2 - var0 * var0);
  909.       var1 *= 2 - var0 * var1;
  910.       var1 *= 2 - var0 * var1;
  911.       var1 *= 2 - var0 * var1;
  912.       return var1;
  913.    }
  914.  
  915.    static MutableBigInteger modInverseBP2(MutableBigInteger var0, int var1) {
  916.       return fixup(new MutableBigInteger(1), new MutableBigInteger(var0), var1);
  917.    }
  918.  
  919.    private MutableBigInteger modInverse(MutableBigInteger var1) {
  920.       MutableBigInteger var2 = new MutableBigInteger(var1);
  921.       MutableBigInteger var3 = new MutableBigInteger(this);
  922.       MutableBigInteger var4 = new MutableBigInteger(var2);
  923.       SignedMutableBigInteger var5 = new SignedMutableBigInteger(1);
  924.       SignedMutableBigInteger var6 = new SignedMutableBigInteger();
  925.       Object var7 = null;
  926.       Object var8 = null;
  927.       int var9 = 0;
  928.       if (var3.isEven()) {
  929.          int var10 = var3.getLowestSetBit();
  930.          var3.rightShift(var10);
  931.          var6.leftShift(var10);
  932.          var9 = var10;
  933.       }
  934.  
  935.       while(!var3.isOne()) {
  936.          if (var3.isZero()) {
  937.             throw new ArithmeticException("BigInteger not invertible.");
  938.          }
  939.  
  940.          if (var3.compare(var4) < 0) {
  941.             MutableBigInteger var11 = var3;
  942.             var3 = var4;
  943.             var4 = var11;
  944.             SignedMutableBigInteger var12 = var6;
  945.             var6 = var5;
  946.             var5 = var12;
  947.          }
  948.  
  949.          if (((var3.value[var3.offset + var3.intLen - 1] ^ var4.value[var4.offset + var4.intLen - 1]) & 3) == 0) {
  950.             var3.subtract(var4);
  951.             var5.signedSubtract(var6);
  952.          } else {
  953.             var3.add(var4);
  954.             var5.signedAdd(var6);
  955.          }
  956.  
  957.          int var13 = var3.getLowestSetBit();
  958.          var3.rightShift(var13);
  959.          var6.leftShift(var13);
  960.          var9 += var13;
  961.       }
  962.  
  963.       while(var5.sign < 0) {
  964.          var5.signedAdd(var2);
  965.       }
  966.  
  967.       return fixup(var5, var2, var9);
  968.    }
  969.  
  970.    static MutableBigInteger fixup(MutableBigInteger var0, MutableBigInteger var1, int var2) {
  971.       MutableBigInteger var3 = new MutableBigInteger();
  972.       int var4 = -inverseMod32(var1.value[var1.offset + var1.intLen - 1]);
  973.       int var5 = 0;
  974.  
  975.       for(int var6 = var2 >> 5; var5 < var6; ++var5) {
  976.          int var7 = var4 * var0.value[var0.offset + var0.intLen - 1];
  977.          var1.mul(var7, var3);
  978.          var0.add(var3);
  979.          --var0.intLen;
  980.       }
  981.  
  982.       var5 = var2 & 31;
  983.       if (var5 != 0) {
  984.          int var9 = var4 * var0.value[var0.offset + var0.intLen - 1];
  985.          var9 &= (1 << var5) - 1;
  986.          var1.mul(var9, var3);
  987.          var0.add(var3);
  988.          var0.rightShift(var5);
  989.       }
  990.  
  991.       while(var0.compare(var1) >= 0) {
  992.          var0.subtract(var1);
  993.       }
  994.  
  995.       return var0;
  996.    }
  997.  
  998.    MutableBigInteger euclidModInverse(int var1) {
  999.       MutableBigInteger var2 = new MutableBigInteger(1);
  1000.       var2.leftShift(var1);
  1001.       MutableBigInteger var3 = new MutableBigInteger(var2);
  1002.       MutableBigInteger var4 = new MutableBigInteger(this);
  1003.       MutableBigInteger var5 = new MutableBigInteger();
  1004.       MutableBigInteger var6 = new MutableBigInteger();
  1005.       var2.divide(var4, var5, var6);
  1006.       MutableBigInteger var7 = var2;
  1007.       var2 = var6;
  1008.       var6 = var7;
  1009.       MutableBigInteger var8 = new MutableBigInteger(var5);
  1010.       MutableBigInteger var9 = new MutableBigInteger(1);
  1011.       MutableBigInteger var10 = new MutableBigInteger();
  1012.  
  1013.       while(!var2.isOne()) {
  1014.          var4.divide(var2, var5, var6);
  1015.          if (var6.intLen == 0) {
  1016.             throw new ArithmeticException("BigInteger not invertible.");
  1017.          }
  1018.  
  1019.          var7 = var6;
  1020.          var6 = var4;
  1021.          var4 = var7;
  1022.          if (var5.intLen == 1) {
  1023.             var8.mul(var5.value[var5.offset], var10);
  1024.          } else {
  1025.             var5.multiply(var8, var10);
  1026.          }
  1027.  
  1028.          var7 = var5;
  1029.          var5 = var10;
  1030.          var10 = var7;
  1031.          var9.add(var5);
  1032.          if (var4.isOne()) {
  1033.             return var9;
  1034.          }
  1035.  
  1036.          var2.divide(var4, var5, var6);
  1037.          if (var6.intLen == 0) {
  1038.             throw new ArithmeticException("BigInteger not invertible.");
  1039.          }
  1040.  
  1041.          var7 = var2;
  1042.          var2 = var6;
  1043.          var6 = var7;
  1044.          if (var5.intLen == 1) {
  1045.             var9.mul(var5.value[var5.offset], var10);
  1046.          } else {
  1047.             var5.multiply(var9, var10);
  1048.          }
  1049.  
  1050.          var7 = var5;
  1051.          var5 = var10;
  1052.          var10 = var7;
  1053.          var8.add(var5);
  1054.       }
  1055.  
  1056.       var3.subtract(var8);
  1057.       return var3;
  1058.    }
  1059. }
  1060.