func (ww *wsWriter) writeFrame(w io.Writer, f ws.Frame) error {
	const (
		bit0  = 0x80
		len7  = int64(125)
		len16 = int64(^(uint16(0)))
		len64 = int64(^(uint64(0)) >> 1)
	)

	bts := ww.tmp[:]
	if f.Header.Fin {
		bts[0] |= bit0
	}
	bts[0] |= f.Header.Rsv << 4
	bts[0] |= byte(f.Header.OpCode)

	var n int
	switch {

may be stored using additional precision beyond that of an IEEE 754 32-bit number,
but float32(x) represents the result of rounding <code>x</code>'s value to
32-bit precision. Similarly, <code>x + 0.1</code> may use more than 32 bits
of precision, but <code>float32(x + 0.1)</code> does not.
</li>
</ol>

<p>
In all non-constant conversions involving floating-point or complex values,
if the result type cannot represent the value the conversion

               * where it does *not* contain bitToFlip.
               *
               * The next combination is
               *
               * {0, 1, ..., bitToFlip - firstSetBit - 2, bitToFlip, ...}
               *
               * This is lexicographically next if you look at the combinations in descending order

    /** The key of the message: Unknown version information. */
    public static final String ERRORS_unknown_version_for_upgrade = "{errors.unknown_version_for_upgrade}";

    /** The key of the message: Failed to upgrade from {0}: {1} */
    public static final String ERRORS_failed_to_upgrade_from = "{errors.failed_to_upgrade_from}";

    /** The key of the message: Failed to start reindexing from {0} to {1} */

                }

                int procs = Runtime.getRuntime().availableProcessors();
                int threads = (int) (coreMultiplier * procs);
                return threads == 0 ? 1 : threads;
            } else {
                int threads = Integer.parseInt(threadConfiguration);
                if (threads <= 0) {
                    throw new IllegalArgumentException(

  }

  public void testRemoveIfWithConcurrentRemoval() {
    LocalCache<Integer, Integer> map =
        makeLocalCache(createCacheBuilder().concurrencyLevel(1).initialCapacity(1));
    map.put(0, 1);
    map.put(1, 1);
    map.put(2, 1);
    map.entrySet()
        .removeIf(
            entry -> {
              assertThat(entry.getValue()).isNotNull();

		// Inputs to ListObjects.
		bucketName string
		prefix     string
		delimiter  string
		page       int
		// Expected output of ListObjects.
		result ListObjectsInfo
	}{
		{testBuckets[0], "", "", 1, resultCases[0]},
		{testBuckets[0], "a", "", 1, resultCases[0]},
		{testBuckets[1], "apache", "", 1, resultCases[1]},
		{testBuckets[1], "", "/", 1, resultCases[2]},
	}

	0x0039 00057 (x.go:5)	MOVQ	8(SP), BP
	0x003e 00062 (x.go:5)	ADDQ	$16, SP
	0x0042 00066 (x.go:5)	RET
	0x0043 00067 (x.go:5)	NOP
	0x0043 00067 (x.go:3)	PCDATA	$1, $-1
	0x0043 00067 (x.go:3)	PCDATA	$0, $-1
	0x0043 00067 (x.go:3)	CALL	runtime.morestack_noctxt(SB)
	0x0048 00072 (x.go:3)	JMP	0
...
</pre>

<p>
The <code>FUNCDATA</code> and <code>PCDATA</code> directives contain information

		{getListObjectsV1URL(s.endPoint, bucketName, "", "1000", "url"), []string{"<Key>foo+bar+1</Key>", "<Key>foo+bar+2</Key>", "<Key>foo+%01+bar</Key>"}},
		{
			getListObjectsV2URL(s.endPoint, bucketName, "", "1000", "", "", ""),
			[]string{
				"<Key>foo bar 1</Key>",
				"<Key>foo bar 2</Key>",
				"<Key>foo &#x1; bar</Key>",

### Detailed go Dependency Changes

#### Added
- github.com/OpenPeeDeeP/depguard: v1.0.1
- github.com/StackExchange/wmi: 5d04971
- github.com/agnivade/levenshtein: v1.0.1
- github.com/alecthomas/template: a0175ee
- github.com/alecthomas/units: 2efee85
- github.com/andreyvit/diff: c7f18ee
- github.com/anmitsu/go-shlex: 648efa6