});
```

Running this race over home WiFi shows the Times (`0002`) completes just slightly sooner than the Post (`0001`):

```
0001 https://www.washingtonpost.com/
0001 0.000 callStart
0002 https://www.nytimes.com/
0002 0.000 callStart
0002 0.010 dnsStart
0001 0.013 dnsStart
0001 0.022 dnsEnd
0002 0.019 dnsEnd
0001 0.028 connectStart
0002 0.025 connectStart
0002 0.072 secureConnectStart

		{"06 k=v\n", "06 k=v\n", "", "", false},
		{"00006 k=v\n", "00006 k=v\n", "", "", false},
		{"000006 k=v\n", "000006 k=v\n", "", "", false},
		{"000000 k=v\n", "000000 k=v\n", "", "", false},
		{"0 k=v\n", "0 k=v\n", "", "", false},
		{"+0000005 x=\n", "+0000005 x=\n", "", "", false},
	}

	for _, v := range vectors {
		key, val, res, err := parsePAXRecord(v.in)
		ok := (err == nil)
		if ok != v.ok {

	MOVV	R1, R2		// 00011025
	MOVV	LO, R1		// 00000812
	MOVV	HI, R1		// 00000810
	MOVV	R1, LO		// 00200013
	MOVV	R1, HI		// 00200011


//	LMOVW rreg ',' rreg
//	{
//		outcode(int($1), &$2, 0, &$4);
//	}
	MOVW	R1, R2		// 00011004
	MOVW	LO, R1		// 00000812
	MOVW	HI, R1		// 00000810
	MOVW	R1, LO		// 00200013
	MOVW	R1, HI		// 00200011
	MOVWU	R14, R27	// 000ed83c001bd83e

//	LMOVH rreg ',' rreg

	b.Run(" 00000000|X0000000 ", func(b *testing.B) { benchmarkErasureEncode(8, 8, 0, 1, size, b) })
	b.Run(" X0000000|00000000 ", func(b *testing.B) { benchmarkErasureEncode(8, 8, 1, 0, size, b) })
	b.Run(" 00000000|XXXXXXX0 ", func(b *testing.B) { benchmarkErasureEncode(8, 8, 0, 7, size, b) })
	b.Run(" XXXXXXX0|00000000 ", func(b *testing.B) { benchmarkErasureEncode(8, 8, 7, 0, size, b) })

    }

    @Test
    @DisplayName("Should convert integer to hex string with padding")
    void testIntToHexString() {
        // Test various integer values
        assertEquals("00000000", Hexdump.toHexString(0, 8));
        assertEquals("000000FF", Hexdump.toHexString(255, 8));
        assertEquals("00001000", Hexdump.toHexString(4096, 8));
        assertEquals("FFFFFFFF", Hexdump.toHexString(-1, 8));

        // Test different sizes

	b.Run(" X0000000|X0000000 ", func(b *testing.B) { benchmarkErasureDecode(8, 8, 1, 1, size, b) })
	b.Run(" 00000000|XXXXXXXX ", func(b *testing.B) { benchmarkErasureDecode(8, 8, 0, 8, size, b) })
	b.Run(" XXXX0000|XXXX0000 ", func(b *testing.B) { benchmarkErasureDecode(8, 8, 4, 4, size, b) })
	b.Run(" XXXXXXXX|00000000 ", func(b *testing.B) { benchmarkErasureDecode(8, 8, 8, 0, size, b) })

        assertNotNull(addresses);
        assertTrue(addresses.length > 0);
        // IPv6 loopback can be represented as ::1 or 0:0:0:0:0:0:0:1
        String hostAddress = addresses[0].getHostAddress();
        assertTrue(hostAddress.contains(":"));
        assertTrue(hostAddress.equals("::1") || hostAddress.equals("0:0:0:0:0:0:0:1"));

        // Test IPv6 address with brackets
        host = "[2001:db8::1]";
        addresses = resolver.resolve(host);

    assertThat(parse("http://[2001:0:0:1:0:0:0:1]/").host).isEqualTo("2001:0:0:1::1")
    assertThat(parse("http://[1:0:0:0:0:0:0:0]/").host).isEqualTo("1::")
    assertThat(parse("http://[0:0:0:0:0:0:0:1]/").host).isEqualTo("::1")
    assertThat(parse("http://[0:0:0:0:0:0:0:0]/").host).isEqualTo("::")
    assertThat(parse("http://[::ffff:c0a8:1fe]/").host).isEqualTo("192.168.1.254")
  }

    return client


def test_extra_types(client: TestClient):
    item_id = "ff97dd87-a4a5-4a12-b412-cde99f33e00e"
    data = {
        "start_datetime": "2018-12-22T14:00:00+00:00",
        "end_datetime": "2018-12-24T15:00:00+00:00",
        "repeat_at": "15:30:00",
        "process_after": 300,
    }
    expected_response = data.copy()
    expected_response.update(
        {

// TODO: cover more instruction

TEXT foo(SB),DUPOK|NOSPLIT,$0
	JAL	1(PC)	//CALL 1(PC)	//00040054
	JAL	(R4)	//CALL (R4)	//8100004c
	// relocation in play so the assembled offset should be 0