home *** CD-ROM | disk | FTP | other *** search
/ S283 Planetary Science &n…he Search for Life DVD 2 / DVD-ROM.iso / install / jre1_3 / lib / rt.jar / java / math / MutableBigInteger.class (.txt) < prev    next >
Encoding:
Java Class File  |  1979-12-31  |  9.5 KB  |  1,061 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) + ((var13 & 4294967295L) > ((long)(~((int)var11)) & 4294967295L) ? 1L : 0L);
  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 var16 = var3 - 2; var16 >= 0; --var16) {
  479.          var6 = 0L;
  480.          int var11 = var4 - 1;
  481.  
  482.          for(int var12 = var4 + var16; var11 >= 0; --var12) {
  483.             long var13 = ((long)var1.value[var11 + var1.offset] & 4294967295L) * ((long)this.value[var16 + this.offset] & 4294967295L) + ((long)var2.value[var12] & 4294967295L) + var6;
  484.             var2.value[var12] = (int)var13;
  485.             var6 = var13 >>> 32;
  486.             --var11;
  487.          }
  488.  
  489.          var2.value[var16] = (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 var7 = var1.intLen;
  610.                if (var3.value.length < this.intLen + 1) {
  611.                   var3.value = new int[this.intLen + 1];
  612.                }
  613.  
  614.                for(int var8 = 0; var8 < this.intLen; ++var8) {
  615.                   var3.value[var8 + 1] = this.value[var8 + this.offset];
  616.                }
  617.  
  618.                var3.intLen = this.intLen;
  619.                var3.offset = 1;
  620.                int var9 = var3.intLen;
  621.                int var10 = var9 - var7 + 1;
  622.                if (var2.value.length < var10) {
  623.                   var2.value = new int[var10];
  624.                   var2.offset = 0;
  625.                }
  626.  
  627.                var2.intLen = var10;
  628.                int[] var11 = var2.value;
  629.                int var12 = 32 - BigInteger.bitLen(var5[0]);
  630.                if (var12 > 0) {
  631.                   BigInteger.primitiveLeftShift(var5, var7, var12);
  632.                   var3.leftShift(var12);
  633.                }
  634.  
  635.                if (var3.intLen == var9) {
  636.                   var3.offset = 0;
  637.                   var3.value[0] = 0;
  638.                   ++var3.intLen;
  639.                }
  640.  
  641.                int var13 = var5[0];
  642.                long var14 = (long)var13 & 4294967295L;
  643.                int var16 = var5[1];
  644.                int[] var17 = new int[2];
  645.  
  646.                for(int var18 = 0; var18 < var10; ++var18) {
  647.                   int var19 = 0;
  648.                   int var20 = 0;
  649.                   boolean var21 = false;
  650.                   int var22 = var3.value[var18 + var3.offset];
  651.                   int var23 = var22 + Integer.MIN_VALUE;
  652.                   int var24 = var3.value[var18 + 1 + var3.offset];
  653.                   if (var22 == var13) {
  654.                      var19 = -1;
  655.                      var20 = var22 + var24;
  656.                      var21 = var20 + Integer.MIN_VALUE < var23;
  657.                   } else {
  658.                      long var25 = (long)var22 << 32 | (long)var24 & 4294967295L;
  659.                      if (var25 >= 0L) {
  660.                         var19 = (int)(var25 / var14);
  661.                         var20 = (int)(var25 - (long)var19 * var14);
  662.                      } else {
  663.                         this.divWord(var17, var25, var13);
  664.                         var19 = var17[0];
  665.                         var20 = var17[1];
  666.                      }
  667.                   }
  668.  
  669.                   if (var19 != 0) {
  670.                      if (!var21) {
  671.                         long var34 = (long)var3.value[var18 + 2 + var3.offset] & 4294967295L;
  672.                         long var27 = ((long)var20 & 4294967295L) << 32 | var34;
  673.                         long var29 = ((long)var16 & 4294967295L) * ((long)var19 & 4294967295L);
  674.                         if (this.unsignedLongCompare(var29, var27)) {
  675.                            --var19;
  676.                            var20 = (int)(((long)var20 & 4294967295L) + var14);
  677.                            if (((long)var20 & 4294967295L) >= var14) {
  678.                               var29 = ((long)var16 & 4294967295L) * ((long)var19 & 4294967295L);
  679.                               var27 = ((long)var20 & 4294967295L) << 32 | var34;
  680.                               if (this.unsignedLongCompare(var29, var27)) {
  681.                                  --var19;
  682.                               }
  683.                            }
  684.                         }
  685.                      }
  686.  
  687.                      var3.value[var18 + var3.offset] = 0;
  688.                      int var35 = this.mulsub(var3.value, var5, var19, var7, var18 + var3.offset);
  689.                      if (var35 + Integer.MIN_VALUE > var23) {
  690.                         this.divadd(var5, var3.value, var18 + 1 + var3.offset);
  691.                         --var19;
  692.                      }
  693.  
  694.                      var11[var18] = var19;
  695.                   }
  696.                }
  697.  
  698.                if (var12 > 0) {
  699.                   var3.rightShift(var12);
  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.       new MutableBigInteger();
  758.       MutableBigInteger var4 = new MutableBigInteger();
  759.       int var5 = this.getLowestSetBit();
  760.       int var6 = var1.getLowestSetBit();
  761.       int var7 = var5 < var6 ? var5 : var6;
  762.       if (var7 != 0) {
  763.          this.rightShift(var7);
  764.          var1.rightShift(var7);
  765.       }
  766.  
  767.       boolean var8 = var7 == var5;
  768.       MutableBigInteger var9 = var8 ? var1 : this;
  769.  
  770.       int var11;
  771.       for(int var10 = var8 ? -1 : 1; (var11 = var9.getLowestSetBit()) >= 0; var9 = var10 >= 0 ? var2 : var1) {
  772.          var9.rightShift(var11);
  773.          if (var10 > 0) {
  774.             var2 = var9;
  775.          } else {
  776.             var1 = var9;
  777.          }
  778.  
  779.          if (var2.intLen < 2 && var1.intLen < 2) {
  780.             int var12 = var2.value[var2.offset];
  781.             int var13 = var1.value[var1.offset];
  782.             var12 = binaryGcd(var12, var13);
  783.             var4.value[0] = var12;
  784.             var4.intLen = 1;
  785.             var4.offset = 0;
  786.             if (var7 > 0) {
  787.                var4.leftShift(var7);
  788.             }
  789.  
  790.             return var4;
  791.          }
  792.  
  793.          if ((var10 = var2.difference(var1)) == 0) {
  794.             break;
  795.          }
  796.       }
  797.  
  798.       if (var7 > 0) {
  799.          var2.leftShift(var7);
  800.       }
  801.  
  802.       return var2;
  803.    }
  804.  
  805.    static int binaryGcd(int var0, int var1) {
  806.       if (var1 == 0) {
  807.          return var0;
  808.       } else if (var0 == 0) {
  809.          return var1;
  810.       } else {
  811.          int var2;
  812.          int var3;
  813.          for(var3 = 0; (var2 = var0 & 255) == 0; var3 += 8) {
  814.             var0 >>>= 8;
  815.          }
  816.  
  817.          byte var4 = BigInteger.trailingZeroTable[var2];
  818.          var3 += var4;
  819.          var0 >>>= var4;
  820.  
  821.          int var5;
  822.          for(var5 = 0; (var2 = var1 & 255) == 0; var5 += 8) {
  823.             var1 >>>= 8;
  824.          }
  825.  
  826.          var4 = BigInteger.trailingZeroTable[var2];
  827.          var5 += var4;
  828.          var1 >>>= var4;
  829.          int var6 = var3 < var5 ? var3 : var5;
  830.  
  831.          while(var0 != var1) {
  832.             if (var0 + Integer.MIN_VALUE > var1 + Integer.MIN_VALUE) {
  833.                for(var0 -= var1; (var2 = var0 & 255) == 0; var0 >>>= 8) {
  834.                }
  835.  
  836.                var0 >>>= BigInteger.trailingZeroTable[var2];
  837.             } else {
  838.                for(var1 -= var0; (var2 = var1 & 255) == 0; var1 >>>= 8) {
  839.                }
  840.  
  841.                var1 >>>= BigInteger.trailingZeroTable[var2];
  842.             }
  843.          }
  844.  
  845.          return var0 << var6;
  846.       }
  847.    }
  848.  
  849.    MutableBigInteger mutableModInverse(MutableBigInteger var1) {
  850.       if (var1.isOdd()) {
  851.          return this.modInverse(var1);
  852.       } else if (this.isEven()) {
  853.          throw new ArithmeticException("BigInteger not invertible.");
  854.       } else {
  855.          int var2 = var1.getLowestSetBit();
  856.          MutableBigInteger var3 = new MutableBigInteger(var1);
  857.          var3.rightShift(var2);
  858.          if (var3.isOne()) {
  859.             return this.modInverseMP2(var2);
  860.          } else {
  861.             MutableBigInteger var4 = this.modInverse(var3);
  862.             MutableBigInteger var5 = this.modInverseMP2(var2);
  863.             MutableBigInteger var6 = modInverseBP2(var3, var2);
  864.             MutableBigInteger var7 = var3.modInverseMP2(var2);
  865.             MutableBigInteger var8 = new MutableBigInteger();
  866.             MutableBigInteger var9 = new MutableBigInteger();
  867.             MutableBigInteger var10 = new MutableBigInteger();
  868.             var4.leftShift(var2);
  869.             var4.multiply(var6, var10);
  870.             var5.multiply(var3, var8);
  871.             var8.multiply(var7, var9);
  872.             var10.add(var9);
  873.             var10.divide(var1, var8, var9);
  874.             return var9;
  875.          }
  876.       }
  877.    }
  878.  
  879.    MutableBigInteger modInverseMP2(int var1) {
  880.       if (this.isEven()) {
  881.          throw new ArithmeticException("Non-invertible. (GCD != 1)");
  882.       } else if (var1 > 64) {
  883.          return this.euclidModInverse(var1);
  884.       } else {
  885.          int var2 = inverseMod32(this.value[this.offset + this.intLen - 1]);
  886.          if (var1 < 33) {
  887.             var2 = var1 == 32 ? var2 : var2 & (1 << var1) - 1;
  888.             return new MutableBigInteger(var2);
  889.          } else {
  890.             long var3 = (long)this.value[this.offset + this.intLen - 1] & 4294967295L;
  891.             if (this.intLen > 1) {
  892.                var3 |= (long)this.value[this.offset + this.intLen - 2] << 32;
  893.             }
  894.  
  895.             long var5 = (long)var2 & 4294967295L;
  896.             var5 *= 2L - var3 * var5;
  897.             var5 = var1 == 64 ? var5 : var5 & (1L << var1) - 1L;
  898.             MutableBigInteger var7 = new MutableBigInteger(new int[2]);
  899.             var7.value[0] = (int)(var5 >>> 32);
  900.             var7.value[1] = (int)var5;
  901.             var7.intLen = 2;
  902.             var7.normalize();
  903.             return var7;
  904.          }
  905.       }
  906.    }
  907.  
  908.    static int inverseMod32(int var0) {
  909.       int var1 = var0 * (2 - var0 * var0);
  910.       var1 *= 2 - var0 * var1;
  911.       var1 *= 2 - var0 * var1;
  912.       var1 *= 2 - var0 * var1;
  913.       return var1;
  914.    }
  915.  
  916.    static MutableBigInteger modInverseBP2(MutableBigInteger var0, int var1) {
  917.       return fixup(new MutableBigInteger(1), new MutableBigInteger(var0), var1);
  918.    }
  919.  
  920.    private MutableBigInteger modInverse(MutableBigInteger var1) {
  921.       MutableBigInteger var2 = new MutableBigInteger(var1);
  922.       MutableBigInteger var3 = new MutableBigInteger(this);
  923.       MutableBigInteger var4 = new MutableBigInteger(var2);
  924.       SignedMutableBigInteger var5 = new SignedMutableBigInteger(1);
  925.       SignedMutableBigInteger var6 = new SignedMutableBigInteger();
  926.       Object var7 = null;
  927.       Object var8 = null;
  928.       int var9 = 0;
  929.       if (var3.isEven()) {
  930.          int var10 = var3.getLowestSetBit();
  931.          var3.rightShift(var10);
  932.          ((MutableBigInteger)var6).leftShift(var10);
  933.          var9 = var10;
  934.       }
  935.  
  936.       while(!var3.isOne()) {
  937.          if (var3.isZero()) {
  938.             throw new ArithmeticException("BigInteger not invertible.");
  939.          }
  940.  
  941.          if (var3.compare(var4) < 0) {
  942.             MutableBigInteger var11 = var3;
  943.             var3 = var4;
  944.             var4 = var11;
  945.             SignedMutableBigInteger var12 = var6;
  946.             var6 = var5;
  947.             var5 = var12;
  948.          }
  949.  
  950.          if (((var3.value[var3.offset + var3.intLen - 1] ^ var4.value[var4.offset + var4.intLen - 1]) & 3) == 0) {
  951.             var3.subtract(var4);
  952.             var5.signedSubtract(var6);
  953.          } else {
  954.             var3.add(var4);
  955.             var5.signedAdd(var6);
  956.          }
  957.  
  958.          int var13 = var3.getLowestSetBit();
  959.          var3.rightShift(var13);
  960.          ((MutableBigInteger)var6).leftShift(var13);
  961.          var9 += var13;
  962.       }
  963.  
  964.       while(var5.sign < 0) {
  965.          var5.signedAdd(var2);
  966.       }
  967.  
  968.       return fixup(var5, var2, var9);
  969.    }
  970.  
  971.    static MutableBigInteger fixup(MutableBigInteger var0, MutableBigInteger var1, int var2) {
  972.       MutableBigInteger var3 = new MutableBigInteger();
  973.       int var4 = -inverseMod32(var1.value[var1.offset + var1.intLen - 1]);
  974.       int var5 = 0;
  975.  
  976.       for(int var6 = var2 >> 5; var5 < var6; ++var5) {
  977.          int var7 = var4 * var0.value[var0.offset + var0.intLen - 1];
  978.          var1.mul(var7, var3);
  979.          var0.add(var3);
  980.          --var0.intLen;
  981.       }
  982.  
  983.       int var9 = var2 & 31;
  984.       if (var9 != 0) {
  985.          int var8 = var4 * var0.value[var0.offset + var0.intLen - 1];
  986.          var8 &= (1 << var9) - 1;
  987.          var1.mul(var8, var3);
  988.          var0.add(var3);
  989.          var0.rightShift(var9);
  990.       }
  991.  
  992.       while(var0.compare(var1) >= 0) {
  993.          var0.subtract(var1);
  994.       }
  995.  
  996.       return var0;
  997.    }
  998.  
  999.    MutableBigInteger euclidModInverse(int var1) {
  1000.       MutableBigInteger var2 = new MutableBigInteger(1);
  1001.       var2.leftShift(var1);
  1002.       MutableBigInteger var3 = new MutableBigInteger(var2);
  1003.       MutableBigInteger var4 = new MutableBigInteger(this);
  1004.       MutableBigInteger var5 = new MutableBigInteger();
  1005.       MutableBigInteger var6 = new MutableBigInteger();
  1006.       var2.divide(var4, var5, var6);
  1007.       MutableBigInteger var7 = var2;
  1008.       var2 = var6;
  1009.       var6 = var7;
  1010.       MutableBigInteger var8 = new MutableBigInteger(var5);
  1011.       MutableBigInteger var9 = new MutableBigInteger(1);
  1012.       MutableBigInteger var10 = new MutableBigInteger();
  1013.  
  1014.       while(!var2.isOne()) {
  1015.          var4.divide(var2, var5, var6);
  1016.          if (var6.intLen == 0) {
  1017.             throw new ArithmeticException("BigInteger not invertible.");
  1018.          }
  1019.  
  1020.          var7 = var6;
  1021.          var6 = var4;
  1022.          var4 = var7;
  1023.          if (var5.intLen == 1) {
  1024.             var8.mul(var5.value[var5.offset], var10);
  1025.          } else {
  1026.             var5.multiply(var8, var10);
  1027.          }
  1028.  
  1029.          var7 = var5;
  1030.          var5 = var10;
  1031.          var10 = var7;
  1032.          var9.add(var5);
  1033.          if (var4.isOne()) {
  1034.             return var9;
  1035.          }
  1036.  
  1037.          var2.divide(var4, var5, var6);
  1038.          if (var6.intLen == 0) {
  1039.             throw new ArithmeticException("BigInteger not invertible.");
  1040.          }
  1041.  
  1042.          var7 = var2;
  1043.          var2 = var6;
  1044.          var6 = var7;
  1045.          if (var5.intLen == 1) {
  1046.             var9.mul(var5.value[var5.offset], var10);
  1047.          } else {
  1048.             var5.multiply(var9, var10);
  1049.          }
  1050.  
  1051.          var7 = var5;
  1052.          var5 = var10;
  1053.          var10 = var7;
  1054.          var8.add(var5);
  1055.       }
  1056.  
  1057.       var3.subtract(var8);
  1058.       return var3;
  1059.    }
  1060. }
  1061.