std::vector<uint8_t> PackInt4ValuesDensely(std::vector<uint8_t> src_buffer);

// Assumes `src_buffer` contains 2 4-bit elements packed in 8-bit.
// Returns a vector where each int8 element contains a int4 sign-extended value.
std::vector<char> UnpackDenseInt4IntoInt8(
    const std::vector<uint8_t>& src_buffer, int64_t num_elements);
}  // namespace tflite

			low = uint32(prod)
		}
	}
	return int32(prod >> 32)
}

// Intn returns, as an int, a non-negative pseudo-random number in the half-open interval [0,n).
// It panics if n <= 0.
func (r *Rand) Intn(n int) int {
	if n <= 0 {
		panic("invalid argument to Intn")
	}
	if n <= 1<<31-1 {
		return int(r.Int31n(int32(n)))
	}
	return int(r.Int63n(int64(n)))
}

	exp := makeExpectedDump(`
        IN 0: R{ I0 } spilloffset: 0 typ: int8
        IN 1: R{ I1 I2 I3 I4 } spilloffset: 2 typ: struct { int8; int8; struct {}; int8; int16 }
        IN 2: R{ I5 } spilloffset: 8 typ: int64
        OUT 0: R{ I0 I1 I2 I3 } spilloffset: -1 typ: struct { int8; int8; struct {}; int8; int16 }
        OUT 1: R{ I4 } spilloffset: -1 typ: int8
        OUT 2: R{ I5 } spilloffset: -1 typ: int32

	} else {
		t.Fatal("expected result must not be nil")
	}
}

func TestIP(t *testing.T) {
	ipv4Addr, _ := netip.ParseAddr("192.168.0.1")
	int4 := types.Int(4)

	ipv6Addr, _ := netip.ParseAddr("2001:db8::68")
	int6 := types.Int(6)

	trueVal := types.Bool(true)
	falseVal := types.Bool(false)

	cases := []struct {
		name              string
		expr              string

      mlir::FloatType::getFloat8E4M3FN(&context)));

  ASSERT_NO_FATAL_FAILURE(VerifyConversion<int4>(
      {static_cast<int4>(1), static_cast<int4>(-1)}, DT_INT4,
      mlir::IntegerType::get(&context, 4,
                             mlir::IntegerType::SignednessSemantics::Signed)));
  ASSERT_NO_FATAL_FAILURE(VerifyConversion<int8>(
      {1, -1}, DT_INT8, mlir::IntegerType::get(&context, 8)));

	"reflect"
	"strings"
	"time"
)

var defaultMaxCount *int = flag.Int("quickchecks", 100, "The default number of iterations for each check")

// A Generator can generate random values of its own type.
type Generator interface {
	// Generate returns a random instance of the type on which it is a
	// method using the size as a size hint.
	Generate(rand *rand.Rand, size int) reflect.Value
}

		golden func(int8) int8
	}{
		{"x|x", func(x int8) int8 { return x | x }, id},
		{"x|0", func(x int8) int8 { return x | 0 }, id},
		{"x|-1", func(x int8) int8 { return x | -1 }, func(x int8) int8 { return -1 }},
		{"x&x", func(x int8) int8 { return x & x }, id},
		{"x&0", func(x int8) int8 { return x & 0 }, zero},
		{"x&-1", func(x int8) int8 { return x & -1 }, id},
		{"x^x", func(x int8) int8 { return x ^ x }, zero},

	if rand.Intn(10) > 5 {
		m.supportedVersion = uint16(rand.Intn(0xffff) + 1)
	}
	if rand.Intn(10) > 5 {
		m.cookie = randomBytes(rand.Intn(500)+1, rand)
	}
	if rand.Intn(10) > 5 {
		for i := 0; i < rand.Intn(5); i++ {
			m.serverShare.group = CurveID(rand.Intn(30000) + 1)
			m.serverShare.data = randomBytes(rand.Intn(200)+1, rand)
		}
	} else if rand.Intn(10) > 5 {
		m.selectedGroup = CurveID(rand.Intn(30000) + 1)
	}

	Type        [64]int8
	Blocksize   uint32
	Min_keysize uint32
	Max_keysize uint32
}

type CryptoReportBlkCipher struct {
	Type        [64]int8
	Geniv       [64]int8
	Blocksize   uint32
	Min_keysize uint32
	Max_keysize uint32
	Ivsize      uint32
}

type CryptoReportAEAD struct {
	Type        [64]int8
	Geniv       [64]int8
	Blocksize   uint32
	Maxauthsize uint32

	Type        [64]int8
	Blocksize   uint32
	Min_keysize uint32
	Max_keysize uint32
}

type CryptoReportBlkCipher struct {
	Type        [64]int8
	Geniv       [64]int8
	Blocksize   uint32
	Min_keysize uint32
	Max_keysize uint32
	Ivsize      uint32
}

type CryptoReportAEAD struct {
	Type        [64]int8
	Geniv       [64]int8
	Blocksize   uint32
	Maxauthsize uint32