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.

	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') } }

// 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),

        buildB.buildFile << """
            dependencies { implementation project(':b1') }
        """

        when:
        execute(buildA, ":dependencies")

        then:
        outputContains("""
runtimeClasspath - Runtime classpath of source set 'main'.
\\--- org.test:${dependencyName}:1.0 -> project :${buildName}
     \\--- project :${buildName}:b1
""")

        where:

replace (
	example.net/a v0.1.0 => ./a
	example.net/b v0.1.0 => ./b1
	example.net/b v0.2.0 => ./b2
	example.net/c v0.1.0 => ./c1
	example.net/c v0.2.0 => ./c2
	example.net/d v0.1.0 => ./d
)

require (
	example.net/b v0.1.0
)
-- a/go.mod --
module example.net/a

go 1.18

require example.net/b v0.2.0
-- a/a.go --
package a

import _ "example.net/b"
-- b1/go.mod --
module example.net/b

go 1.16

}

func TestBlockGeneric(t *testing.T) {
	var b1, b2 [32]uint64
	s := seed // byte seed
	seed := [4]uint64{
		binary.LittleEndian.Uint64(s[0*8:]),
		binary.LittleEndian.Uint64(s[1*8:]),
		binary.LittleEndian.Uint64(s[2*8:]),
		binary.LittleEndian.Uint64(s[3*8:]),
	}

	Block(&seed, &b1, 4)
	Block_generic(&seed, &b2, 4)
	if !slices.Equal(b1[:], b2[:]) {
		var out bytes.Buffer

	addMul64(r0, 19, a4, b1)

	// r1 = a0×b1 + a1×b0 + 19×(a2×b4 + a3×b3 + a4×b2)
	r1 := uint128{"r1", GP64(), GP64()}
	mul64(r1, 1, a0, b1)
	addMul64(r1, 1, a1, b0)
	addMul64(r1, 19, a2, b4)
	addMul64(r1, 19, a3, b3)
	addMul64(r1, 19, a4, b2)

	// r2 = a0×b2 + a1×b1 + a2×b0 + 19×(a3×b4 + a4×b3)
	r2 := uint128{"r2", GP64(), GP64()}
	mul64(r2, 1, a0, b2)
	addMul64(r2, 1, a1, b1)
	addMul64(r2, 1, a2, b0)

// Copyright 2019 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

func hashBytesRaw(b0, b1, b2, b3, b7 byte) uint64 {
	return (uint64(b0) | uint64(b1)<<8 | uint64(b2)<<16 | uint64(b3)<<24)
}

func doStuff(data []byte) uint64 {
	return hashBytesRaw(data[0], data[1], data[2], data[3], data[7])