(Rsh8x(64|32|16|8)  <t> x y) && !shiftIsBounded(v) => (SARB <t> x (OR(Q|L|L|L) <y.Type> y (NOT(Q|L|L|L) <y.Type> (SBB(Q|L|L|L)carrymask <y.Type> (CMP(Q|L|W|B)const y [8])))))

(Rsh64x(64|32|16|8) x y) && shiftIsBounded(v) => (SARQ x y)
(Rsh32x(64|32|16|8) x y) && shiftIsBounded(v) => (SARL x y)
(Rsh16x(64|32|16|8) x y) && shiftIsBounded(v) => (SARW x y)

	// Interpretation of trace:
	//   x ≡ y    attempt to unify types x and y
	//   p ➞ y    type parameter p is set to type y (p is inferred to be y)
	//   p ⇄ q    type parameters p and q match (p is inferred to be q and vice versa)
	//   x ≢ y    types x and y cannot be unified
	//   [p, q, ...] ➞ [x, y, ...]    mapping from type parameters to types
	traceInference = false
)

23:		x := id(0)
24:		y := id(0)
25:		fmt.Println(x)
26:		for i := x; i < 3; i++ {
27:			x := i * i
28:			y += id(x) //gdb-dbg=(x,y)//gdb-opt=(x,y)
26:		for i := x; i < 3; i++ {
27:			x := i * i
28:			y += id(x) //gdb-dbg=(x,y)//gdb-opt=(x,y)
26:		for i := x; i < 3; i++ {
27:			x := i * i
28:			y += id(x) //gdb-dbg=(x,y)//gdb-opt=(x,y)
26:		for i := x; i < 3; i++ {
31:		fmt.Println(x, y)

		// establishing that x[start.x:end.x] == y[start.y:end.y].
		// Note that on the first (or last) iteration we may (or definitely do)
		// have an empty match: start.x==end.x and start.y==end.y.
		start := m
		for start.x > done.x && start.y > done.y && x[start.x-1] == y[start.y-1] {
			start.x--
			start.y--
		}
		end := m
		for end.x < len(x) && end.y < len(y) && x[end.x] == y[end.y] {
			end.x++
			end.y++
		}

		y = g(y, z, x)
	} else {
		y++
	}
	if y == x { // ERROR "Branch prediction rule default < call"
		y = g(y, z, x)
	} else {
	}
	if y == 2 { // ERROR "Branch prediction rule default < call"
		z++
	} else {
		y = g(z, x, y)
	}
	if y+z == 3 { // ERROR "Branch prediction rule call < exit"
		println("ha ha")
	} else {
		panic("help help help")
	}
	if x != 0 { // ERROR "Branch prediction rule default < ret"

(Div64 x y) => (DIVV x y)
(Div64u ...) => (DIVVU ...)
(Div32 x y) => (DIVV (SignExt32to64 x) (SignExt32to64 y))
(Div32u x y) => (DIVVU (ZeroExt32to64 x) (ZeroExt32to64 y))
(Div16 x y) => (DIVV (SignExt16to64 x) (SignExt16to64 y))
(Div16u x y) => (DIVVU (ZeroExt16to64 x) (ZeroExt16to64 y))
(Div8 x y) => (DIVV (SignExt8to64 x) (SignExt8to64 y))
(Div8u x y) => (DIVVU (ZeroExt8to64 x) (ZeroExt8to64 y))
(Div(32|64)F ...) => (DIV(F|D) ...)

//line foo/bar.y:204
//line foo/bar.y:208
//line foo/bar.y:211
//line foo/bar.y:213
//line foo/bar.y:215
//line foo/bar.y:217
//line foo/bar.y:221
//line foo/bar.y:229
//line foo/bar.y:236
//line foo/bar.y:238
//line foo/bar.y:240
//line foo/bar.y:244
//line foo/bar.y:249
//line foo/bar.y:253
//line foo/bar.y:257
//line foo/bar.y:262
//line foo/bar.y:267
//line foo/bar.y:272
	if l == f {
//line foo/bar.y:277

	*x = *y // ERROR "write barrier"

	z := *y // no barrier
	*x = z  // ERROR "write barrier"
}

func f4(x *[2]string, y [2]string) {
	*x = y // ERROR "write barrier"

	z := y // no barrier
	*x = z // ERROR "write barrier"
}

func f4a(x *[2]string, y *[2]string) {
	*x = *y // ERROR "write barrier"

	z := *y // no barrier
	*x = z  // ERROR "write barrier"
}

type T struct {
	X *int
	Y int

		}{1, "hi"}
		var y = struct {
			x int
			y string
		}{2, "bye"}
		var z = struct {
			x int
			y string
		}{1, "hi"}

		isfalse(x == y)
		isfalse(y == x)
		isfalse(y == z)
		isfalse(z == y)
		istrue(x == z)
		istrue(z == x)

		istrue(x != y)
		istrue(y != x)
		istrue(y != z)
		istrue(z != y)
		isfalse(x != z)
		isfalse(z != x)

		var m = make(map[struct {

	a, b, c := 1, 4, 16
	x := F(&a, &b, &c)
	fmt.Printf("x = %d\n", x)

	y := H("Hello", "World!")
	fmt.Println("len(y) =", len(y))
	fmt.Println("y =", y)
	z := H("Hello", "Pal!")
	fmt.Println("len(z) =", len(z))
	fmt.Println("z =", z)

	fmt.Println()

	y = K("Hello", "World!")
	fmt.Println("len(y) =", len(y))
	fmt.Println("y =", y)
	z = K("Hello", "Pal!")
	fmt.Println("len(z) =", len(z))
	fmt.Println("z =", z)