LVX	(R4+off80),V13
	LVX	(R4+off96),V14
	LVX	(R4+off112),V15

	ADD	$128,R4

	VXOR	V0,V8,V16
	VXOR	V1,V9,V17
	VXOR	V2,V10,V18
	VXOR	V3,V11,V19
	VXOR	V4,V12,V20
	VXOR	V5,V13,V21
	VXOR	V6,V14,V22
	VXOR	V7,V15,V23

	MOVD    $1,R15
	CMP     $0,R6
	ADD     $128,R6

	BNE	l1
	ANDCC   $127,R5
	SUBC	R5,$128,R6
	ADD	R3,R6,R3

	SRD	$4,R5,R7
	MOVD	R7,CTR
	LVX	(R3),V0

	LEAQ	a1+8(FP), SI
	LEAQ	sysargs-160(SP), DI
	CLD
	MOVSQ
	MOVSQ
	MOVSQ
	SYSCALL
	MOVQ	AX, r1+32(FP)
	MOVQ	$0, r2+40(FP)
	CMPL	AX, $-1
	JNE	ok3

	LEAQ	errbuf-128(SP), AX
	MOVQ	AX, sysargs-160(SP)
	MOVQ	$128, sysargs1-152(SP)
	MOVQ	$SYS_ERRSTR, BP
	SYSCALL
	CALL	runtime·exitsyscall(SB) // call via ABI wrapper, ensuring ABIInternal fixed registers are set
	MOVQ	sysargs-160(SP), AX
	MOVQ	AX, errbuf-168(SP)

			major: "1",
			minor: "22",
			want:  122,
		},
		{
			name:  "1.28",
			major: "1",
			minor: "28",
			want:  128,
		},
		{
			// {"major": "1","minor": "28+","gitVersion": "v1.28.9-eks-036c24b",...}
			name:       "EKS",
			major:      "1",
			minor:      "28+",
			gitVersion: "v1.28.9-eks-036c24b",
			want:       128,
		},
	}
	for _, tt := range tests {

        lhs_dilation = [],
        rhs_dilation = [],
        dimension_numbers = "",
        batch_group_count = 1,
        feature_group_count = 1,
        rhs_quantization_axis = -1,
        rhs_quantization_min_val = -128,
        rhs_quantization_max_val = 127,
        attr_map = ""
      } : (tensor<*xf32>, tensor<*x!tf_type.qint8>, tensor<*xf32>, tensor<*xi32>) -> tensor<*xf32>


    func.return %out : tensor<*xf32>
  }

func lt_128_uint64(x uint64) bool                  { return x < 128 }
func le_128_uint64(x uint64) bool                  { return x <= 128 }
func gt_128_uint64(x uint64) bool                  { return x > 128 }
func ge_128_uint64(x uint64) bool                  { return x >= 128 }
func eq_128_uint64(x uint64) bool                  { return x == 128 }
func ne_128_uint64(x uint64) bool                  { return x != 128 }

    assertThat(SignedBytes.join("", (byte) 1, (byte) 2, (byte) 3)).isEqualTo("123");
    assertThat(SignedBytes.join(",", (byte) -128, (byte) -1)).isEqualTo("-128,-1");
  }

  @J2ktIncompatible // b/285319375
  public void testLexicographicalComparator() {
    List<byte[]> ordered =
        Arrays.asList(
            new byte[] {},
            new byte[] {LEAST},

import static org.gradle.testing.fixture.JUnitCoverage.JUNIT_JUPITER
import static org.hamcrest.CoreMatchers.containsString

// https://github.com/junit-team/junit5/issues/1285
@TargetCoverage({ JUNIT_JUPITER })
class JUnitJupiterLoggingOutputCaptureIntegrationTest extends AbstractJUnitLoggingOutputCaptureIntegrationTest implements JUnitJupiterMultiVersionTest {
    def "captures logging output events"() {

    DefaultValuedOptionalAttr<I64Attr, "-1">:$lhs_quantization_axis,
    DefaultValuedOptionalAttr<I64Attr, "-128">:$lhs_quantization_min_val,
    DefaultValuedOptionalAttr<I64Attr, "127">:$lhs_quantization_max_val,
    DefaultValuedOptionalAttr<I64Attr, "-1">:$rhs_quantization_axis,
    DefaultValuedOptionalAttr<I64Attr, "-128">:$rhs_quantization_min_val,
    DefaultValuedOptionalAttr<I64Attr, "127">:$rhs_quantization_max_val,

	}

	fmt.Printf("var t T1\n")
	fmt.Printf("var p *T1\n")

	// Simple selectors
	for n := 2; n < 256; n++ {
		writeDot(n)
	}

	// Double selectors
	for n := 128; n < 256; n++ {
		writeDot(n/16, n)
	}

	// Triple selectors
	for n := 128; n < 256; n++ {
		writeDot(n/64, n/8, n)
	}
}

const structTpl = `
type T%d struct {
	A%d int
	T%d
	*T%d
}
`

func writeStruct(n int) {

)

// initialize loads the 256-bit key into the two 128-bit secret values r and s.
func initialize(key *[32]byte, m *macState) {
	m.r[0] = binary.LittleEndian.Uint64(key[0:8]) & rMask0
	m.r[1] = binary.LittleEndian.Uint64(key[8:16]) & rMask1
	m.s[0] = binary.LittleEndian.Uint64(key[16:24])
	m.s[1] = binary.LittleEndian.Uint64(key[24:32])
}

// uint128 holds a 128-bit number as two 64-bit limbs, for use with the