docs: static boolean digitGen(DiyFp low,
                       DiyFp w,
                       DiyFp high,
                       FastDtoaBuilder buffer,
                       int mk) {
          assert(low.e() == w.e() && w.e() == high.e());
          assert uint64_lte(low.f() + 1, high.f() - 1);
          assert(minimal_target_exponent <= w.e() && w.e() <= maximal_target_exponent);
          // low, w and high are imprecise, but by less than one ulp (unit in the last
          // place).
          // If we remove (resp. add) 1 ulp from low (resp. high) we are certain that
          // the new numbers are outside of the interval we want the final
          // representation to lie in.
          // Inversely adding (resp. removing) 1 ulp from low (resp. high) would yield
          // numbers that are certain to lie in the interval. We will use this fact
          // later on.
          // We will now start by generating the digits within the uncertain
          // interval. Later we will weed out representations that lie outside the safe
          // interval and thus _might_ lie outside the correct interval.
          long unit = 1;
          DiyFp too_low = new DiyFp(low.f() - unit, low.e());
          DiyFp too_high = new DiyFp(high.f() + unit, high.e());
          // too_low and too_high are guaranteed to lie outside the interval we want the
          // generated number in.
          DiyFp unsafe_interval = DiyFp.minus(too_high, too_low);
          // We now cut the input number into two parts: the integral digits and the
          // fractionals. We will not write any decimal separator though, but adapt
          // kappa instead.
          // Reminder: we are currently computing the digits (stored inside the buffer)
          // such that:   too_low < buffer * 10^kappa < too_high
          // We use too_high for the digit_generation and stop as soon as possible.
          // If we stop early we effectively round down.
          DiyFp one = new DiyFp(1L << -w.e(), w.e());
          // Division by one is a shift.
          int integrals = (int)((too_high.f() >>> -one.e()) & 0xffffffffL);
          // Modulo by one is an and.
          long fractionals = too_high.f() & (one.f() - 1);
          long result = biggestPowerTen(integrals, DiyFp.kSignificandSize - (-one.e()));
          int divider = (int) ((result >>> 32) & 0xffffffffL);
          int divider_exponent = (int) (result & 0xffffffffL);
          int kappa = divider_exponent + 1;
          // Loop invariant: buffer = too_high / 10^kappa  (integer division)
          // The invariant holds for the first iteration: kappa has been initialized
          // with the divider exponent + 1. And the divider is the biggest power of ten
          // that is smaller than integrals.
          while (kappa > 0) {
              int digit = integrals / divider;
              buffer.append((char) ('0' + digit));
              integrals %= divider;
              kappa--;
              // Note that kappa now equals the exponent of the divider and that the
              // invariant thus holds again.
              long rest =
                      ((long)integrals << -one.e()) + fractionals;
              // Invariant: too_high = buffer * 10^kappa + DiyFp(rest, one.e())
              // Reminder: unsafe_interval.e() == one.e()
              if (rest < unsafe_interval.f()) {
                  // Rounding down (by not emitting the remaining digits) yields a number
                  // that lies within the unsafe interval.
                  buffer.point = buffer.end - mk + kappa;
                  return roundWeed(buffer, DiyFp.minus(too_high, w).f(),
                          unsafe_interval.f(), rest,
                          (long)divider << -one.e(), unit);
              }
              divider /= 10;
          }
  
          // The integrals have been generated. We are at the point of the decimal
          // separator. In the following loop we simply multiply the remaining digits by
          // 10 and divide by one. We just need to pay attention to multiply associated
          // data (like the interval or 'unit'), too.
          // Instead of multiplying by 10 we multiply by 5 (cheaper operation) and
          // increase its (imaginary) exponent. At the same time we decrease the
          // divider's (one's) exponent and shift its significand.
          // Basically, if fractionals was a DiyFp (with fractionals.e == one.e):
          //      fractionals.f *= 10;
          //      fractionals.f >>= 1; fractionals.e++; // value remains unchanged.
          //      one.f >>= 1; one.e++;                 // value remains unchanged.
          //      and we have again fractionals.e == one.e which allows us to divide
          //           fractionals.f() by one.f()
          // We simply combine the *= 10 and the >>= 1.
          while (true) {
              fractionals *= 5;
              unit *= 5;
              unsafe_interval.setF(unsafe_interval.f() * 5);
              unsafe_interval.setE(unsafe_interval.e() + 1);  // Will be optimized out.
              one.setF(one.f() >>> 1);
              one.setE(one.e() + 1);
              // Integer division by one.
              int digit = (int)((fractionals >>> -one.e()) & 0xffffffffL);
              buffer.append((char) ('0' + digit));
              fractionals &= one.f() - 1;  // Modulo by one.
              kappa--;
              if (fractionals < unsafe_interval.f()) {
                  buffer.point = buffer.end - mk + kappa;
                  return roundWeed(buffer, DiyFp.minus(too_high, w).f() * unit,
                          unsafe_interval.f(), fractionals, one.f(), unit);
              }
          }
      }