? roundArbitrarily
            : DoubleUtils.nextDown(roundArbitrarily);
      case CEILING:
        return (cmpXToRoundArbitrarily <= 0) ? roundArbitrarily : Math.nextUp(roundArbitrarily);
      case DOWN:
        if (x >= 0) {
          return (cmpXToRoundArbitrarily >= 0)
              ? roundArbitrarily
              : DoubleUtils.nextDown(roundArbitrarily);
        } else {

      for (int direction : new int[] {1, -1}) {
        double d = Double.longBitsToDouble(Double.doubleToLongBits(Math.scalb(1.0, i)) + direction);
        // Math.nextUp/nextDown
        if (d != Math.rint(d)) {
          fractionalBuilder.add(d);
        }
      }
    }
    for (double d :
        Doubles.asList(
            0,
            1,
            2,

      for (int direction : new int[] {1, -1}) {
        double d = Double.longBitsToDouble(Double.doubleToLongBits(Math.scalb(1.0, i)) + direction);
        // Math.nextUp/nextDown
        if (d != Math.rint(d)) {
          fractionalBuilder.add(d);
        }
      }
    }
    for (double d :
        Doubles.asList(
            0,
            1,
            2,

		m.metadata = nil
	}
	r.err = err
	return m, err
}

// next will read one entry from the stream.
// Generally not recommended for fast operation.
func (r *metacacheReader) nextEOF() bool {
	r.checkInit()
	if r.err != nil {
		return r.err == io.EOF
	}
	if r.current.name != "" {
		return false
	}
	_, err := r.peek()
	if err != nil {
		r.err = err

			if !o.InclDeleted && entry.isAllFreeVersions() {
				return true
			}
			entries.o = append(entries.o, entry)
			return entries.len() < o.Limit
		})
		if (err != nil && errors.Is(err, io.EOF)) || pastPrefix || r.nextEOF() {
			return entries, io.EOF
		}
		return entries, err
	}

	// We should not need to filter more.
	return r.readN(o.Limit, o.InclDeleted, o.IncludeDirectories, o.Versioned, o.Prefix)
}