sinkBuffer.writeByte(b0)

    var b1 = 0
    if (isClient) {
      b1 = b1 or B1_FLAG_MASK
    }
    when {
      dataSize <= PAYLOAD_BYTE_MAX -> {
        b1 = b1 or dataSize.toInt()
        sinkBuffer.writeByte(b1)
      }
      dataSize <= PAYLOAD_SHORT_MAX -> {
        b1 = b1 or PAYLOAD_SHORT
        sinkBuffer.writeByte(b1)
        sinkBuffer.writeShort(dataSize.toInt())
      }

  {
    GraphDefBuilder b1(GraphDefBuilder::kFailImmediately);
    Node* a = Input(b1.opts().WithName("A"));
    Node* b = Input(b1.opts().WithName("B"));
    Node* c = Unary(a, b1.opts().WithName("C").WithAttr("_encapsulate", "F1"));
    Node* d =
        Binary(b, c, b1.opts().WithName("D").WithAttr("_encapsulate", "F1"));
    Node* e = Binary(c, d,
                     b1.opts()
                         .WithName("E")

                private static final Class<B1> bClass = B1.class;
                private static final B1 b1 = new B1();
                private static final B1 b2;
                static {
                    b2 = new B1();
                }
                private static B1 b3 = new B1();
                private B1 b4 = new B1();
                private B1 m1(B1 b) { return new B1(); };

	// but in reverse order.
	b1 := block & 0xaaaaaaaa55555555
	block ^= b1 ^ b1>>33 ^ b1<<33

	b1 = block & 0x3300330033003300
	b2 := block & 0x00cc00cc00cc00cc
	block ^= b1 ^ b2 ^ b1>>6 ^ b2<<6

	b1 = block & 0x0f0f00000f0f0000
	b2 = block & 0x0000f0f00000f0f0
	block ^= b1 ^ b2 ^ b1>>12 ^ b2<<12

	b1 = block >> 32 & 0xff00ff
	b2 = (block & 0xff00ff00)

	ps1 = ps  // ERROR "cannot use|incompatible"


	a0 = [10]int(a)
	a0 = [10]int(a1)
	a = A(a0)
	a = A(a1)
	a1 = A1(a0)
	a1 = A1(a)

	b0 = []int(b)
	b0 = []int(b1)
	b = B(b0)
	b = B(b1)
	b1 = B1(b0)
	b1 = B1(b)

	c0 = chan int(c)
	c0 = chan int(c1)
	c = C(c0)
	c = C(c1)
	c1 = C1(c0)
	c1 = C1(c)

	f0 = func() int(f)
	f0 = func() int(f1)
	f = F(f0)
	f = F(f1)

name: req1
A: B1 C1 D1 E1 F1
B1: C1 E1 F1
req A:   B1    D1
req A C: B1 C1 D1

name: req2
A: G1 H1
G1: H1
H1: G1
req A:   G1
req A G: G1
req A H: H1

name: req3
M: A1 B1
A1: X1
B1: X2
X1: I1
X2:
req M: A1 B1

name: reqnone
M: Anone B1 D1 E1
B1: Cnone D1
E1: Fnone
build M: M B1 D1 E1
req M:     B1    E1

name: reqdup

type A2[T any] interface {
	m2(T)
}

type B1[T any] struct {
	filler int
	*A1[T]
	A2[T]
}

type B2[T any] interface {
	A2[T]
}

type C[T any] struct {
	filler1 int
	filler2 int
	B1[T]
}

type D[T any] struct {
	filler1 int
	filler2 int
	filler3 int
	C[T]
}

func _() {
	// calling embedded methods
	var b1 B1[string]

	b1.A1.m1("")
	b1.m1("")

	b1.A2.m2("")

	}
}

func TestConversion(t *testing.T) {
	b1 := NewFileBase("b1", "b1")
	b2 := NewFileBase("b2", "b2")
	b3 := NewLinePragmaBase(MakePos(b1, 10, 0), "b3", "b3", 123, 0)

	var tab PosTable
	for _, want := range []Pos{
		NoPos,
		MakePos(nil, 0, 0), // same table entry as NoPos
		MakePos(b1, 0, 0),
		MakePos(nil, 10, 20), // same table entry as NoPos
		MakePos(b2, 10, 20),

	// calling embedded methods
	var b1 B1[T]
	b1.A1 = &A1[T]{}
	b1.A2 = &ImpA2[T]{}

	b1.A1.m1(arg)
	b1.m1(arg)

	b1.A2.m2(arg)
	b1.m2(arg)

	var b2 B2[T]
	b2 = &ImpA2[T]{}
	b2.m2(arg)

	// a deeper nesting
	var d D[T]
	d.C.B1.A1 = &A1[T]{}
	d.C.B1.A2 = &ImpA2[T]{}
	d.m1(arg)
	d.m2(arg)

	// calling method expressions
	m1x := B1[T].m1
	m1x(b1, arg)
	// TODO(khr): reenable these.

/*
import "fmt"

type MyStruct struct {
	b1, b2 string
	E
}

type E struct {
	val int
}

type C interface {
	~struct {
		b1, b2 string
		E
	}
}

func f[T C]() T {
	var x T = T{
		b1: "a",
		b2: "b",
	}

	if got, want := x.b2, "b"; got != want {
		panic(fmt.Sprintf("got %d, want %d", got, want))
	}
	x.b1 = "y"
	x.val = 5

	return x
}

func main() {