VMOVDQU    AA0, (8*32)(oup); VMOVDQU BB0, (9*32)(oup); VMOVDQU CC0, (10*32)(oup); VMOVDQU DD0, (11*32)(oup)

	MOVQ       $384, itr1
	LEAQ       384(inp), inp
	SUBQ       $384, inl
	VPERM2I128 $0x02, AA3, BB3, AA0
	VPERM2I128 $0x02, tmpStoreAVX2, DD3, BB0
	VPERM2I128 $0x13, AA3, BB3, CC0
	VPERM2I128 $0x13, tmpStoreAVX2, DD3, DD0

					EcdhCurves:   []string{"P-256", "P-384"},
					CipherSuites: []string{"ECDHE-ECDSA-AES128-SHA", "ECDHE-RSA-AES256-GCM-SHA384"},
				},
			},
			result: &auth.DownstreamTlsContext{
				CommonTlsContext: &auth.CommonTlsContext{
					TlsParams: &auth.TlsParameters{
						EcdhCurves:   []string{"P-256", "P-384"},

	/* x^237632 mod p(x), x^237568 mod p(x) */
DATA ·IEEEConst+368(SB)/8,$0x00000001e188c74c
DATA ·IEEEConst+376(SB)/8,$0x000000015abd16b4

	/* x^236608 mod p(x), x^236544 mod p(x) */
DATA ·IEEEConst+384(SB)/8,$0x00000001c2d3451c
DATA ·IEEEConst+392(SB)/8,$0x00000000018f9852

	/* x^235584 mod p(x), x^235520 mod p(x) */
DATA ·IEEEConst+400(SB)/8,$0x00000000f55cf1ca
DATA ·IEEEConst+408(SB)/8,$0x000000001fb3084a

				"Virginia Tech Global Qualified Server CA",
				"Trusted Root CA G2",
				"GlobalSign Root CA",
			},
		},
	},
	{
		// Check that SHA-384 intermediates (which are popping up)
		// work.
		name:          "SHA-384",
		leaf:          trustAsiaLeaf,
		intermediates: []string{trustAsiaSHA384Intermediate},
		roots:         []string{digicertRoot},
		currentTime:   1558051200,

				},
				1: &state.NUMANodeState{
					MemoryMap: map[v1.ResourceName]*state.MemoryTable{
						v1.ResourceMemory: {
							Allocatable:    640 * mb,
							Free:           256 * mb,
							Reserved:       384 * mb,
							SystemReserved: 512 * mb,
							TotalMemSize:   2176 * mb,
						},
						hugepages1Gi: {
							Allocatable:    gb,
							Free:           0,
							Reserved:       gb,

	SYS_CHOWN                           = 0x17D // 381
	SYS_CLOSE                           = 0x17E // 382
	SYS_CLOSEDIR                        = 0x17F // 383
	SYS_CREAT                           = 0x180 // 384
	SYS_CTERMID                         = 0x181 // 385
	SYS_DUP                             = 0x182 // 386
	SYS_DUP2                            = 0x183 // 387
	SYS_EXECL                           = 0x184 // 388

		priv    any
		sigAlgo SignatureAlgorithm
	}{
		{"RSA", testPrivateKey, SHA256WithRSA},
		{"RSA-PSS-SHA256", testPrivateKey, SHA256WithRSAPSS},
		{"ECDSA-256", ecdsa256Priv, ECDSAWithSHA256},
		{"ECDSA-384", ecdsa384Priv, ECDSAWithSHA256},
		{"ECDSA-521", ecdsa521Priv, ECDSAWithSHA256},
		{"Ed25519", ed25519Priv, PureEd25519},
	}

	for _, test := range tests {
		template := CertificateRequest{

func stack376()  { var buf [376]byte; use(buf[:]); C.callGoStackCheck() }
func stack380()  { var buf [380]byte; use(buf[:]); C.callGoStackCheck() }
func stack384()  { var buf [384]byte; use(buf[:]); C.callGoStackCheck() }
func stack388()  { var buf [388]byte; use(buf[:]); C.callGoStackCheck() }
func stack392()  { var buf [392]byte; use(buf[:]); C.callGoStackCheck() }

func TestGoldenMarshal(t *testing.T) {
	tests := []struct {
		name    string
		newHash func() hash.Hash
		golden  []sha512Test
	}{
		{"512/224", New512_224, golden224},
		{"512/256", New512_256, golden256},
		{"384", New384, golden384},
		{"512", New, golden512},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			for _, test := range tt.golden {
				h := tt.newHash()
				h2 := tt.newHash()

	380:  {region: 0x9d, script: 0x5, flags: 0x0},
	381:  {region: 0x7f, script: 0x5b, flags: 0x0},
	382:  {region: 0x7c, script: 0x5b, flags: 0x0},
	383:  {region: 0x166, script: 0x5b, flags: 0x0},
	384:  {region: 0x166, script: 0x5b, flags: 0x0},
	385:  {region: 0x166, script: 0x5b, flags: 0x0},
	386:  {region: 0x166, script: 0x5b, flags: 0x0},
	387:  {region: 0x166, script: 0x5b, flags: 0x0},