private static boolean fastSingleWordDivision(
      int leftSignum, long leftFast0, long leftFast1, long leftFast2, int leftScale,
      int rightSignum, long rightFast0, int rightScale,
      FastHiveDecimal fastResult) {

    long remainderSubexpr2 =
        doSingleWordQuotient(
            leftFast0, leftFast1, leftFast2,
            rightFast0,
            fastResult);

    long quotient0 = fastResult.fast0;
    long quotient1 = fastResult.fast1;
    long quotient2 = fastResult.fast2;

    int quotientDigitCount;
    if (quotient2 != 0) {
      quotientDigitCount = fastLongWordPrecision(quotient2);
    } else if (quotient1 != 0) {
      quotientDigitCount = fastLongWordPrecision(quotient1);
    } else {
      quotientDigitCount = fastLongWordPrecision(quotient0);
    }

    int remainderDigitCount =
        doSingleWordRemainder(
            leftFast0, leftFast1, leftFast2,
            rightFast0,
            remainderSubexpr2,
            fastResult);

    long remainder0 = fastResult.fast0;
    long remainder1 = fastResult.fast1;
    long remainder2 = fastResult.fast2;

    fastResult.fast0 = quotient0;
    fastResult.fast1 = quotient1;
    fastResult.fast2 = quotient2;

    final int quotientScale = leftScale + rightScale;

    if (remainderDigitCount == 0) {
      fastResult.fastScale = quotientScale;
    } else {
      int resultScale = quotientScale + remainderDigitCount;

      int adjustedQuotientDigitCount;
      if (quotientScale > 0) {
        adjustedQuotientDigitCount = Math.max(0, quotientDigitCount - quotientScale);
      } else {
        adjustedQuotientDigitCount = quotientDigitCount;
      }
      final int maxScale = HiveDecimal.MAX_SCALE - adjustedQuotientDigitCount;

      int scale = Math.min(resultScale, maxScale);

      int remainderScale;
      remainderScale = Math.min(remainderDigitCount, maxScale - quotientScale);
      if (remainderScale > 0) {
        if (quotientDigitCount > 0) {
          // Make room for remainder.
          fastScaleUp(
              fastResult,
              remainderScale,
              fastResult);
        }
        // Copy in remainder digits... which start at the top of remainder2.
        if (remainderScale < LONGWORD_DECIMAL_DIGITS) {
          final long remainderDivisor2 = powerOfTenTable[LONGWORD_DECIMAL_DIGITS - remainderScale];
          fastResult.fast0 += (remainder2 / remainderDivisor2);
        } else if (remainderScale == LONGWORD_DECIMAL_DIGITS) {
          fastResult.fast0 = remainder2;
        } else if (remainderScale < TWO_X_LONGWORD_DECIMAL_DIGITS) {
          final long remainderDivisor2 = powerOfTenTable[remainderScale - LONGWORD_DECIMAL_DIGITS];
          fastResult.fast1 += (remainder2 / remainderDivisor2);
          fastResult.fast0 = remainder1;
        } else if (remainderScale == TWO_X_LONGWORD_DECIMAL_DIGITS) {
          fastResult.fast1 = remainder2;
          fastResult.fast0 = remainder1;
        }
      }

      // UNDONE: Method is still under development.
      fastResult.fastScale = scale;

      // UNDONE: Trim trailing zeroes...
    }

    return true;
  }
*********************************************************************************************
  // Decimal Division / Remainder.

  /**
EXPERMIMENTAL: Division when divisor fits in a single decimal longword.

@return  remainderSubexpr2
storage-api/src/java/org/apache/hadoop/hive/common/type/FastHiveDecimalImpl.java