/*unpacked_values=*/{0x01, 0x02, 0x03, 0x04},
                        /*pack_dim=*/0,
                        /*expected_packed_shape=*/{1, 2},
                        /*expected_packed_values=*/{0x31, 0x42});
}

TEST(TfToXlaAttributeUtilsTest, PackOperandPackDimSizeOdd) {
  PackOperandTestHelper(
      /*unpacked_shape=*/{2, 3},
      /*unpacked_values=*/{0x01, 0x02, 0x03, 0x04, 0x05, 0x06},
      /*pack_dim=*/1,

	cmd.Env = append(cmd.Env, "GO_WANT_HELPER_PROCESS=1")
	out, _ := cmd.CombinedOutput()

	want := `--- FAIL: TestTBHelper \([^)]+\)
    helperfuncs_test.go:15: 0
    helperfuncs_test.go:47: 1
    helperfuncs_test.go:24: 2
    helperfuncs_test.go:49: 3
    helperfuncs_test.go:56: 4
    --- FAIL: TestTBHelper/sub \([^)]+\)
        helperfuncs_test.go:59: 5
        helperfuncs_test.go:24: 6
        helperfuncs_test.go:58: 7

	0x48, 0x8e, 0xf1, 0xc4, 0x23, 0x39, 0xc6, 0x0b, 0x8f, 0xe4, 0x18, 0x6f, 0x3c, 0x92, 0x63, 0x7c,
	0xf0, 0x48, 0x8e, 0x71, 0xc2, 0x63, 0x39, 0x86, 0x28, 0x15, 0x62, 0x42, 0x0a, 0x10, 0x00, 0x00,
	0xff, 0xff, 0x50, 0x91, 0xd0, 0x9c, 0x50, 0x01, 0x00, 0x00,

	BYTE $0xac; BYTE $0x69; BYTE $0xed; BYTE $0xee
	BYTE $0xeb; BYTE $0xef; BYTE $0xec; BYTE $0xbf
	BYTE $0x80; BYTE $0xfd; BYTE $0xfe; BYTE $0xfb
	BYTE $0xfc; BYTE $0xba; BYTE $0xae; BYTE $0x59
	BYTE $0x44; BYTE $0x45; BYTE $0x42; BYTE $0x46
	BYTE $0x43; BYTE $0x47; BYTE $0x9c; BYTE $0x48
	BYTE $0x54; BYTE $0x51; BYTE $0x52; BYTE $0x53
	BYTE $0x58; BYTE $0x55; BYTE $0x56; BYTE $0x57
	BYTE $0x8c; BYTE $0x49; BYTE $0xcd; BYTE $0xce

	var x33 [10<<20]byte
	var x34 [10<<20]byte
	var x35 [10<<20]byte
	var x36 [10<<20]byte
	var x37 [10<<20]byte
	var x38 [10<<20]byte
	var x39 [10<<20]byte
	var x40 [10<<20]byte
	var x41 [10<<20]byte
	var x42 [10<<20]byte
	var x43 [10<<20]byte
	var x44 [10<<20]byte
	var x45 [10<<20]byte
	var x46 [10<<20]byte
	var x47 [10<<20]byte
	var x48 [10<<20]byte
	var x49 [10<<20]byte
	var x50 [10<<20]byte
	var x51 [10<<20]byte

	},
	{
		// LZ4
		header: []byte{0x4, 0x22, 0x4d, 0x18},
		f:      formatLZ4,
	},
	{
		// Snappy/S2 stream
		header: []byte{0xff, 0x06, 0x00, 0x00},
		f:      formatS2,
	},
	{
		header: []byte{0x42, 0x5a, 'h'},
		f:      formatBZ2,
	},
}

type untarOptions struct {
	ignoreDirs bool
	ignoreErrs bool
	prefixAll  string
}

// disconnectReader will ensure that no reads can take place on

	0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02,
	0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x42, 0x0a, 0x5a, 0x08, 0x2e,
	0x3b, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
}

var (
	file_pkg_test_config_mock_config_proto_rawDescOnce sync.Once

000002c0  c4 cf c2 ed 90 99 5f 58  cb 3b 74 08 04 00 80 49  |......_X.;t....I|
000002d0  51 c7 81 cd e1 9f 67 83  76 7e 51 19 83 2a 34 47  |Q.....g.v~Q..*4G|
000002e0  5a e8 6d 13 dd e5 44 eb  1a 20 42 ac d3 65 e8 2e  |Z.m...D.. B..e..|
000002f0  8d c5 79 56 e6 5e 26 00  9b 2a 80 16 d8 2e af 42  |..yV.^&..*.....B|
00000300  35 b7 0f f8 6a 41 87 b6  c5 6a 37 6e bc 17 5e a4  |5...jA...j7n..^.|

		// In tests, rand will return all zeros and NewPrivateKey will reject
		// the zero key as it generates the identity as a public key. This also
		// makes this function consistent with crypto/elliptic.GenerateKey.
		key[1] ^= 0x42

		k, err := c.NewPrivateKey(key)
		if err == errInvalidPrivateKey {
			continue
		}
		return k, err
	}
}

func (c *nistCurve[Point]) NewPrivateKey(key []byte) (*PrivateKey, error) {

00000130  b2 ea 4e 0f 13 f0 6e 63  88 e7 9f 55 65 0b 00 00  |..N...nc...Ue...|
00000140  00 00 00 21 20 f1 10 27  87 e9 eb 1d b9 5f 0e f4  |...! ..'....._..|
00000150  67 e3 19 b6 52 b4 1a 9f  b7 68 0c 4e 25 42 3a 78  |g...R....h.N%B:x|
00000160  91 e1 9d 62 f4                                    |...b.|
>>> Flow 2 (server to client)
00000000  16 03 03 00 58 02 00 00  54 03 03 cf 21 ad 74 e5  |....X...T...!.t.|