assertFalse(multimap().containsEntry(k0(), v0()));
  }

  @CollectionSize.Require(absent = ZERO)
  @MapFeature.Require(SUPPORTS_REMOVE)
  /*
   * We are comparing Multimaps of the same type, so as long as they have value collections that
   * implement equals() (as with ListMultimap or SetMultimap, as opposed to a QueueMultimap or
   * something), our equality check is value-based.
   */

import static com.google.common.math.MathPreconditions.checkRoundingUnnecessary;

import com.google.common.annotations.GwtIncompatible;
import java.math.RoundingMode;

/**
 * Helper type to implement rounding {@code X} to a representable {@code double} value according to
 * a {@link RoundingMode}.
 */
@GwtIncompatible
abstract class ToDoubleRounder<X extends Number & Comparable<X>> {
  /**

    int NT_STATUS_PIPE_BROKEN = 0xC000014b;
    /** The specified local group does not exist */
    int NT_STATUS_NO_SUCH_ALIAS = 0xC0000151;
    /** The user has not been granted the requested logon type at this computer */
    int NT_STATUS_LOGON_TYPE_NOT_GRANTED = 0xC000015b;
    /** The SAM database does not have a computer account for this workstation trust relationship */
    int NT_STATUS_NO_TRUST_SAM_ACCOUNT = 0xC000018b;

    /**
     * Time encoding type: 1970 epoch, 32-bit seconds, big-endian.
     */
    public static final int TIME_1970_SEC_32BE = 1;

    /**
     * Time encoding type: 1970 epoch, 32-bit seconds, little-endian.
     */
    public static final int TIME_1970_SEC_32LE = 2;

    /**
     * Time encoding type: 1904 epoch, 32-bit seconds, big-endian.
     */

    return getInet4Address(Arrays.copyOfRange(ip.getAddress(), 12, 16));
  }

  /**
   * Examines the Inet6Address to determine if it is an IPv6 address of one of the specified address
   * types that contain an embedded IPv4 address.
   *
   * <p>NOTE: ISATAP addresses are explicitly excluded from this method due to their trivial

// Return pointer to testOneByteReadEOF{}
func newTestReaderEOF(data []byte) io.Reader {
	return &testOneByteReadEOF{false, data}
}

// OneByteReadEOF - implements io.Reader which returns 1 byte along with io.EOF error.
type testOneByteReadEOF struct {
	eof  bool
	data []byte
}

func (r *testOneByteReadEOF) Read(p []byte) (n int, err error) {
	if r.eof {
		return 0, io.EOF
	}
	n = copy(p, r.data)
	r.eof = true

                                </div>
                            </div>
                            <div class="card-footer">
                                <button type="submit" class="btn btn-primary" name="download"
                                        value="<la:message key="labels.dict_kuromoji_button_download" />">
                                    <em class="fa fa-download">

  }

  @Override
  public Iterator<E> iterator() {
    if (iterator == null) {
      // TODO: throw something else? Do we worry that people's code and tests
      // might be relying on this particular type of exception?
      throw new IllegalStateException();
    }
    try {
      return iterator;
    } finally {
      iterator = null;
    }
  }

        for (int i = 0; i < getNumEntries(); i++) {
            results[i] = e = new SmbShareInfo();
            e.netName = readString(buffer, bufferIndex, 13, false);
            bufferIndex += 14;
            e.type = SMBUtil.readInt2(buffer, bufferIndex);
            bufferIndex += 2;
            int off = SMBUtil.readInt4(buffer, bufferIndex);
            bufferIndex += 4;
            off = (off & 0xFFFF) - this.converter;

```json
{
    "detail": [
        {
            "type": "extra_forbidden",
            "loc": ["cookie", "santa_tracker"],
            "msg": "Extra inputs are not permitted",
            "input": "good-list-please",
        }
    ]
}
```

## Підсумок