"01",
	}, {
		"complete HCLenTree, complete HLitTree, degenerate HDistTree, use valid HDist symbol",
		"000100feff000de0010400000000100000000000000000000000000000000000" +
			"0000000000000000000000000000003c",
		"00000000",
	}, {
		"complete HCLenTree, degenerate HLitTree, degenerate HDistTree",
		"05e0010400000000100000000000000000000000000000000000000000000000" +
			"0000000000000000000c",
		"",
	}, {

	a := Z8u1{false, [8]byte{255, 255, 255, 255, 255, 255, 255, 255}}
	zero8u1_ssa(&a)
	want := Z8u1{false, [8]byte{0, 0, 0, 0, 0, 0, 0, 0}}
	if a != want {
		t.Errorf("zero8u2 got=%v, want %v\n", a, want)
	}
	b := Z8u2{15, [8]byte{255, 255, 255, 255, 255, 255, 255, 255}}
	zero8u2_ssa(&b)
	wantb := Z8u2{15, [8]byte{0, 0, 0, 0, 0, 0, 0, 0}}
	if b != wantb {
		t.Errorf("zero8u2 got=%v, want %v\n", b, wantb)
	}
}

00000020  92 33 b6 3e 56 2b c2 f7  29 e3 f9 20 8c d7 b6 90  |.3.>V+..).. ....|
00000030  03 f5 8b 55 e9 81 47 5b  84 ec 19 bc 32 58 c6 30  |...U..G[....2X.0|
00000040  f1 79 ea 51 a2 18 cc c0  4e 8a 8e cb 00 05 00 00  |.y.Q....N.......|
00000050  09 ff 01 00 01 00 00 17  00 00 16 03 02 02 59 0b  |..............Y.|
00000060  00 02 55 00 02 52 00 02  4f 30 82 02 4b 30 82 01  |..U..R..O0..K0..|

		in[i] = byte(i + 30)
	}

	out := []byte(Dump(in[:]))
	if !bytes.Equal(out, expectedHexDump) {
		t.Errorf("got:\n%s\nwant:\n%s", out, expectedHexDump)
	}
}

var expectedHexDump = []byte(`00000000  1e 1f 20 21 22 23 24 25  26 27 28 29 2a 2b 2c 2d  |.. !"#$%&'()*+,-|
00000010  2e 2f 30 31 32 33 34 35  36 37 38 39 3a 3b 3c 3d  |./0123456789:;<=|
00000020  3e 3f 40 41 42 43 44 45                           |>?@ABCDE|
`)

00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
00000020  00 00 00 44 4f 57 4e 47  52 44 01 00 00 2f 00 00  |...DOWNGRD.../..|
00000030  0d 00 23 00 00 ff 01 00  01 00 00 17 00 00 16 03  |..#.............|
00000040  03 02 59 0b 00 02 55 00  02 52 00 02 4f 30 82 02  |..Y...U..R..O0..|
00000050  4b 30 82 01 b4 a0 03 02  01 02 02 09 00 e8 f0 9d  |K0..............|

    assertEquals(
        "1::4:0:0:7:8", InetAddresses.toAddrString(InetAddresses.forString("1:0:0:4:0:0:7:8")));
    assertEquals("::", InetAddresses.toAddrString(InetAddresses.forString("0:0:0:0:0:0:0:0")));
    assertEquals("::1", InetAddresses.toAddrString(InetAddresses.forString("0:0:0:0:0:0:0:1")));
    assertEquals(
        "2001:658:22a:cafe::",

    --snippet-highlight-color: #f7c590;
    /* Border colors for structural elements and user defined tables */
    --border-color: #ededed;
    --table-border-color: #000000;
    /* Search input colors */
    --search-input-background-color: #ffffff;
    --search-input-text-color: #000000;
    --search-input-placeholder-color: #909090;
    /* Highlight color for active search tag target */
    --search-tag-highlight-color: #ffff00;

000001d0  a0 d6 9d da ae b2 eb 76  64 02 82 58 d4 bc 5a 44  |.......vd..X..ZD|
000001e0  b9 5a f5 33 57 fa a6 9c  d5 05 84 9a 19 0b 65 37  |.Z.3W.........e7|
000001f0  bc 05 16 03 03 00 04 0e  00 00 00                 |...........|
>>> Flow 3 (client to server)
00000000  16 03 03 00 25 10 00 00  21 20 95 58 05 04 03 27  |....%...! .X...'|
00000010  5e 14 d4 41 5a 3b eb d3  13 ad d4 16 fb 43 bf d6  |^..AZ;.......C..|

	"strconv"
	"strings"
)

// zeros is a slice of eight stringified zeros. It's used in
// parseIPSlow to construct slices of specific amounts of zero fields,
// from 1 to 8.
var zeros = []string{"0", "0", "0", "0", "0", "0", "0", "0"}

// parseIPSlow is like ParseIP, but aims for readability above
// speed. It's the reference implementation for correctness checking
// and against which we measure optimized parsers.
//

	output := out.String()

	expectedOutput := `                                  WORKLOAD    TOTAL RPS    ERROR RPS  P50 LATENCY  P90 LATENCY  P99 LATENCY
                                   details        0.040        0.000          2ms          4ms          4ms
`
	if output != expectedOutput {
		t.Fatalf("Unexpected output; got:\n %q\nwant:\n %q", output, expectedOutput)
	}
}