break
		}

		// Walk over attributes, counting.
		n := 0
		b1 := b // Read from copy of b.
		b1.uint()
		b1.uint8()
		for {
			tag := b1.uint()
			fmt := b1.uint()
			if tag == 0 && fmt == 0 {
				break
			}
			if format(fmt) == formImplicitConst {
				b1.int()
			}
			n++
		}
		if b1.err != nil {
			return nil, b1.err
		}

		// Walk over attributes again, this time writing them down.

func diff(m0, m1 image.Image) error {
	b0, b1 := m0.Bounds(), m1.Bounds()
	if !b0.Size().Eq(b1.Size()) {
		return fmt.Errorf("dimensions differ: %v vs %v", b0, b1)
	}
	dx := b1.Min.X - b0.Min.X
	dy := b1.Min.Y - b0.Min.Y
	for y := b0.Min.Y; y < b0.Max.Y; y++ {
		for x := b0.Min.X; x < b0.Max.X; x++ {
			c0 := m0.At(x, y)
			c1 := m1.At(x+dx, y+dy)
			r0, g0, b0, a0 := c0.RGBA()
			r1, g1, b1, a1 := c1.RGBA()

	MOVOU B0, (16*14)(dst)
	PSHUFD $78, B0, B1
	PXOR B0, B1
	MOVOU B1, (16*15)(dst)

	MOVOU B0, B2
	MOVOU B1, B3
	// Now prepare powers of H and pre-computations for them
	MOVQ $7, AX

initLoop:
		MOVOU B2, T0
		MOVOU B2, T1
		MOVOU B3, T2
		PCLMULQDQ $0x00, B0, T0
		PCLMULQDQ $0x11, B0, T1
		PCLMULQDQ $0x00, B1, T2

		PXOR T0, T2
		PXOR T1, T2
		MOVOU T2, B4

        def a1 = file("a/1.txt") << "a/1"
        def b1 = file("b/1.txt") << "b/1"
        def fileResolver = TestFiles.fileCollectionFactory(testDirectory)

        when:
        def a = fileResolver.resolving(["a"]).asFileTree
        def b = fileResolver.resolving(["b"]).asFileTree
        def composite = newCompositeFileTree([a, b])

        then:
        composite.files == [a1, b1].toSet()
    }

    def "can visit all files"() {

        createDirs("buildB", "buildB/buildSrc", "buildB/buildSrc/b1", "buildB/buildSrc/b2")
        buildB.file("buildSrc/settings.gradle") << """
            $settings
            include 'b1', 'b2'
        """
        buildB.file("buildSrc/build.gradle") << """
            allprojects { apply plugin: 'java' }
            dependencies { implementation project(':b1') }
            project(':b1') { dependencies { implementation project(':b2') } }

type T[P any] struct {
	_ P
}

type S /* ERROR "invalid recursive type" */ struct {
	_ T[S]
}

// simplified test 1

var _ A1[A1[string]]

type A1[P any] struct {
	_ B1[P]
}

type B1[P any] struct {
	_ P
}

// simplified test 2
var _ B2[A2]

type A2 struct {
	_ B2[string]
}

type B2[P any] struct {
	_ C2[P]
}

type C2[P any] struct {
	_ P
}

// license that can be found in the LICENSE file.

package ssa

import (
	"cmd/compile/internal/types"
	"strings"
	"testing"
)

func TestSCCPBasic(t *testing.T) {
	c := testConfig(t)
	fun := c.Fun("b1",
		Bloc("b1",
			Valu("mem", OpInitMem, types.TypeMem, 0, nil),
			Valu("v1", OpConst64, c.config.Types.Int64, 20, nil),
			Valu("v2", OpConst64, c.config.Types.Int64, 21, nil),

		fm.AddUnit("lit.go", "f3", true, u, 0)
	}

	var b1, b2, b3, b4 strings.Builder
	if err := fm.EmitTextual(&b1); err != nil {
		t.Fatalf("EmitTextual returned %v", err)
	}
	wantText := strings.TrimSpace(`
mode: atomic
p.go:10.0,11.0 2 0
p.go:15.0,11.0 1 1
q.go:20.0,25.0 3 0
q.go:30.0,31.0 2 1
q.go:33.0,40.0 7 2
lit.go:99.0,100.0 1 0`)
	gotText := strings.TrimSpace(b1.String())
	if wantText != gotText {

# if needed to process newly-reolved imports.

env TESTGO_VERSION=go1.21.0
env TESTGO_VERSION_SWITCH=switch

cp go.mod go.mod.orig

# tidy reports needing 1.22.0 for b1
env GOTOOLCHAIN=local
! go mod tidy
stderr '^go: example imports\n\texample.net/b: module ./b1 requires go >= 1.22.0 \(running go 1.21.0; GOTOOLCHAIN=local\)$'
env GOTOOLCHAIN=auto
go mod tidy

cmp stderr tidy-stderr.want
cmp go.mod go.mod.tidy

// Copyright 2022 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package p

// version 1
var x1 T1[B1]

type T1[_ any] struct{}
type A1 T1[B1]
type B1 = T1[A1]

// version 2
type T2[_ any] struct{}
type A2 T2[B2]
type B2 = T2[A2]