5159     };
5160 
5161     /*
5162      * returns precision of 128-bit value
5163      */
5164     private static int precision(long hi, long lo){
5165         if(hi==0) {
5166             if(lo>=0) {
5167                 return longDigitLength(lo);
5168             }
5169             return (unsignedLongCompareEq(lo, LONGLONG_TEN_POWERS_TABLE[0][1])) ? 20 : 19;
5170             // 0x8AC7230489E80000L  = unsigned 2^19
5171         }
5172         int r = ((128 - Long.numberOfLeadingZeros(hi) + 1) * 1233) >>> 12;
5173         int idx = r-19;
5174         return (idx >= LONGLONG_TEN_POWERS_TABLE.length || longLongCompareMagnitude(hi, lo,
5175                                                                                     LONGLONG_TEN_POWERS_TABLE[idx][0], LONGLONG_TEN_POWERS_TABLE[idx][1])) ? r : r + 1;
5176     }
5177 
5178     /*
5179      * returns true if 128 bit number <hi0,lo0> is less then <hi1,lo1>
5180      * hi0 & hi1 should be non-negative
5181      */
5182     private static boolean longLongCompareMagnitude(long hi0, long lo0, long hi1, long lo1) {
5183         if(hi0!=hi1) {
5184             return hi0<hi1;
5185         }
5186         return (lo0+Long.MIN_VALUE) <(lo1+Long.MIN_VALUE);
5187     }
5188 
5189     private static BigDecimal divide(long dividend, int dividendScale, long divisor, int divisorScale, int scale, int roundingMode) {
5190         if (checkScale(dividend,(long)scale + divisorScale) > dividendScale) {
5191             int newScale = scale + divisorScale;
5192             int raise = newScale - dividendScale;
5193             if(raise<LONG_TEN_POWERS_TABLE.length) {
5194                 long xs = dividend;
5195                 if ((xs = longMultiplyPowerTen(xs, raise)) != INFLATED) {
5196                     return divideAndRound(xs, divisor, scale, roundingMode, scale);
5197                 }
5198                 BigDecimal q = multiplyDivideAndRound(LONG_TEN_POWERS_TABLE[raise], dividend, divisor, scale, roundingMode, scale);
5199                 if(q!=null) {

5159     };
5160 
5161     /*
5162      * returns precision of 128-bit value
5163      */
5164     private static int precision(long hi, long lo){
5165         if(hi==0) {
5166             if(lo>=0) {
5167                 return longDigitLength(lo);
5168             }
5169             return (unsignedLongCompareEq(lo, LONGLONG_TEN_POWERS_TABLE[0][1])) ? 20 : 19;
5170             // 0x8AC7230489E80000L  = unsigned 2^19
5171         }
5172         int r = ((128 - Long.numberOfLeadingZeros(hi) + 1) * 1233) >>> 12;
5173         int idx = r-19;
5174         return (idx >= LONGLONG_TEN_POWERS_TABLE.length || longLongCompareMagnitude(hi, lo,
5175                                                                                     LONGLONG_TEN_POWERS_TABLE[idx][0], LONGLONG_TEN_POWERS_TABLE[idx][1])) ? r : r + 1;
5176     }
5177 
5178     /*
5179      * returns true if 128 bit number <hi0,lo0> is less than <hi1,lo1>
5180      * hi0 & hi1 should be non-negative
5181      */
5182     private static boolean longLongCompareMagnitude(long hi0, long lo0, long hi1, long lo1) {
5183         if(hi0!=hi1) {
5184             return hi0<hi1;
5185         }
5186         return (lo0+Long.MIN_VALUE) <(lo1+Long.MIN_VALUE);
5187     }
5188 
5189     private static BigDecimal divide(long dividend, int dividendScale, long divisor, int divisorScale, int scale, int roundingMode) {
5190         if (checkScale(dividend,(long)scale + divisorScale) > dividendScale) {
5191             int newScale = scale + divisorScale;
5192             int raise = newScale - dividendScale;
5193             if(raise<LONG_TEN_POWERS_TABLE.length) {
5194                 long xs = dividend;
5195                 if ((xs = longMultiplyPowerTen(xs, raise)) != INFLATED) {
5196                     return divideAndRound(xs, divisor, scale, roundingMode, scale);
5197                 }
5198                 BigDecimal q = multiplyDivideAndRound(LONG_TEN_POWERS_TABLE[raise], dividend, divisor, scale, roundingMode, scale);
5199                 if(q!=null) {