internal fun parseCookie(
  currentTimeMillis: Long,
  url: HttpUrl,
  setCookie: String,
): Cookie? = Cookie.parse(currentTimeMillis, url, setCookie)

internal fun cookieToString(
  cookie: Cookie,
  forObsoleteRfc2965: Boolean,
): String = cookie.toString(forObsoleteRfc2965)

internal fun addHeaderLenient(
  builder: Headers.Builder,
  line: String,
): Headers.Builder = builder.addLenient(line)

internal fun addHeaderLenient(

     * Not exactly sure what that is all about, certainly legacy stuff
     *
     * @return resolveHashes
     */
    boolean isResolveHashes();

    /**
     * Check if this referral needs to be resolved further
     *
     * @return whether this refrral needs to be resolved further
     */
    boolean isIntermediate();

    /**
     * Combine this referral with another to form a chain
     *

        }
    }

    private final SSPContext mechContext;

    private boolean firstResponse = true;
    private boolean completed;

    private ASN1ObjectIdentifier[] mechs;
    private ASN1ObjectIdentifier selectedMech;
    private ASN1ObjectIdentifier[] remoteMechs;

    private final boolean disableMic;
    private boolean requireMic;

    /**

 * javadoc for details.
 */
@GwtCompatible
abstract class CommonMatcher {
  public abstract boolean matches();

  public abstract boolean find();

  public abstract boolean find(int index);

  public abstract String replaceAll(String replacement);

  public abstract int end();

  public abstract int start();

            this.signingPreferred = Boolean.parseBoolean(value);
        }

        value = props.getProperty("jcifs.smb.client.signingEnforced");
        if (value != null) {
            this.signingEnforced = Boolean.parseBoolean(value);
        }

        value = props.getProperty("jcifs.smb.client.encryptionEnforced");
        if (value != null) {
            this.encryptionEnabled = Boolean.parseBoolean(value);
        }

        }

        @Override
        public boolean removeAll(Collection<?> c) {
          return removeEntriesIf(Maps.<K>keyPredicateOnEntries(in(c)));
        }

        @Override
        public boolean retainAll(Collection<?> c) {
          return removeEntriesIf(Maps.<K>keyPredicateOnEntries(not(in(c))));
        }

        @Override
        public boolean remove(@Nullable Object o) {

        Cut<C> fromKey, boolean fromInclusive, Cut<C> toKey, boolean toInclusive) {
      return subMap(
          Range.range(
              fromKey, BoundType.forBoolean(fromInclusive),
              toKey, BoundType.forBoolean(toInclusive)));
    }

    @Override
    public NavigableMap<Cut<C>, Range<C>> headMap(Cut<C> toKey, boolean inclusive) {

    ArtifactMetadata md;

    // indications to use these in comparison
    private boolean compareVersion = false;
    private boolean compareScope = false;

    public MetadataGraphVertex(ArtifactMetadata md) {
        super();
        this.md = md;
    }

    public MetadataGraphVertex(ArtifactMetadata md, boolean compareVersion, boolean compareScope) {
        this(md);
        this.compareVersion = compareVersion;

        }

        File temp = new File(destination + ".tmp");

        temp.deleteOnExit();

        boolean downloaded = false;

        try {
            connectWagon(wagon, repository);

            boolean firstRun = true;
            boolean retry = true;

            // this will run at most twice. The first time, the firstRun flag is turned off, and if the retry flag

   */
  @GuardedBy("lock")
  private int runningTasks = 0;

  @GuardedBy("lock")
  private boolean shutdown = false;

  @Override
  public void execute(Runnable command) {
    startTask();
    try {
      command.run();
    } finally {
      endTask();
    }
  }

  @Override
  public boolean isShutdown() {
    synchronized (lock) {
      return shutdown;
    }
  }

  @Override