//         })
	// }
	//
	// In the example above, non-parallel parents T1 and T2 contain parallel children T1a, T1b, T2a, T2b.
	//
	// Since both T1 and T2 are non-parallel, they are run synchronously: T1 followed by T2. After T1 exits,
	// T1a and T1b are run asynchronously with each other. After T1a and T1b complete, T2 is then run in the
	// same way: T2 exits, then T2a and T2b are run asynchronously to completion.

var ax [10]int
var a0 = [10]int{0, 0, 0}
var a1 = [10]int{1, 2, 3, 4}

type T struct{ X, Y int }

var tx T
var t0 = T{}
var t0a = T{0, 0}
var t0b = T{X: 0}
var t1 = T{X: 1, Y: 2}
var t1a = T{3, 4}

var psx *[]int
var ps0 = &[]int{0, 0, 0}
var ps1 = &[]int{1, 2, 3}

var pax *[10]int
var pa0 = &[10]int{0, 0, 0}
var pa1 = &[10]int{1, 2, 3}

var ptx *T
var pt0 = &T{}

                })
        })
}
```

In the example above, non-parallel parents T1 and T2 contain parallel children T1a, T1b, T2a, T2b.

Since both T1 and T2 are non-parallel, they are run synchronously: T1 followed by T2. After T1 exits,
T1a and T1b are run asynchronously with each other. After T1a and T1b complete, T2 is then run in the
same way: T2 exits, then T2a and T2b are run asynchronously to completion.

	// and their actual names don't come into play here.
	x1.f = x2.f
}

// We can verify this behavior using type aliases instead:
type T1a struct {
	f A1
}
type A1 = struct { g int }

type T2a struct {
	f struct {
		g A2
	}
}
type A2 = int

var x1a T1a
var x2a T2a

func _() {
	x1a = x2a // ERROR "assignment"
	x1a.f = x2a.f
}

YI�z$F�'M"�L�Ĥ�� � ږC�*�)�ĉY�1��K4�{��9H�Ѡ�J�(%%q��(#hAR�
Ŕ(1J(F�RUI�����ݒ��hR�&/�7���f�R�m�@�F�`�D-騉S)E��m�Bx�� ����e{�͇���`����k��l�����ʪ6B�?��ð:��T|��p2���Xy�>�2�T;���n`�Պ�I�,˲6X^�q^����b�Q�X� )'�����(S-�͵���`m9��H�DkɁ��x�'�t1a���0�&�b����j����D�%R�EJlJ.�hn8�à[��ʶ�|2[�t��,�2����(ϜnxKα�wl��d�� 괦�U9�j����ҤKC�7y�x�D��2}�M__x��ϡ��r�P[�"g��I�X%+�)�4�����b�$�1D�ь"J�%#Q��$�o=��ē&J&BbRMA�^i�!K��q��,ᘉR�%�=� ȫ�� ��){^}���v��)i�VVeU !����a�-9�]|��p2��qPy�>�2�T;�...