assertThrows(UnsupportedOperationException.class, () -> unmod.merge(4, "four", (k, v) -> v));
    assertThrows(UnsupportedOperationException.class, () -> unmod.clear());

    /* UnsupportedOperationException on indirect modifications. */
    BiMap<String, Number> inverse = unmod.inverse();
    assertThrows(UnsupportedOperationException.class, () -> inverse.put("four", 4));

The assembler works on the semi-abstract form, so
when you see an instruction like <code>MOV</code>
what the toolchain actually generates for that operation might
not be a move instruction at all, perhaps a clear or load.
Or it might correspond exactly to the machine instruction with that name.
In general, machine-specific operations tend to appear as themselves, while more general concepts like

   *
   * @return an iterator over the elements contained in this collection
   */
  @Override
  public Iterator<E> iterator() {
    return new QueueIterator();
  }

  @Override
  public void clear() {
    for (int i = 0; i < size; i++) {
      queue[i] = null;
    }
    size = 0;
  }

  @Override
  @J2ktIncompatible // Incompatible return type change. Use inherited (unoptimized) implementation

      shutdown(connectionCode)
    }

    var streamsToClose: Array<Http2Stream>? = null
    withLock {
      if (streams.isNotEmpty()) {
        streamsToClose = streams.values.toTypedArray()
        streams.clear()
      }
    }

    streamsToClose?.forEach { stream ->
      ignoreIoExceptions {
        stream.close(streamCode, cause)
      }
    }

   *
   * @throws UnsupportedOperationException always
   * @deprecated Unsupported operation.
   */
  @Deprecated
  @Override
  @DoNotCall("Always throws UnsupportedOperationException")
  public final void clear() {
    throw new UnsupportedOperationException();
  }

  /**
   * Returns an immutable collection of the values for the given key. If no mappings in the multimap

				topEntries[i] = entry
				continue
			}
			// We got different entries
			if entry.name > current.name {
				continue
			}
			// We got a new, better current.
			// Clear existing entries.
			for i := range topEntries[:i] {
				topEntries[i] = metaCacheEntry{}
			}
			agree = 1
			current = entry
			topEntries[i] = entry
		}

}
func (sr sparseFileReader) physicalRemaining() int64 {
	return sr.fr.physicalRemaining()
}

type zeroReader struct{}

func (zeroReader) Read(b []byte) (int, error) {
	clear(b)
	return len(b), nil
}

// mustReadFull is like io.ReadFull except it returns
// io.ErrUnexpectedEOF when io.EOF is hit before len(b) bytes are read.
func mustReadFull(r io.Reader, b []byte) (int, error) {

								changed = true
								version.ObjectV2.PartIndices[i] = nil
							}
							clearField = clearField && len(version.ObjectV2.PartIndices[i]) == 0
						}
					}
					if changed {
						// All empty, clear.
						if clearField {
							version.ObjectV2.PartIndices = nil
						}

						// Reindex since it was changed.
						meta, err := version.MarshalMsg(make([]byte, 0, len(ver.meta)+10))
						if err == nil {

labels.index_form_search_btn=Search
labels.index_osdd_title=Search
labels.index_form_option_btn=Options
labels.index_help=Help
labels.search_options=Search Options
labels.search_options_close=Close
labels.search_options_clear=Clear
labels.search_cache_msg=This is a cache of {0}. It is a snapshot of the page as it appeared on {1}.
labels.search_unknown=Unknown
labels.footer_back_to_top=Back to Top
labels.header_brand_name=Fess

                    if (failureMessage.length() > 0) {
                        failureBuf.append(response.buildFailureMessage()).append('\n');
                    }
                }
                bufferedList.clear();
            }
        });
        if (!bufferedList.isEmpty()) {
            final BulkResponse response = doInsertAll(bufferedList, opType);
            if (response.hasFailures()) {