if len(m) == 0 {
		return nil, false
	}

	dirExists := 0
	if cap(r.candidates) < len(m) {
		r.candidates = make([][]xlMetaV2ShallowVersion, 0, len(m))
	}
	r.candidates = r.candidates[:0]
	objsAgree := 0
	objsValid := 0
	for i := range m {
		entry := &m[i]
		// Empty entry
		if entry.name == "" {
			continue
		}

		if entry.isDir() {

          if (!upperBoundWindow.contains(cut)) {
            return null;
          }
          Entry<Cut<C>, Range<C>> candidate = rangesByLowerBound.lowerEntry(cut);
          if (candidate != null && candidate.getValue().upperBound.equals(cut)) {
            return candidate.getValue();
          }
        } catch (ClassCastException e) {
          return null;
        }
      }
      return null;

   * requires us to have a DNS address for both hosts, which only happens after route planning. We
   * can't coalesce connections that use a proxy, since proxies don't tell us the origin server's IP
   * address.
   */
  private fun routeMatchesAny(candidates: List<Route>): Boolean =
    candidates.any {
      it.proxy.type() == Proxy.Type.DIRECT &&

  }

  private final int k;
  private final Comparator<? super T> comparator;

  /*
   * We are currently considering the elements in buffer in the range [0, bufferSize) as candidates
   * for the top k elements. Whenever the buffer is filled, we quickselect the top k elements to the
   * range [0, k) and ignore the remaining elements.
   */
  private final @Nullable T[] buffer;

                    byAscendingSize, startIndex, inputIsSet),
                e);
          }
          /*
           * TODO(cpovirk): Check that the values match one of candidates that
           * MutatedOnQuery*.delegate() actually returned during this test?
           */
          assertWithMessage(
                  "byAscendingSize %s, startIndex %s, inputIsSet %s",

        low = mid;
      } else {
        return mid; // allRequired[mid] = centerFloor, so we can't get closer than that
      }
    }

    // Now pick the closest of the two candidates. Note that there is no rounding here.
    if (from + to - allRequired[low] - allRequired[high] > 0) {
      return high;
    } else {
      return low;
    }
  }

            noNewExchangesEvent = !candidate.noNewExchanges
            candidate.noNewExchanges = true
            connectionUser.releaseConnectionNoEvents()
          }
          candidate.noNewExchanges || !sameHostAndPort(candidate.route().address.url) -> {
            connectionUser.releaseConnectionNoEvents()
          }
          else -> null
        }
      }

			}
		}
	}

	if found {
		// Update candidate FileInfo with succModTime and numVersions in quorum when available
		if props, ok := otherPropsMap.GetValueWithQuorum(quorum); ok {
			candidate.SuccessorModTime = props.succModTime
			candidate.IsLatest = props.succModTime.IsZero()
			candidate.NumVersions = props.numVersions
		}
		return candidate, nil
	}

            }

            if (candidate != null
                && candidate.getKey().isConnected(subRange)
                && candidate.getKey().intersection(subRange).equals(r)) {
              return candidate.getValue();
            }
          }
        } catch (ClassCastException e) {
          return null;
        }
        return null;
      }

      for (long candidate : roundToDoubleTestCandidates) {
        assertThat(LongMath.roundToDouble(candidate, roundingMode))
            .isEqualTo(BigIntegerMath.roundToDouble(BigInteger.valueOf(candidate), roundingMode));
      }
    }
  }

  @GwtIncompatible
  public void testRoundToDoubleAgainstBigIntegerUnnecessary() {
    for (long candidate : roundToDoubleTestCandidates) {