MOVOU B2, (16*2)(SP)
	MOVOU B3, (16*3)(SP)
	MOVOU B4, (16*4)(SP)
	MOVOU B5, (16*5)(SP)
	MOVOU B6, (16*6)(SP)
	MOVOU B7, (16*7)(SP)

	LEAQ 128(ptx), ptx
	LEAQ 128(ctx), ctx

gcmAesEncOctetsLoop:

		CMPQ ptxLen, $128
		JB gcmAesEncOctetsEnd
		SUBQ $128, ptxLen

		MOVOU (8*16 + 0*16)(SP), B0
		MOVOU (8*16 + 1*16)(SP), B1
		MOVOU (8*16 + 2*16)(SP), B2
		MOVOU (8*16 + 3*16)(SP), B3

		t.Fatal(err)
	}
	for i := 0; i < 128; i++ {
		r.Seed(42)
		p, err := rand.Prime(r, 32)
		if err != nil {
			t.Fatal(err)
		}
		if p.Cmp(p0) != 0 {
			return
		}
	}
	t.Error("Prime always generated the same prime given the same input")
}

func TestInt(t *testing.T) {
	// start at 128 so the case of (max.BitLen() % 8) == 0 is covered
	for n := 128; n < 140; n++ {
		b := new(big.Int).SetInt64(int64(n))

    /**
     * Context type
     */
    public static final int NEGO_CTX_ENC_TYPE = 0x2;

    /**
     * AES 128 CCM
     */
    public static final int CIPHER_AES128_CCM = 0x1;

    /**
     * AES 128 GCM
     */
    public static final int CIPHER_AES128_GCM = 0x2;

    private int[] ciphers;


    /**
     * 
     * @param config

	MOVQ R14, 96(SP)
	MOVQ R15, 104(SP)
	#ifdef GOOS_darwin
	#ifndef hasAVX
	CMPB internal∕cpu·X86+const_offsetX86HasAVX(SB), $0
	JE 2(PC)
	#endif
	VZEROUPPER
	#endif
	MOVUPS X0, 112(SP)
	MOVUPS X1, 128(SP)
	MOVUPS X2, 144(SP)
	MOVUPS X3, 160(SP)
	MOVUPS X4, 176(SP)
	MOVUPS X5, 192(SP)
	MOVUPS X6, 208(SP)
	MOVUPS X7, 224(SP)
	MOVUPS X8, 240(SP)
	MOVUPS X9, 256(SP)
	MOVUPS X10, 272(SP)
	MOVUPS X11, 288(SP)

	sd	x20, 40(sp)
	sd	x21, 48(sp)
	sd	x22, 56(sp)
	sd	x23, 64(sp)
	sd	x24, 72(sp)
	sd	x25, 80(sp)
	sd	x26, 88(sp)
	sd	x27, 96(sp)
	fsd	f8, 104(sp)
	fsd	f9, 112(sp)
	fsd	f18, 120(sp)
	fsd	f19, 128(sp)
	fsd	f20, 136(sp)
	fsd	f21, 144(sp)
	fsd	f22, 152(sp)
	fsd	f23, 160(sp)
	fsd	f24, 168(sp)
	fsd	f25, 176(sp)
	fsd	f26, 184(sp)
	fsd	f27, 192(sp)

	// a0 = *fn, a1 = *setg_gcc, a2 = *g
	mv	s1, a0

	1280: {region: 0x166, script: 0x5b, flags: 0x0},
	1281: {region: 0x166, script: 0x5b, flags: 0x0},
	1282: {region: 0xdc, script: 0x22, flags: 0x0},
	1283: {region: 0x166, script: 0x5b, flags: 0x0},
	1284: {region: 0x166, script: 0x5b, flags: 0x0},
	1285: {region: 0xd2, script: 0x5b, flags: 0x0},
	1286: {region: 0x76, script: 0x5b, flags: 0x0},
	1287: {region: 0x166, script: 0x5b, flags: 0x0},

	"action":                   "action is what action was taken/failed regarding to the regarding object. It is machine-readable. This field can have at most 128 characters.",
	"reason":                   "reason is why the action was taken. It is human-readable. This field can have at most 128 characters.",

	MOVQ	BP, (2*8)(SP)	\
	MOVQ	BX, (3*8)(SP)	\
	MOVQ	R12, (4*8)(SP)	\
	MOVQ	R13, (5*8)(SP)	\
	MOVQ	R14, (6*8)(SP)	\
	MOVQ	R15, (7*8)(SP)	\
	MOVUPS	X6, (8*8)(SP)	\
	MOVUPS	X7, (10*8)(SP)	\
	MOVUPS	X8, (12*8)(SP)	\
	MOVUPS	X9, (14*8)(SP)	\
	MOVUPS	X10, (16*8)(SP)	\
	MOVUPS	X11, (18*8)(SP)	\
	MOVUPS	X12, (20*8)(SP)	\
	MOVUPS	X13, (22*8)(SP)	\
	MOVUPS	X14, (24*8)(SP)	\
	MOVUPS	X15, (26*8)(SP)

// license that can be found in the LICENSE file.

package os

func hostname() (name string, err error) {
	f, err := Open("#c/sysname")
	if err != nil {
		return "", err
	}
	defer f.Close()

	var buf [128]byte
	n, err := f.Read(buf[:len(buf)-1])

	if err != nil {
		return "", err
	}
	if n > 0 {
		buf[n] = 0
	}
	return string(buf[0:n]), nil

            (options as JUnitPlatformOptions).excludeTags("org.gradle.test.fixtures.Flaky")
        }
        FlakyTestStrategy.ONLY -> {
            // Note there is an issue: https://github.com/spockframework/spock/issues/1288
            // JUnit Platform `includeTags` works before Spock engine, thus excludes all spock tests.
            // As a workaround, we tag all non-spock integration tests and use `includeTags(none() | Flaky)` here.