ppanic("x() != 1")
		}
	}

	{
		if y := func(x int) int { // ERROR "can inline main.func3"
			return x + 2
		}(40); y != 42 { // ERROR "inlining call to main.func3"
			ppanic("y != 42")
		}
		if y := func(x int) int { // ERROR "can inline main.func4" "func literal does not escape"
			return x + 2
		}; y(40) != 42 { // ERROR "inlining call to main.func4"
			ppanic("y(40) != 42")
		}
	}

	{

	type X struct {
		y int64
		Empty
	}
	type Y struct {
		x X
		y int64
	}
	c := make(chan X)
	var y Y
	go func() {
		x := y.x
		c <- x
	}()
	y.y = 42
	<-c
}

func TestRaceNestedStruct(t *testing.T) {
	type X struct {
		x, y int
	}
	type Y struct {
		x X
	}
	c := make(chan Y)
	var y Y
	go func() {
		c <- y

	// For all blocks x and y, one of the following holds:
	//
	// (x-dom-y) x dominates y => entry(x) < entry(y) < exit(y) < exit(x)
	// (y-dom-x) y dominates x => entry(y) < entry(x) < exit(x) < exit(y)
	// (x-then-y) neither x nor y dominates the other and x walked before y => entry(x) < exit(x) < entry(y) < exit(y)
	// (y-then-x) neither x nor y dominates the other and y walked before y => entry(y) < exit(y) < entry(x) < exit(x)
	//

�
�
�
�
�
�
�
�
�
�
�
�
�
 �
!�
"�
#�
$�
%�
&�
'�
(�
)�
*�
+�
,�
-�
.�
/�
0�
1�
2�
3�
4�
5�
6�
7�
8�
9�
:�
;�
<�
=�
>�
?�
@�
A�
B�
C�
D�
E�
F�
G�
H�
I�
J�
K�
L�
M�
N�
O�
P�
Q�
R�
S�
T�
U�
V�
W�
X�
Y�
Z�
[�
\�
]�
^�
_�
`�
a�
b�
c�
d�
e�
f�
g�
h�
i�
j�
k�
l�
m�
n�
o�
p�
q�
r�
s�
t�
u�
v�
w�
x�
y�
z�
{�
|�
}�
~�
�
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��...

	two[31] = 2

	// 0×G + 0×G = ∞
	x, y := p256.CombinedMult(gx, gy, zero, zero)
	if x.Sign() != 0 || y.Sign() != 0 {
		t.Errorf("0×G + 0×G = (%d, %d), should be ∞", x, y)
	}

	// 1×G + 0×G = G
	x, y = p256.CombinedMult(gx, gy, one, zero)
	if x.Cmp(gx) != 0 || y.Cmp(gy) != 0 {
		t.Errorf("1×G + 0×G = (%d, %d), should be (%d, %d)", x, y, gx, gy)
	}

	// 0×G + 1×G = G
	x, y = p256.CombinedMult(gx, gy, zero, one)

	y = -1
	r = x + y
	if r != -1 {
		t.Errorf("0 %s -1 = %d, want -1", "+", r)
	}
	y = 0
	r = x + y
	if r != 0 {
		t.Errorf("0 %s 0 = %d, want 0", "+", r)
	}
	y = 1
	r = x + y
	if r != 1 {
		t.Errorf("0 %s 1 = %d, want 1", "+", r)
	}
	y = 4294967296
	r = x + y
	if r != 4294967296 {
		t.Errorf("0 %s 4294967296 = %d, want 4294967296", "+", r)
	}
	y = 9223372036854775806
	r = x + y

(SUB x (SLLconst [c] y)) => (SUBshiftLL x y [c])
(SUB (SLLconst [c] y) x) => (RSBshiftLL x y [c])
(SUB x (SRLconst [c] y)) => (SUBshiftRL x y [c])
(SUB (SRLconst [c] y) x) => (RSBshiftRL x y [c])
(SUB x (SRAconst [c] y)) => (SUBshiftRA x y [c])
(SUB (SRAconst [c] y) x) => (RSBshiftRA x y [c])
(SUB x (SLL y z)) => (SUBshiftLLreg x y z)
(SUB (SLL y z) x) => (RSBshiftLLreg x y z)
(SUB x (SRL y z)) => (SUBshiftRLreg x y z)

func fmin[F floaty](x, y F) F {
	if y != y || y < x {
		return y
	}
	if x != x || x < y || x != 0 {
		return x
	}
	// x and y are both ±0
	// if either is -0, return -0; else return +0
	return forbits(x, y)
}

func fmax[F floaty](x, y F) F {
	if y != y || y > x {
		return y
	}
	if x != x || x > y || x != 0 {
		return x
	}
	// x and y are both ±0

	if y == 0 {
		divzerouint64(x, y)
		modzerouint64(x, y)
		return
	}
	q, r := udiv(x, y)
	q1 := x/y
	r1 := x%y
	if q1 != q {
		print("uint64(", x, "/", y, ") = ", q1, ", want ", q, "\n")
	}
	if r1 != r {
		print("uint64(", x, "%", y, ") = ", r1, ", want ", r, "\n")
	}
}

func checkuint32(x, y uint32) {
	if y == 0 {
		divzerouint32(x, y)
		modzerouint32(x, y)

		{"(y&x)&x", func(x, y int8) int8 { return (y & x) & x }, and},
		{"x^(x^y)", func(x, y int8) int8 { return x ^ (x ^ y) }, y},
		{"x^(y^x)", func(x, y int8) int8 { return x ^ (y ^ x) }, y},
		{"(x^y)^x", func(x, y int8) int8 { return (x ^ y) ^ x }, y},
		{"(y^x)^x", func(x, y int8) int8 { return (y ^ x) ^ x }, y},
		{"-(y-x)", func(x, y int8) int8 { return -(y - x) }, func(x, y int8) int8 { return x - y }},