ADCQ   DX, SI

	// r0 += 19×a3×b2
	MOVQ   24(CX), AX
	IMUL3Q $0x13, AX, AX
	MULQ   16(BX)
	ADDQ   AX, DI
	ADCQ   DX, SI

	// r0 += 19×a4×b1
	MOVQ   32(CX), AX
	IMUL3Q $0x13, AX, AX
	MULQ   8(BX)
	ADDQ   AX, DI
	ADCQ   DX, SI

	// r1 = a0×b1
	MOVQ (CX), AX
	MULQ 8(BX)
	MOVQ AX, R9
	MOVQ DX, R8

	// r1 += a1×b0
	MOVQ 8(CX), AX
	MULQ (BX)
	ADDQ AX, R9
	ADCQ DX, R8

        def stream = new StdInStream(dispatch)
        def text = "some text"
        def bytes = text.bytes

        when:
        async {
            start {
                def b1 = stream.read()
                assert b1 == bytes[0]
                def b2 = stream.read()
                assert b2 == bytes[1]
            }
            thread.blockUntil.requested
            thread.block()

import javax.inject.Named;
import javax.inject.Singleton;

/**
 * Wagon for testing, for protocols <code>b1</code> and <code>b2</code>
 *
 */
@Named("b")
@Singleton
public class WagonB extends WagonMock {
    public String[] getSupportedProtocols() {
        return new String[] {"b1", "b2"};
    }

	z := f3 / 0.5

	return x, y, z
}

func indexLoad(b0 []float32, b1 float32, idx int) float32 {
	// arm64:`FMOVS\s\(R[0-9]+\)\(R[0-9]+<<2\),\sF[0-9]+`
	return b0[idx] * b1
}

func indexStore(b0 []float64, b1 float64, idx int) {
	// arm64:`FMOVD\sF[0-9]+,\s\(R[0-9]+\)\(R[0-9]+<<3\)`
	b0[idx] = b1
}

// ----------- //
//    Fused    //
// ----------- //

    @Ignore
    def "reports failure when included build directory is not the root directory of build"() {
        when:
        includedBuilds << buildB.file('b1')

        then:
        fails(buildA, "help")

        and:
        failure.assertHasDescription("Included build 'b1' must have a settings file.")
    }

    def "reports failure for duplicate included build name"() {
        given:

		for round := 0; round < 4; round++ {
			b0, b4, b8, b12 = qr(b0, b4, b8, b12)
			b1, b5, b9, b13 = qr(b1, b5, b9, b13)
			b2, b6, b10, b14 = qr(b2, b6, b10, b14)
			b3, b7, b11, b15 = qr(b3, b7, b11, b15)

			b0, b5, b10, b15 = qr(b0, b5, b10, b15)
			b1, b6, b11, b12 = qr(b1, b6, b11, b12)
			b2, b7, b8, b13 = qr(b2, b7, b8, b13)
			b3, b4, b9, b14 = qr(b3, b4, b9, b14)
		}

00000100  cb 3b 74                                          |.;t|
>>> Flow 2 (server to client)
00000000  16 03 03 00 7a 02 00 00  76 03 03 28 10 3b 44 b1  |....z...v..(.;D.|
00000010  0f a9 77 89 f9 dd 3c 3a  ad 83 a0 ca 3e 60 d6 0e  |..w...<:....>`..|
00000020  ab 94 3a ec 2e 63 ef b1  41 90 48 20 00 00 00 00  |..:..c..A.H ....|
00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|

	"istio.io/istio/pkg/config/analysis/diag"
)

func TestErrorOnIssuesFound(t *testing.T) {
	g := NewWithT(t)

	msgs := []diag.Message{
		diag.NewMessage(
			diag.NewMessageType(diag.Error, "B1", "Template: %q"),
			nil,
			"",
		),
		diag.NewMessage(
			diag.NewMessageType(diag.Warning, "A1", "Template: %q"),
			nil,
			"",
		),
	}

	err := errorIfMessagesExceedThreshold(msgs)

          rangesBuffer.writeByte(range.b1)
          rangesBuffer.writeByte('-'.code)
          rangesBuffer.writeByte('-'.code)
        }
        is MappedRange.Inline1 -> {
          rangesBuffer.writeByte(range.b1)
          rangesBuffer.writeByte(range.b2)
          rangesBuffer.writeByte('-'.code)
        }
        is MappedRange.Inline2 -> {
          rangesBuffer.writeByte(range.b1)
          rangesBuffer.writeByte(range.b2)

	b0.Event("GoStatus", trace.GoID(1), trace.ThreadID(0), go122.GoRunning)
	b0.Event("GoSyscallBegin", testgen.Seq(1), testgen.NoStack)
	b0.Event("GoSyscallEndBlocked")

	// A bare M steals the goroutine's P.
	b1 := g.Batch(trace.ThreadID(1), 0)
	b1.Event("ProcSteal", trace.ProcID(0), testgen.Seq(2), trace.ThreadID(0))