a = uint8(b)
	if int32(a) != 255 {
		// Failing case prints 'got 255 expected 255'
		println("got", a, "expected 255")
	}
}

//go:noinline
func g() {
	b := int8(func() uint32 { return 0xffffffff }())
	a = uint8(b)
	if int32(a) != 255 {
		// Failing case prints 'got 255 expected 255'
		println("got", a, "expected 255")
	}
}

func main() {
	f()
	g()

	VPCMPEQB Y1, Y2, Y3
	VPMOVMSKB Y3, SI
	CMPL  SI, $0xffffffff
	JE   success_avx2
	ADDQ $1,DI
	CMPQ DI,DX
	JB loop32
	JMP fail_avx2
_33_to_63:
	LEAQ 1(DI)(DX*1), DX
	SUBQ AX, DX
	VMOVDQU -32(R8)(AX*1), Y0
	VMOVDQU (R8), Y1
loop33to63:
	VMOVDQU (DI), Y2
	VPCMPEQB Y1, Y2, Y3
	VPMOVMSKB Y3, SI
	CMPL  SI, $0xffffffff
	JE   partial_success33to63
	ADDQ $1,DI
	CMPQ DI,DX

		}
		return (d * d) >> 2
	}
	testCases := []uint32{
		0,
		1,
		2,
		0x0fffd,
		0x0fffe,
		0x0ffff,
		0x10000,
		0x10001,
		0x10002,
		0xfffffffd,
		0xfffffffe,
		0xffffffff,
	}
	for _, x := range testCases {
		for _, y := range testCases {
			if got, want := sqDiff(x, y), orig(x, y); got != want {
				t.Fatalf("sqDiff(%#x, %#x): got %d, want %d", x, y, got, want)
			}
		}
	}

	_ = '\ue000' // ok
	_ = '\U0010ffff'  // ok
	_ = '\U00110000'  // ERROR "Unicode|unicode"
	_ = "abc\U0010ffffdef"  // ok
	_ = "abc\U00110000def"  // ERROR "Unicode|unicode"
	_ = '\Uffffffff'  // ERROR "Unicode|unicode"

// specified in the ECX register into registers EDX:EAX.
// Currently, the only supported value for XCR is 0.
void
gccgoXgetbv(uint32_t *eax, uint32_t *edx)
{
	uint64_t v = _xgetbv(0);
	*eax = v & 0xffffffff;
	*edx = v >> 32;
}

#pragma clang attribute pop

	var x39 uint64
	x39, x38 = bits.Mul64(x30, 0xfffffffffffffffe)
	var x40 uint64
	var x41 uint64
	x41, x40 = bits.Mul64(x30, 0xffffffff00000000)
	var x42 uint64
	var x43 uint64
	x43, x42 = bits.Mul64(x30, 0xffffffff)
	var x44 uint64
	var x45 uint64
	x44, x45 = bits.Add64(x43, x40, uint64(0x0))
	var x46 uint64
	var x47 uint64
	x46, x47 = bits.Add64(x41, x38, uint64(p384Uint1(x45)))
	var x48 uint64
	var x49 uint64

                size += domain.length;
            }
            else {
                flags &= ( NTLMSSP_NEGOTIATE_OEM_DOMAIN_SUPPLIED ^ 0xffffffff );
            }

            byte[] workstation = new byte[0];
            String suppliedWorkstationString = getSuppliedWorkstation();

                domain = suppliedDomain.toUpperCase().getBytes(
                        getOEMEncoding());
            } else {
                flags &= (NTLMSSP_NEGOTIATE_OEM_DOMAIN_SUPPLIED ^ 0xffffffff);
            }
            byte[] workstation = new byte[0];
            if (suppliedWorkstation != null &&
                    suppliedWorkstation.length() != 0) {
                hostInfo = true;

	_EXCEPTION_FLT_OVERFLOW         = 0xc0000091
	_EXCEPTION_FLT_UNDERFLOW        = 0xc0000093
	_EXCEPTION_INT_DIVIDE_BY_ZERO   = 0xc0000094
	_EXCEPTION_INT_OVERFLOW         = 0xc0000095

	_INFINITE     = 0xffffffff
	_WAIT_TIMEOUT = 0x102

	_EXCEPTION_CONTINUE_EXECUTION  = -0x1
	_EXCEPTION_CONTINUE_SEARCH     = 0x0
	_EXCEPTION_CONTINUE_SEARCH_SEH = 0x1
)

type systeminfo struct {
	anon0                       [4]byte

	if !ok {
		t.Fatal("Failed to set bigN")
	}
	tests := []struct {
		n        *big.Int
		expected int
	}{
		{n: big.NewInt(int64(0)), expected: 0},
		{n: big.NewInt(int64(0xffffffffff)), expected: 40},
		{n: bigN, expected: 1},
	}
	for _, test := range tests {
		actual := countBits(test.n)
		if test.expected != actual {