*/
  @CanIgnoreReturnValue
  boolean putAll(Multimap<? extends K, ? extends V> multimap);

  /**
   * Stores a collection of values with the same key, replacing any existing values for that key.
   *
   * <p>If {@code values} is empty, this is equivalent to {@link #removeAll(Object) removeAll(key)}.
   *

    private String authMethod;

    private boolean handshakeComplete;

    private final CIFSContext transportContext;

    /**
     * Creates a new NTLM HTTP URL connection that wraps an existing HTTP connection.
     *
     * @param connection
     *            connection to wrap
     * @param tc
     *            context to use
     */

                if (log.isTraceEnabled()) {
                    log.trace("Reusing existing session " + ssn);
                }
                return ssn.acquire();
            }
            if (log.isTraceEnabled()) {
                log.trace("Existing session " + ssn + " does not match " + tf.getCredentials());
            }
        }

        /* logoff old sessions */

  /**
   * Returns an iterator over the URLs in this cache. This iterator doesn't throw
   * `ConcurrentModificationException`, but if new responses are added while iterating, their URLs
   * will not be returned. If existing responses are evicted during iteration, they will be absent
   * (unless they were already returned).
   *
   * The iterator supports [MutableIterator.remove]. Removing a URL from the iterator evicts the

    List<V> oldValues = getCopy(key);
    ListIterator<V> keyValues = new ValueForKeyIterator(key);
    Iterator<? extends V> newValues = values.iterator();

    // Replace existing values, if any.
    while (keyValues.hasNext() && newValues.hasNext()) {
      keyValues.next();
      keyValues.set(newValues.next());
    }

    // Remove remaining old values, if any.

  /**
   * Equivalent to {@code transitiveClosure(graph, ADD_SELF_LOOPS_ALWAYS)}. Callers should look at
   * the different strategy options that the new method supports rather than simply migrating to the
   * new method with the existing behavior; we believe that most callers will want to use the {@code
   * ADD_SELF_LOOPS_FOR_CYCLES} strategy.
   *
   * @since 33.1.0 (present with return type {@code Graph} since 20.0)

		return errDiskNotFound
	}

	// Marshal and write to disk.
	formatData, err := json.Marshal(format)
	if err != nil {
		return err
	}

	tmpFormat := mustGetUUID()

	// Purge any existing temporary file, okay to ignore errors here.
	defer disk.Delete(context.TODO(), minioMetaBucket, tmpFormat, DeleteOptions{
		Recursive: false,
		Immediate: false,
	})

	// write to unique file.

	return &Writer{cw: &countWriter{w: bufio.NewWriter(w)}}
}

// SetOffset sets the offset of the beginning of the zip data within the
// underlying writer. It should be used when the zip data is appended to an
// existing file, such as a binary executable.
// It must be called before any data is written.
func (w *Writer) SetOffset(n int64) {
	if w.cw.count != 0 {
		panic("zip: SetOffset called after data was written")
	}
	w.cw.count = n

          <executions>
            <!--
            We can apparently have only one <jdk> per execution: Others are silently ignored :(
            To properly test this, you need to remove existing toolchains:
            rm -rf ~/.m2/jdks/ ~/.m2/toolchains.xml
            (But don't run that if you have put something into ~/.m2/toolchains.xml yourself.)
            -->
            <execution>

	Size                  int64
	Duration              time.Duration
	ReplicationAction     replicationAction // full or metadata only
	OpType                replication.Type  // whether incoming replication, existing object, healing etc..
	ReplicationStatus     replication.StatusType
	PrevReplicationStatus replication.StatusType
	VersionPurgeStatus    VersionPurgeStatusType
	ResyncTimestamp       string