V entryValue = e.getValue();

            if (entryValue != null) {
              // TODO(kak): Remove this branch
            } else if (isCollected(e)) {
              // TODO(kak): Remove this branch
            } else {
              return null;
            }

            ++modCount;
            E newFirst = removeFromChain(first, e);

  public static boolean fuzzyEquals(double a, double b, double tolerance) {
    MathPreconditions.checkNonNegative("tolerance", tolerance);
    return Math.copySign(a - b, 1.0) <= tolerance
        // copySign(x, 1.0) is a branch-free version of abs(x), but with different NaN semantics
        || (a == b) // needed to ensure that infinities equal themselves
        || (Double.isNaN(a) && Double.isNaN(b));
  }

  /**

      KeyList<K, V> keyList = requireNonNull(keyToKeyList.remove(node.getKey()));
      keyList.count = 0;
      modCount++;
    } else {
      // requireNonNull is safe (under the conditions listed in the comment in the branch above).
      KeyList<K, V> keyList = requireNonNull(keyToKeyList.get(node.getKey()));
      keyList.count--;

      if (node.previousSibling == null) {

      KeyList<K, V> keyList = requireNonNull(keyToKeyList.remove(node.getKey()));
      keyList.count = 0;
      modCount++;
    } else {
      // requireNonNull is safe (under the conditions listed in the comment in the branch above).
      KeyList<K, V> keyList = requireNonNull(keyToKeyList.get(node.getKey()));
      keyList.count--;

      if (node.previousSibling == null) {

//
//   - Array: the number of elements in v (same as len(v)).
//   - Pointer to array: the number of elements in *v (same as len(v)).
//   - Slice: the maximum length the slice can reach when resliced;
//     if v is nil, cap(v) is zero.
//   - Channel: the channel buffer capacity, in units of elements;
//     if v is nil, cap(v) is zero.
//

// and from parent directories all the way up to the root of subdir.
// go.mod and go.sum files are needed for the go tool modules queries,
// and the testdata directories for tests.  It is common for tests to
// reach out into testdata from parent packages.
func adbCopyTree(deviceCwd, subdir string) error {
	dir := ""
	for {
		for _, name := range []string{"testdata", "go.mod", "go.sum"} {
			hostPath := filepath.Join(dir, name)

    return x > 0 & (x & (x - 1)) == 0;
  }

  /**
   * Returns 1 if {@code x < y} as unsigned longs, and 0 otherwise. Assumes that x - y fits into a
   * signed long. The implementation is branch-free, and benchmarks suggest it is measurably faster
   * than the straightforward ternary expression.
   */
  @VisibleForTesting
  static int lessThanBranchFree(long x, long y) {

pkg syscall (linux-386), type Flock_t struct, Pid int32
pkg syscall (linux-386), type Flock_t struct, Start int64
pkg syscall (linux-386), type Flock_t struct, Type int16
pkg syscall (linux-386), type Flock_t struct, Whence int16
pkg syscall (linux-386-cgo), func FcntlFlock(uintptr, int, *Flock_t) error
pkg syscall (linux-386-cgo), func SendmsgN(int, []uint8, []uint8, Sockaddr, int) (int, error)
pkg syscall (linux-386-cgo), type Flock_t struct

## Sponsor the author { #sponsor-the-author }

If your **product/company** depends on or is related to **FastAPI** and you want to reach its users, you can sponsor the author (me) through [GitHub sponsors](https://github.com/sponsors/tiangolo). Depending on the tier, you could get some extra benefits, like a badge in the docs. 🎁

---

   *
   * <p>The graph below would be valid input with start nodes of {@code a, f, c}. However, if {@code
   * b} were <i>also</i> a start node, then there would be multiple paths to reach {@code e} and
   * {@code h}.
   *
   * {@snippet :
   *    a     b      c
   *   / \   / \     |
   *  /   \ /   \    |
   * d     e     f   g
   *       |
   *       |
   *       h
   * }