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

//line x1.go:4
package main

	p4()
	p5()
	p6()
	p7()
	p8()
	p9()
	p10()
	p11()
}

var gx []int

func f(i int) int {
	return gx[i]
}

func check(x []int, x0, x1, x2 int) {
	if x[0] != x0 || x[1] != x1 || x[2] != x2 {
		fmt.Printf("%v, want %d,%d,%d\n", x, x0, x1, x2)
		panic("failed")
	}
}

func check3(x, y, z, xx, yy, zz int) {
	if x != xx || y != yy || z != zz {

const (
	basic /* =@basic */ = iota
	labelOk // =@labelOk
)

type T /* =@T */ int

func _(count /* =@count */ T /* @T */) {
	x /* =@x1 */ := c /* @cdecl */{}
	switch x /* =@x2 */ := x /* @x1 */; x /* =@x3 */ := x /* @x2 */.(type) {
	case c /* @cdecl */:
	default:
	}
loop /* =@loop */:
	for {
		if true {
			break loop /* @loop */
		}
	}
	select {

			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)

)

// Apply replacements so that the test can be self-contained.
// (It's easier to see all of the modules here than to go
// rooting around in testdata/mod.)
replace (
	a => ./a
	b => ./b
	c => ./c
	x v0.1.0 => ./x1
	x v0.2.0 => ./x2
	i => ./i
)
-- main.go --
package main

import (
	_ "a"
	_ "b"
	_ "c"
)

func main() {}
-- a/go.mod --
module a
go 1.13
require x v0.1.0
-- a/a.go --

// 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:])