docs: static boolean roundWeed(FastDtoaBuilder buffer,
                               long distance_too_high_w,
                               long unsafe_interval,
                               long rest,
                               long ten_kappa,
                               long unit) {
          long small_distance = distance_too_high_w - unit;
          long big_distance = distance_too_high_w + unit;
          // Let w_low  = too_high - big_distance, and
          //     w_high = too_high - small_distance.
          // Note: w_low < w < w_high
          //
          // The real w (* unit) must lie somewhere inside the interval
          // ]w_low; w_low[ (often written as "(w_low; w_low)")
  
          // Basically the buffer currently contains a number in the unsafe interval
          // ]too_low; too_high[ with too_low < w < too_high
          //
          //  too_high - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
          //                     ^v 1 unit            ^      ^                 ^      ^
          //  boundary_high ---------------------     .      .                 .      .
          //                     ^v 1 unit            .      .                 .      .
          //   - - - - - - - - - - - - - - - - - - -  +  - - + - - - - - -     .      .
          //                                          .      .         ^       .      .
          //                                          .  big_distance  .       .      .
          //                                          .      .         .       .    rest
          //                              small_distance     .         .       .      .
          //                                          v      .         .       .      .
          //  w_high - - - - - - - - - - - - - - - - - -     .         .       .      .
          //                     ^v 1 unit                   .         .       .      .
          //  w ----------------------------------------     .         .       .      .
          //                     ^v 1 unit                   v         .       .      .
          //  w_low  - - - - - - - - - - - - - - - - - - - - -         .       .      .
          //                                                           .       .      v
          //  buffer --------------------------------------------------+-------+--------
          //                                                           .       .
          //                                                  safe_interval    .
          //                                                           v       .
          //   - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -     .
          //                     ^v 1 unit                                     .
          //  boundary_low -------------------------                     unsafe_interval
          //                     ^v 1 unit                                     v
          //  too_low  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
          //
          //
          // Note that the value of buffer could lie anywhere inside the range too_low
          // to too_high.
          //
          // boundary_low, boundary_high and w are approximations of the real boundaries
          // and v (the input number). They are guaranteed to be precise up to one unit.
          // In fact the error is guaranteed to be strictly less than one unit.
          //
          // Anything that lies outside the unsafe interval is guaranteed not to round
          // to v when read again.
          // Anything that lies inside the safe interval is guaranteed to round to v
          // when read again.
          // If the number inside the buffer lies inside the unsafe interval but not
          // inside the safe interval then we simply do not know and bail out (returning
          // false).
          //
          // Similarly we have to take into account the imprecision of 'w' when rounding
          // the buffer. If we have two potential representations we need to make sure
          // that the chosen one is closer to w_low and w_high since v can be anywhere
          // between them.
          //
          // By generating the digits of too_high we got the largest (closest to
          // too_high) buffer that is still in the unsafe interval. In the case where
          // w_high < buffer < too_high we try to decrement the buffer.
          // This way the buffer approaches (rounds towards) w.
          // There are 3 conditions that stop the decrementation process:
          //   1) the buffer is already below w_high
          //   2) decrementing the buffer would make it leave the unsafe interval
          //   3) decrementing the buffer would yield a number below w_high and farther
          //      away than the current number. In other words:
          //              (buffer{-1} < w_high) && w_high - buffer{-1} > buffer - w_high
          // Instead of using the buffer directly we use its distance to too_high.
          // Conceptually rest ~= too_high - buffer
          while (rest < small_distance &&  // Negated condition 1
                  unsafe_interval - rest >= ten_kappa &&  // Negated condition 2
                  (rest + ten_kappa < small_distance ||  // buffer{-1} > w_high
                          small_distance - rest >= rest + ten_kappa - small_distance)) {
              buffer.decreaseLast();
              rest += ten_kappa;
          }
  
          // We have approached w+ as much as possible. We now test if approaching w-
          // would require changing the buffer. If yes, then we have two possible
          // representations close to w, but we cannot decide which one is closer.
          if (rest < big_distance &&
                  unsafe_interval - rest >= ten_kappa &&
                  (rest + ten_kappa < big_distance ||
                          big_distance - rest > rest + ten_kappa - big_distance)) {
              return false;
          }
  
          // Weeding test.
          //   The safe interval is [too_low + 2 ulp; too_high - 2 ulp]
          //   Since too_low = too_high - unsafe_interval this is equivalent to
          //      [too_high - unsafe_interval + 4 ulp; too_high - 2 ulp]
          //   Conceptually we have: rest ~= too_high - buffer
          return (2 * unit <= rest) && (rest <= unsafe_interval - 4 * unit);
      }