// Code generated by 'go run genfiles.go'; DO NOT EDIT.

//go:build goexperiment.simd

// This file contains functions testing simd methods that compare two operands.
// Each function in this file is specialized for a
// particular simd type <BaseType><Width>x<Count>.

package simd_test

import (
	"simd"
	"testing"
)

// testInt8x16Compare tests the simd comparison method f against the expected behavior generated by want
func testInt8x16Compare(t *testing.T, f func(_, _ simd.Int8x16) simd.Mask8x16, want func(_, _ []int8) []int64) {
	n := 16
	t.Helper()
	forSlicePair(t, int8s, n, func(x, y []int8) bool {
		t.Helper()
		a := simd.LoadInt8x16Slice(x)
		b := simd.LoadInt8x16Slice(y)
		g := make([]int8, n)
		f(a, b).AsInt8x16().StoreSlice(g)
		w := want(x, y)
		return checkSlicesLogInput(t, s64(g), w, 0.0, func() { t.Helper(); t.Logf("x=%v", x); t.Logf("y=%v", y) })
	})
}

// testInt16x8Compare tests the simd comparison method f against the expected behavior generated by want
func testInt16x8Compare(t *testing.T, f func(_, _ simd.Int16x8) simd.Mask16x8, want func(_, _ []int16) []int64) {
	n := 8
	t.Helper()
	forSlicePair(t, int16s, n, func(x, y []int16) bool {
		t.Helper()
		a := simd.LoadInt16x8Slice(x)
		b := simd.LoadInt16x8Slice(y)
		g := make([]int16, n)
		f(a, b).AsInt16x8().StoreSlice(g)
		w := want(x, y)
		return checkSlicesLogInput(t, s64(g), w, 0.0, func() { t.Helper(); t.Logf("x=%v", x); t.Logf("y=%v", y) })
	})
}

// testInt32x4Compare tests the simd comparison method f against the expected behavior generated by want
func testInt32x4Compare(t *testing.T, f func(_, _ simd.Int32x4) simd.Mask32x4, want func(_, _ []int32) []int64) {
	n := 4
	t.Helper()
	forSlicePair(t, int32s, n, func(x, y []int32) bool {
		t.Helper()
		a := simd.LoadInt32x4Slice(x)
		b := simd.LoadInt32x4Slice(y)
		g := make([]int32, n)
		f(a, b).AsInt32x4().StoreSlice(g)
		w := want(x, y)
		return checkSlicesLogInput(t, s64(g), w, 0.0, func() { t.Helper(); t.Logf("x=%v", x); t.Logf("y=%v", y) })
	})
}

// testInt64x2Compare tests the simd comparison method f against the expected behavior generated by want
func testInt64x2Compare(t *testing.T, f func(_, _ simd.Int64x2) simd.Mask64x2, want func(_, _ []int64) []int64) {
	n := 2
	t.Helper()
	forSlicePair(t, int64s, n, func(x, y []int64) bool {
		t.Helper()
		a := simd.LoadInt64x2Slice(x)
		b := simd.LoadInt64x2Slice(y)
		g := make([]int64, n)
		f(a, b).AsInt64x2().StoreSlice(g)
		w := want(x, y)
		return checkSlicesLogInput(t, s64(g), w, 0.0, func() { t.Helper(); t.Logf("x=%v", x); t.Logf("y=%v", y) })
	})
}

// testUint8x16Compare tests the simd comparison method f against the expected behavior generated by want
func testUint8x16Compare(t *testing.T, f func(_, _ simd.Uint8x16) simd.Mask8x16, want func(_, _ []uint8) []int64) {
	n := 16
	t.Helper()
	forSlicePair(t, uint8s, n, func(x, y []uint8) bool {
		t.Helper()
		a := simd.LoadUint8x16Slice(x)
		b := simd.LoadUint8x16Slice(y)
		g := make([]int8, n)
		f(a, b).AsInt8x16().StoreSlice(g)
		w := want(x, y)
		return checkSlicesLogInput(t, s64(g), w, 0.0, func() { t.Helper(); t.Logf("x=%v", x); t.Logf("y=%v", y) })
	})
}

// testUint16x8Compare tests the simd comparison method f against the expected behavior generated by want
func testUint16x8Compare(t *testing.T, f func(_, _ simd.Uint16x8) simd.Mask16x8, want func(_, _ []uint16) []int64) {
	n := 8
	t.Helper()
	forSlicePair(t, uint16s, n, func(x, y []uint16) bool {
		t.Helper()
		a := simd.LoadUint16x8Slice(x)
		b := simd.LoadUint16x8Slice(y)
		g := make([]int16, n)
		f(a, b).AsInt16x8().StoreSlice(g)
		w := want(x, y)
		return checkSlicesLogInput(t, s64(g), w, 0.0, func() { t.Helper(); t.Logf("x=%v", x); t.Logf("y=%v", y) })
	})
}

// testUint32x4Compare tests the simd comparison method f against the expected behavior generated by want
func testUint32x4Compare(t *testing.T, f func(_, _ simd.Uint32x4) simd.Mask32x4, want func(_, _ []uint32) []int64) {
	n := 4
	t.Helper()
	forSlicePair(t, uint32s, n, func(x, y []uint32) bool {
		t.Helper()
		a := simd.LoadUint32x4Slice(x)
		b := simd.LoadUint32x4Slice(y)
		g := make([]int32, n)
		f(a, b).AsInt32x4().StoreSlice(g)
		w := want(x, y)
		return checkSlicesLogInput(t, s64(g), w, 0.0, func() { t.Helper(); t.Logf("x=%v", x); t.Logf("y=%v", y) })
	})
}

// testUint64x2Compare tests the simd comparison method f against the expected behavior generated by want
func testUint64x2Compare(t *testing.T, f func(_, _ simd.Uint64x2) simd.Mask64x2, want func(_, _ []uint64) []int64) {
	n := 2
	t.Helper()
	forSlicePair(t, uint64s, n, func(x, y []uint64) bool {
		t.Helper()
		a := simd.LoadUint64x2Slice(x)
		b := simd.LoadUint64x2Slice(y)
		g := make([]int64, n)
		f(a, b).AsInt64x2().StoreSlice(g)
		w := want(x, y)
		return checkSlicesLogInput(t, s64(g), w, 0.0, func() { t.Helper(); t.Logf("x=%v", x); t.Logf("y=%v", y) })
	})
}

// testFloat32x4Compare tests the simd comparison method f against the expected behavior generated by want
func testFloat32x4Compare(t *testing.T, f func(_, _ simd.Float32x4) simd.Mask32x4, want func(_, _ []float32) []int64) {
	n := 4
	t.Helper()
	forSlicePair(t, float32s, n, func(x, y []float32) bool {
		t.Helper()
		a := simd.LoadFloat32x4Slice(x)
		b := simd.LoadFloat32x4Slice(y)
		g := make([]int32, n)
		f(a, b).AsInt32x4().StoreSlice(g)
		w := want(x, y)
		return checkSlicesLogInput(t, s64(g), w, 0.0, func() { t.Helper(); t.Logf("x=%v", x); t.Logf("y=%v", y) })
	})
}

// testFloat64x2Compare tests the simd comparison method f against the expected behavior generated by want
func testFloat64x2Compare(t *testing.T, f func(_, _ simd.Float64x2) simd.Mask64x2, want func(_, _ []float64) []int64) {
	n := 2
	t.Helper()
	forSlicePair(t, float64s, n, func(x, y []float64) bool {
		t.Helper()
		a := simd.LoadFloat64x2Slice(x)
		b := simd.LoadFloat64x2Slice(y)
		g := make([]int64, n)
		f(a, b).AsInt64x2().StoreSlice(g)
		w := want(x, y)
		return checkSlicesLogInput(t, s64(g), w, 0.0, func() { t.Helper(); t.Logf("x=%v", x); t.Logf("y=%v", y) })
	})
}

// testInt8x32Compare tests the simd comparison method f against the expected behavior generated by want
func testInt8x32Compare(t *testing.T, f func(_, _ simd.Int8x32) simd.Mask8x32, want func(_, _ []int8) []int64) {
	n := 32
	t.Helper()
	forSlicePair(t, int8s, n, func(x, y []int8) bool {
		t.Helper()
		a := simd.LoadInt8x32Slice(x)
		b := simd.LoadInt8x32Slice(y)
		g := make([]int8, n)
		f(a, b).AsInt8x32().StoreSlice(g)
		w := want(x, y)
		return checkSlicesLogInput(t, s64(g), w, 0.0, func() { t.Helper(); t.Logf("x=%v", x); t.Logf("y=%v", y) })
	})
}

// testInt16x16Compare tests the simd comparison method f against the expected behavior generated by want
func testInt16x16Compare(t *testing.T, f func(_, _ simd.Int16x16) simd.Mask16x16, want func(_, _ []int16) []int64) {
	n := 16
	t.Helper()
	forSlicePair(t, int16s, n, func(x, y []int16) bool {
		t.Helper()
		a := simd.LoadInt16x16Slice(x)
		b := simd.LoadInt16x16Slice(y)
		g := make([]int16, n)
		f(a, b).AsInt16x16().StoreSlice(g)
		w := want(x, y)
		return checkSlicesLogInput(t, s64(g), w, 0.0, func() { t.Helper(); t.Logf("x=%v", x); t.Logf("y=%v", y) })
	})
}

// testInt32x8Compare tests the simd comparison method f against the expected behavior generated by want
func testInt32x8Compare(t *testing.T, f func(_, _ simd.Int32x8) simd.Mask32x8, want func(_, _ []int32) []int64) {
	n := 8
	t.Helper()
	forSlicePair(t, int32s, n, func(x, y []int32) bool {
		t.Helper()
		a := simd.LoadInt32x8Slice(x)
		b := simd.LoadInt32x8Slice(y)
		g := make([]int32, n)
		f(a, b).AsInt32x8().StoreSlice(g)
		w := want(x, y)
		return checkSlicesLogInput(t, s64(g), w, 0.0, func() { t.Helper(); t.Logf("x=%v", x); t.Logf("y=%v", y) })
	})
}

// testInt64x4Compare tests the simd comparison method f against the expected behavior generated by want
func testInt64x4Compare(t *testing.T, f func(_, _ simd.Int64x4) simd.Mask64x4, want func(_, _ []int64) []int64) {
	n := 4
	t.Helper()
	forSlicePair(t, int64s, n, func(x, y []int64) bool {
		t.Helper()
		a := simd.LoadInt64x4Slice(x)
		b := simd.LoadInt64x4Slice(y)
		g := make([]int64, n)
		f(a, b).AsInt64x4().StoreSlice(g)
		w := want(x, y)
		return checkSlicesLogInput(t, s64(g), w, 0.0, func() { t.Helper(); t.Logf("x=%v", x); t.Logf("y=%v", y) })
	})
}

// testUint8x32Compare tests the simd comparison method f against the expected behavior generated by want
func testUint8x32Compare(t *testing.T, f func(_, _ simd.Uint8x32) simd.Mask8x32, want func(_, _ []uint8) []int64) {
	n := 32
	t.Helper()
	forSlicePair(t, uint8s, n, func(x, y []uint8) bool {
		t.Helper()
		a := simd.LoadUint8x32Slice(x)
		b := simd.LoadUint8x32Slice(y)
		g := make([]int8, n)
		f(a, b).AsInt8x32().StoreSlice(g)
		w := want(x, y)
		return checkSlicesLogInput(t, s64(g), w, 0.0, func() { t.Helper(); t.Logf("x=%v", x); t.Logf("y=%v", y) })
	})
}

// testUint16x16Compare tests the simd comparison method f against the expected behavior generated by want
func testUint16x16Compare(t *testing.T, f func(_, _ simd.Uint16x16) simd.Mask16x16, want func(_, _ []uint16) []int64) {
	n := 16
	t.Helper()
	forSlicePair(t, uint16s, n, func(x, y []uint16) bool {
		t.Helper()
		a := simd.LoadUint16x16Slice(x)
		b := simd.LoadUint16x16Slice(y)
		g := make([]int16, n)
		f(a, b).AsInt16x16().StoreSlice(g)
		w := want(x, y)
		return checkSlicesLogInput(t, s64(g), w, 0.0, func() { t.Helper(); t.Logf("x=%v", x); t.Logf("y=%v", y) })
	})
}

// testUint32x8Compare tests the simd comparison method f against the expected behavior generated by want
func testUint32x8Compare(t *testing.T, f func(_, _ simd.Uint32x8) simd.Mask32x8, want func(_, _ []uint32) []int64) {
	n := 8
	t.Helper()
	forSlicePair(t, uint32s, n, func(x, y []uint32) bool {
		t.Helper()
		a := simd.LoadUint32x8Slice(x)
		b := simd.LoadUint32x8Slice(y)
		g := make([]int32, n)
		f(a, b).AsInt32x8().StoreSlice(g)
		w := want(x, y)
		return checkSlicesLogInput(t, s64(g), w, 0.0, func() { t.Helper(); t.Logf("x=%v", x); t.Logf("y=%v", y) })
	})
}

// testUint64x4Compare tests the simd comparison method f against the expected behavior generated by want
func testUint64x4Compare(t *testing.T, f func(_, _ simd.Uint64x4) simd.Mask64x4, want func(_, _ []uint64) []int64) {
	n := 4
	t.Helper()
	forSlicePair(t, uint64s, n, func(x, y []uint64) bool {
		t.Helper()
		a := simd.LoadUint64x4Slice(x)
		b := simd.LoadUint64x4Slice(y)
		g := make([]int64, n)
		f(a, b).AsInt64x4().StoreSlice(g)
		w := want(x, y)
		return checkSlicesLogInput(t, s64(g), w, 0.0, func() { t.Helper(); t.Logf("x=%v", x); t.Logf("y=%v", y) })
	})
}

// testFloat32x8Compare tests the simd comparison method f against the expected behavior generated by want
func testFloat32x8Compare(t *testing.T, f func(_, _ simd.Float32x8) simd.Mask32x8, want func(_, _ []float32) []int64) {
	n := 8
	t.Helper()
	forSlicePair(t, float32s, n, func(x, y []float32) bool {
		t.Helper()
		a := simd.LoadFloat32x8Slice(x)
		b := simd.LoadFloat32x8Slice(y)
		g := make([]int32, n)
		f(a, b).AsInt32x8().StoreSlice(g)
		w := want(x, y)
		return checkSlicesLogInput(t, s64(g), w, 0.0, func() { t.Helper(); t.Logf("x=%v", x); t.Logf("y=%v", y) })
	})
}

// testFloat64x4Compare tests the simd comparison method f against the expected behavior generated by want
func testFloat64x4Compare(t *testing.T, f func(_, _ simd.Float64x4) simd.Mask64x4, want func(_, _ []float64) []int64) {
	n := 4
	t.Helper()
	forSlicePair(t, float64s, n, func(x, y []float64) bool {
		t.Helper()
		a := simd.LoadFloat64x4Slice(x)
		b := simd.LoadFloat64x4Slice(y)
		g := make([]int64, n)
		f(a, b).AsInt64x4().StoreSlice(g)
		w := want(x, y)
		return checkSlicesLogInput(t, s64(g), w, 0.0, func() { t.Helper(); t.Logf("x=%v", x); t.Logf("y=%v", y) })
	})
}

// testInt8x64Compare tests the simd comparison method f against the expected behavior generated by want
func testInt8x64Compare(t *testing.T, f func(_, _ simd.Int8x64) simd.Mask8x64, want func(_, _ []int8) []int64) {
	n := 64
	t.Helper()
	forSlicePair(t, int8s, n, func(x, y []int8) bool {
		t.Helper()
		a := simd.LoadInt8x64Slice(x)
		b := simd.LoadInt8x64Slice(y)
		g := make([]int8, n)
		f(a, b).AsInt8x64().StoreSlice(g)
		w := want(x, y)
		return checkSlicesLogInput(t, s64(g), w, 0.0, func() { t.Helper(); t.Logf("x=%v", x); t.Logf("y=%v", y) })
	})
}

// testInt16x32Compare tests the simd comparison method f against the expected behavior generated by want
func testInt16x32Compare(t *testing.T, f func(_, _ simd.Int16x32) simd.Mask16x32, want func(_, _ []int16) []int64) {
	n := 32
	t.Helper()
	forSlicePair(t, int16s, n, func(x, y []int16) bool {
		t.Helper()
		a := simd.LoadInt16x32Slice(x)
		b := simd.LoadInt16x32Slice(y)
		g := make([]int16, n)
		f(a, b).AsInt16x32().StoreSlice(g)
		w := want(x, y)
		return checkSlicesLogInput(t, s64(g), w, 0.0, func() { t.Helper(); t.Logf("x=%v", x); t.Logf("y=%v", y) })
	})
}

// testInt32x16Compare tests the simd comparison method f against the expected behavior generated by want
func testInt32x16Compare(t *testing.T, f func(_, _ simd.Int32x16) simd.Mask32x16, want func(_, _ []int32) []int64) {
	n := 16
	t.Helper()
	forSlicePair(t, int32s, n, func(x, y []int32) bool {
		t.Helper()
		a := simd.LoadInt32x16Slice(x)
		b := simd.LoadInt32x16Slice(y)
		g := make([]int32, n)
		f(a, b).AsInt32x16().StoreSlice(g)
		w := want(x, y)
		return checkSlicesLogInput(t, s64(g), w, 0.0, func() { t.Helper(); t.Logf("x=%v", x); t.Logf("y=%v", y) })
	})
}

// testInt64x8Compare tests the simd comparison method f against the expected behavior generated by want
func testInt64x8Compare(t *testing.T, f func(_, _ simd.Int64x8) simd.Mask64x8, want func(_, _ []int64) []int64) {
	n := 8
	t.Helper()
	forSlicePair(t, int64s, n, func(x, y []int64) bool {
		t.Helper()
		a := simd.LoadInt64x8Slice(x)
		b := simd.LoadInt64x8Slice(y)
		g := make([]int64, n)
		f(a, b).AsInt64x8().StoreSlice(g)
		w := want(x, y)
		return checkSlicesLogInput(t, s64(g), w, 0.0, func() { t.Helper(); t.Logf("x=%v", x); t.Logf("y=%v", y) })
	})
}

// testUint8x64Compare tests the simd comparison method f against the expected behavior generated by want
func testUint8x64Compare(t *testing.T, f func(_, _ simd.Uint8x64) simd.Mask8x64, want func(_, _ []uint8) []int64) {
	n := 64
	t.Helper()
	forSlicePair(t, uint8s, n, func(x, y []uint8) bool {
		t.Helper()
		a := simd.LoadUint8x64Slice(x)
		b := simd.LoadUint8x64Slice(y)
		g := make([]int8, n)
		f(a, b).AsInt8x64().StoreSlice(g)
		w := want(x, y)
		return checkSlicesLogInput(t, s64(g), w, 0.0, func() { t.Helper(); t.Logf("x=%v", x); t.Logf("y=%v", y) })
	})
}

// testUint16x32Compare tests the simd comparison method f against the expected behavior generated by want
func testUint16x32Compare(t *testing.T, f func(_, _ simd.Uint16x32) simd.Mask16x32, want func(_, _ []uint16) []int64) {
	n := 32
	t.Helper()
	forSlicePair(t, uint16s, n, func(x, y []uint16) bool {
		t.Helper()
		a := simd.LoadUint16x32Slice(x)
		b := simd.LoadUint16x32Slice(y)
		g := make([]int16, n)
		f(a, b).AsInt16x32().StoreSlice(g)
		w := want(x, y)
		return checkSlicesLogInput(t, s64(g), w, 0.0, func() { t.Helper(); t.Logf("x=%v", x); t.Logf("y=%v", y) })
	})
}

// testUint32x16Compare tests the simd comparison method f against the expected behavior generated by want
func testUint32x16Compare(t *testing.T, f func(_, _ simd.Uint32x16) simd.Mask32x16, want func(_, _ []uint32) []int64) {
	n := 16
	t.Helper()
	forSlicePair(t, uint32s, n, func(x, y []uint32) bool {
		t.Helper()
		a := simd.LoadUint32x16Slice(x)
		b := simd.LoadUint32x16Slice(y)
		g := make([]int32, n)
		f(a, b).AsInt32x16().StoreSlice(g)
		w := want(x, y)
		return checkSlicesLogInput(t, s64(g), w, 0.0, func() { t.Helper(); t.Logf("x=%v", x); t.Logf("y=%v", y) })
	})
}

// testUint64x8Compare tests the simd comparison method f against the expected behavior generated by want
func testUint64x8Compare(t *testing.T, f func(_, _ simd.Uint64x8) simd.Mask64x8, want func(_, _ []uint64) []int64) {
	n := 8
	t.Helper()
	forSlicePair(t, uint64s, n, func(x, y []uint64) bool {
		t.Helper()
		a := simd.LoadUint64x8Slice(x)
		b := simd.LoadUint64x8Slice(y)
		g := make([]int64, n)
		f(a, b).AsInt64x8().StoreSlice(g)
		w := want(x, y)
		return checkSlicesLogInput(t, s64(g), w, 0.0, func() { t.Helper(); t.Logf("x=%v", x); t.Logf("y=%v", y) })
	})
}

// testFloat32x16Compare tests the simd comparison method f against the expected behavior generated by want
func testFloat32x16Compare(t *testing.T, f func(_, _ simd.Float32x16) simd.Mask32x16, want func(_, _ []float32) []int64) {
	n := 16
	t.Helper()
	forSlicePair(t, float32s, n, func(x, y []float32) bool {
		t.Helper()
		a := simd.LoadFloat32x16Slice(x)
		b := simd.LoadFloat32x16Slice(y)
		g := make([]int32, n)
		f(a, b).AsInt32x16().StoreSlice(g)
		w := want(x, y)
		return checkSlicesLogInput(t, s64(g), w, 0.0, func() { t.Helper(); t.Logf("x=%v", x); t.Logf("y=%v", y) })
	})
}

// testFloat64x8Compare tests the simd comparison method f against the expected behavior generated by want
func testFloat64x8Compare(t *testing.T, f func(_, _ simd.Float64x8) simd.Mask64x8, want func(_, _ []float64) []int64) {
	n := 8
	t.Helper()
	forSlicePair(t, float64s, n, func(x, y []float64) bool {
		t.Helper()
		a := simd.LoadFloat64x8Slice(x)
		b := simd.LoadFloat64x8Slice(y)
		g := make([]int64, n)
		f(a, b).AsInt64x8().StoreSlice(g)
		w := want(x, y)
		return checkSlicesLogInput(t, s64(g), w, 0.0, func() { t.Helper(); t.Logf("x=%v", x); t.Logf("y=%v", y) })
	})
}