use_repo(
    xla_third_party,
    "FP16",
    "FXdiv",
    "XNNPACK",
    "compute_library",
    "cpuinfo",
    "cudnn_frontend_archive",
    "cutlass_archive",
    "dlpack",
    "ducc",
    "eigen_archive",
    "farmhash_archive",
    "farmhash_gpu_archive",
    "gemmlowp",
    "gloo",
    "highwayhash",
    "hwloc",
    "implib_so",
    "llvm-raw",
    "llvm_openmp",

        }
        String dunc = oldUncPath.substring(pathConsumed);
        if (log.isDebugEnabled()) {
            log.debug("Remaining '" + dunc + "'");
        }

        if (dunc.equals("") || dunc.equals("\\")) {
            dunc = "\\";
            this.type = SmbConstants.TYPE_SHARE;
        }
        if (!dr.getPath().isEmpty()) {
            dunc = "\\" + dr.getPath() + dunc;
        }

        // Adding the class hashCode to avoid a clash with Succ instances.
        return Pred.class.hashCode() + node.hashCode();
      }
    }

    static final class Succ<N> extends NodeConnection<N> {
      Succ(N node) {
        super(node);
      }

      @Override
      public boolean equals(@Nullable Object that) {
        if (that instanceof Succ) {
          return this.node.equals(((Succ<?>) that).node);

  }

  private void setSuccessor(int entry, int succ) {
    long succMask = ~0L >>> 32;
    setLink(entry, (link(entry) & ~succMask) | ((succ + 1) & succMask));
  }

  private void setPredecessor(int entry, int pred) {
    long predMask = ~0L << 32;
    setLink(entry, (link(entry) & ~predMask) | ((long) (pred + 1) << 32));
  }

  private void setSucceeds(int pred, int succ) {
    if (pred == ENDPOINT) {

    AvlNode() {
      this.elem = null;
      this.elemCount = 1;
    }

    // For discussion of pred() and succ(), see the comment on the pred and succ fields.

    private AvlNode<E> pred() {
      return requireNonNull(pred);
    }

    private AvlNode<E> succ() {
      return requireNonNull(succ);
    }

    int count(Comparator<? super E> comparator, @ParametricNullness E e) {

    private void succeedsInValueSet(
        @Nullable ValueEntry<K, V> pred, @Nullable ValueEntry<K, V> succ) {
      if (pred == null) {
        firstEntry = succ;
      } else {
        pred.successorInValueSet = succ;
      }
      if (succ == null) {
        lastEntry = pred;
      } else {
        succ.predecessorInValueSet = pred;
      }
    }

    private void succeedsInValueSet(
        @Nullable ValueEntry<K, V> pred, @Nullable ValueEntry<K, V> succ) {
      if (pred == null) {
        firstEntry = succ;
      } else {
        pred.successorInValueSet = succ;
      }
      if (succ == null) {
        lastEntry = pred;
      } else {
        succ.predecessorInValueSet = pred;
      }
    }

        return; // give up if someone is calling complete
      }
      Waiter succ;
      while (curr != null) {
        succ = curr.next;
        if (curr.thread != null) { // we aren't unlinking this node, update pred.
          pred = curr;
        } else if (pred != null) { // We are unlinking this node and it has a predecessor.
          pred.next = succ;

                    }
                    final String dunc = loc.handleDFSReferral(dr, rpath);
                    if (request != null) {
                        request.setPath(dunc);
                    }
                    return loc;
                }

                // fallthrough to normal handling

        when(dr.getPath()).thenReturn("dfs/path");
        when(dr.getPathConsumed()).thenReturn(2); // consume leading \\ from UNC

        String newUnc = l.handleDFSReferral(dr, "\\req\\");
        // dunc is "\\" + path + remaining  - note: path may not have leading backslashes
        assertTrue(newUnc.contains("dfs/path") || newUnc.contains("dfs\\path"));
        assertEquals(dr, l.getDfsReferral());