//
//go:noinline
func (v V) autos_ssa(which, w1, x1, w2, x2 int64) (y, z V) {
	fill_ssa(v.w, v.x, &v, v.p) // gratuitous no-op to force addressing
	var a, b, c, d, e, f, g, h V
	fill_ssa(w1, x1, &a, &b)
	fill_ssa(w1, x2, &b, &c)
	fill_ssa(w1, v.x, &c, &d)
	fill_ssa(w2, x1, &d, &e)
	fill_ssa(w2, x2, &e, &f)
	fill_ssa(w2, v.x, &f, &g)
	fill_ssa(v.w, x1, &g, &h)
	fill_ssa(v.w, x2, &h, &a)
	switch which {

        versionCatalogFile.text == toPlatformLineSeparators("""$COMMON_START
[versions]
group-long = "1.1"
group-long-x1 = "1.2"

[libraries]
group-long = { module = "group:long", version.ref = "group-long" }
group-long-x1 = { module = "group:long", version.ref = "group-long-x1" }
""")
    }

    def "generates valid identifiers"() {
        setup:

move_17through32:
	MOVOU	(SI), X0
	MOVOU	-16(SI)(BX*1), X1
	MOVOU	X0, (DI)
	MOVOU	X1, -16(DI)(BX*1)
	RET
move_33through64:
	MOVOU	(SI), X0
	MOVOU	16(SI), X1
	MOVOU	-32(SI)(BX*1), X2
	MOVOU	-16(SI)(BX*1), X3
	MOVOU	X0, (DI)
	MOVOU	X1, 16(DI)
	MOVOU	X2, -32(DI)(BX*1)
	MOVOU	X3, -16(DI)(BX*1)
	RET
move_65through128:
	MOVOU	(SI), X0
	MOVOU	16(SI), X1
	MOVOU	32(SI), X2
	MOVOU	48(SI), X3

	// 16 bytes loaded at this address won't cross
	// a page boundary, so we can load it directly.
	MOVOU	-16(AX), X1
	ADDL	BX, BX
	PAND	masks<>(SB)(BX*8), X1

final1:
	PXOR	X0, X1	// xor data with seed
	AESENC	X1, X1  // scramble combo 3 times
	AESENC	X1, X1
	AESENC	X1, X1
	MOVL	X1, (DX)
	RET

endofpage:
	// address ends in 1111xxxx. Might be up against

			return &NotExpr{X: x}
		}
		return x
	case *AndExpr:
		x1 := pushNot(x.X, not)
		y1 := pushNot(x.Y, not)
		if not {
			return or(x1, y1)
		}
		if x1 == x.X && y1 == x.Y {
			return x
		}
		return and(x1, y1)
	case *OrExpr:
		x1 := pushNot(x.X, not)
		y1 := pushNot(x.Y, not)
		if not {
			return and(x1, y1)
		}
		if x1 == x.X && y1 == x.Y {
			return x
		}
		return or(x1, y1)

// Test case for issue 6638.

type T interface {
	m() [T(nil).m /* ERROR "undefined" */ ()[0]]int
}

// Variations of this test case.

type T1 /* ERROR "invalid recursive type" */ interface {
	m() [x1.m()[0]]int
}

var x1 T1

type T2 /* ERROR "invalid recursive type" */ interface {
	m() [len(x2.m())]int
}

var x2 T2

type T3 /* ERROR "invalid recursive type" */ interface {
	m() [unsafe.Sizeof(x3.m)]int
}

  // so we get back [nullptr, 1].

  AbstractTensorHandlePtr x1;
  {
    AbstractTensorHandle* x1_raw = nullptr;
    status_ = TestScalarTensorHandle<float, TF_FLOAT>(
        immediate_execution_ctx_.get(), 1.0f, &x1_raw);
    ASSERT_EQ(errors::OK, status_.code()) << status_.message();
    x1.reset(x1_raw);
  }

  AbstractTensorHandlePtr x2;
  {
    AbstractTensorHandle* x2_raw = nullptr;

		// eliminate bounds checks on p
		q := p[i:]
		q = q[:BlockSize:BlockSize]

		// save current state
		aa, bb, cc, dd := a, b, c, d

		// load input block
		x0 := byteorder.LeUint32(q[4*0x0:])
		x1 := byteorder.LeUint32(q[4*0x1:])
		x2 := byteorder.LeUint32(q[4*0x2:])
		x3 := byteorder.LeUint32(q[4*0x3:])
		x4 := byteorder.LeUint32(q[4*0x4:])
		x5 := byteorder.LeUint32(q[4*0x5:])
		x6 := byteorder.LeUint32(q[4*0x6:])

	T1[P1 any] struct {
		f1 T2[P1, float32]
	}

	T2[P2, P3 any] struct {
		f2 P2
		f3 P3
	}
)

func _() {
	var x1 T1[int]
	var x2 T2[int, float32]

	x1.f1.f2 = 0
	x1.f1 = x2
}

type T3[P any] T1[T2[P, P]]

func _() {
	var x1 T3[int]
	var x2 T2[int, int]
	x1.f1.f2 = x2
}

func f[P any] (x P) List[P] {
	return List[P]{x}
}

var (
	_ []int = f(0)

	CMPL	SI, DI
	JEQ	allsame
	CMPL	BP, $4
	JB	small
#ifdef GO386_softfloat
	JMP	mediumloop
#endif
largeloop:
	CMPL	BP, $16
	JB	mediumloop
	MOVOU	(SI), X0
	MOVOU	(DI), X1
	PCMPEQB X0, X1
	PMOVMSKB X1, BX
	XORL	$0xffff, BX	// convert EQ to NE
	JNE	diff16	// branch if at least one byte is not equal
	ADDL	$16, SI
	ADDL	$16, DI
	SUBL	$16, BP
	JMP	largeloop

diff16: