}
	}
}

func TestAnd64(t *testing.T) {
	// Basic sanity check.
	x := uint64(0xffffffffffffffff)
	sink = &x
	for i := uint64(0); i < 64; i++ {
		old := x
		v := atomic.And64(&x, ^(1 << i))
		if r := uint64(0xffffffffffffffff) << (i + 1); x != r || v != old {
			t.Fatalf("clearing bit %#x: want %#x, got new %#x and old %#v", uint64(1<<i), r, x, v)
		}
	}

//
// Bounds: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
type fiatScalarMontgomeryDomainFieldElement [4]uint64

// The type fiatScalarNonMontgomeryDomainFieldElement is a field element NOT in the Montgomery domain.
//
// Bounds: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]

	CMPQ	DX,CX
	JAE     isBig_floor
	MOVQ	AX, X0 // X0 = x
	CVTTSD2SQ	X0, AX
	CVTSQ2SD	AX, X1 // X1 = float(int(x))
	CMPSD	X1, X0, 1 // compare LT; X0 = 0xffffffffffffffff or 0
	MOVSD	$(-1.0), X2
	ANDPD	X2, X0 // if x < float(int(x)) {X0 = -1} else {X0 = 0}
	ADDSD	X1, X0
	MOVSD	X0, ret+8(FP)
	RET
isBig_floor:
	MOVQ    AX, ret+8(FP) // return x
	RET

package main

// #include <stdlib.h>
import "C"

import (
	"fmt"
	"runtime"
)

func main() {
	var size C.size_t
	size--

	// The Dragonfly libc succeeds when asked to allocate
	// 0xffffffffffffffff bytes, so pass a different value that
	// causes it to fail.
	if runtime.GOOS == "dragonfly" {
		size = C.size_t(0x7fffffff << (32 * (^uintptr(0) >> 63)))
	}

	p := C.malloc(size)
	if p == nil {

TEXT runtime·wasmTruncU(SB), NOSPLIT, $0-0
	Get R0
	Get R0
	F64Ne // NaN
	If
		I64Const $0x8000000000000000
		Return
	End

	Get R0
	F64Const $0xfffffffffffff800p0 // Maximum truncated representation of 0xffffffffffffffff
	F64Gt
	If
		I64Const $0x8000000000000000
		Return
	End

	Get R0
	F64Const $0.
	F64Lt
	If
		I64Const $0x8000000000000000
		Return
	End

	Get R0
	I64TruncF64U
	Return

			convUInt64: 0x8000000000000000,
		},
		{
			input:      -0x7ffffffffffffdfe,
			convInt64:  -0x7ffffffffffffc00,
			convUInt64: 0x8000000000000000,
		},
		// umax +- 1
		{
			input:      0xffffffffffffffff,
			convInt64:  -0x8000000000000000,
			convUInt64: 0x8000000000000000,
		},
		{
			input:      0x10000000000000000,
			convInt64:  -0x8000000000000000,
			convUInt64: 0x8000000000000000,
		},
		{

	// fits in uint64. go/constant uses a different representation for
	// values larger than int64, but the cmd/asm parser can't parse
	// anything bigger than a uint64.
	bigInt = 0xffffffffffffffff

	stringVal = "test"

	longStringVal = "this_is_a_string_constant_longer_than_seventy_characters_which_used_to_fail_see_issue_50253"
)

var (
	smallIntAsm   int64
	bigIntAsm     uint64

		want    uint64
		wantErr string
	}
	tests := []testCase{
		{"x", 0, "invalid byte in chunk length"},
		{"0000000000000000", 0, ""},
		{"0000000000000001", 1, ""},
		{"ffffffffffffffff", 1<<64 - 1, ""},
		{"FFFFFFFFFFFFFFFF", 1<<64 - 1, ""},
		{"000000000000bogus", 0, "invalid byte in chunk length"},
		{"00000000000000000", 0, "http chunk length too large"}, // could accept if we wanted

DATA andMask<>+0x68(SB)/8, $0x0000000000000000
DATA andMask<>+0x70(SB)/8, $0xffffffffffffffff
DATA andMask<>+0x78(SB)/8, $0x0000000000000000
DATA andMask<>+0x80(SB)/8, $0xffffffffffffffff
DATA andMask<>+0x88(SB)/8, $0x00000000000000ff
DATA andMask<>+0x90(SB)/8, $0xffffffffffffffff
DATA andMask<>+0x98(SB)/8, $0x000000000000ffff
DATA andMask<>+0xa0(SB)/8, $0xffffffffffffffff
DATA andMask<>+0xa8(SB)/8, $0x0000000000ffffff

	var _ = string(1.0 /* ERROR "cannot convert" */ << s)
}

func issue22969() {
	var s uint
	var a []byte
	_ = a[0xffffffffffffffff /* ERROR "overflows int" */ <<s] // example from issue 22969
	_ = make([]int, 0xffffffffffffffff /* ERROR "overflows int" */ << s)
	_ = make([]int, 0, 0xffffffffffffffff /* ERROR "overflows int" */ << s)
	var _ byte = 0x100 /* ERROR "overflows byte" */ << s