fixme:   "decoding bigint to interface{} must not produce math/big.Int",
		},
		{
			example: hex("3bffffffffffffffff"),
			reject:  "-2^64-1 overflows int64 and falling back to float64 (as with JSON) loses distinction between float and integer",
		},
		{
			example: hex("c349010000000000000000"),

		},
		{
			name:          "int64 min negative value",
			in:            hex("3b7fffffffffffffff"), // -9223372036854775808
			want:          int64(-9223372036854775808),
			assertOnError: assertNilError,
		},
		{
			name: "min negative integer value supported by cbor: -2^64",
			in:   hex("3bffffffffffffffff"), // -18446744073709551616

      UnsignedLongs.parseUnsignedLong("18446744073709551616");
      fail();
    } catch (NumberFormatException expected) {
    }
  }

  public void testDecodeLong() {
    assertThat(UnsignedLongs.decode("0xffffffffffffffff")).isEqualTo(0xffffffffffffffffL);
    assertThat(UnsignedLongs.decode("01234567")).isEqualTo(01234567); // octal
    assertThat(UnsignedLongs.decode("#1234567890abcdef")).isEqualTo(0x1234567890abcdefL);

      UnsignedLongs.parseUnsignedLong("18446744073709551616");
      fail();
    } catch (NumberFormatException expected) {
    }
  }

  public void testDecodeLong() {
    assertThat(UnsignedLongs.decode("0xffffffffffffffff")).isEqualTo(0xffffffffffffffffL);
    assertThat(UnsignedLongs.decode("01234567")).isEqualTo(01234567); // octal
    assertThat(UnsignedLongs.decode("#1234567890abcdef")).isEqualTo(0x1234567890abcdefL);

		t.Error(err)
	}

	if !asmLikeGeneric([5]uint64{0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff}) {
		t.Errorf("failed for {0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff}")
	}
}

func TestFeSquare(t *testing.T) {
	asmLikeGeneric := func(a Element) bool {
		t1 := a

		}
	}
}

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]]

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

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