//   ⎡x / c⎤ = ⎣x * m / 2^(n+s)⎦ + 1
// (TODO: derivation?)
//
// The multiply is a bit odd, as it is a signed n-bit value
// times an unsigned n-bit value.  For n smaller than the
// word size, we can extend x and m appropriately and use the
// signed multiply instruction.  For n == word size,
// we must use the signed multiply high and correct
// the result by adding x*2^n.
//

	// This does not seem worthwhile, at least for Go: not having any high
	// bits in the multiplier reduces the effect of low bits on the highest bits,
	// and it only saves 1 multiply out of 3.
	// (On 32-bit systems, it saves 1 out of 6, since Mul64 is doing 4.)
	const (
		mulHi = 2549297995355413924
		mulLo = 4865540595714422341
		incHi = 6364136223846793005
		incLo = 1442695040888963407
	)

    %16 = stablehlo.subtract %10, %15 : tensor<1x3x3x4xf32>
    %17 = stablehlo.broadcast_in_dim %4, dims = [0, 1, 2, 3] : (tensor<1x1x1x4xf32>) -> tensor<1x3x3x4xf32>
    %18 = stablehlo.multiply %16, %17 : tensor<1x3x3x4xf32>
    %19 = call @uniform_quantize_1(%18, %5, %6) : (tensor<1x3x3x4xf32>, tensor<1x1x1x1xf32>, tensor<1x1x1x1xi8>) -> tensor<1x3x3x4xi8>

	MOVD 16(R3), R10 // h2
	MOVD 24(R3), R11 // r0
	MOVD 32(R3), R12 // r1

	CMP R5, $16
	BLT bytes_between_0_and_15

loop:
	POLY1305_ADD(R4, R8, R9, R10, R20, R21, R22)

	PCALIGN $16
multiply:
	POLY1305_MUL(R8, R9, R10, R11, R12, R16, R17, R18, R14, R20, R21)
	ADD $-16, R5
	CMP R5, $16
	BGE loop

bytes_between_0_and_15:
	CMP  R5, $0
	BEQ  done
	MOVD $0, R16 // h0
	MOVD $0, R17 // h1

	HasAVX512IFMA       bool // Advanced vector extension 512 Integer Fused Multiply Add
	HasAVX512VBMI       bool // Advanced vector extension 512 Vector Byte Manipulation Instructions
	HasAVX5124VNNIW     bool // Advanced vector extension 512 Vector Neural Network Instructions Word variable precision
	HasAVX5124FMAPS     bool // Advanced vector extension 512 Fused Multiply Accumulation Packed Single precision

		{name: "Pow22523", oneArgF: (*Element).Pow22523},
		{
			name: "Mult32",
			oneArgF: func(v, x *Element) *Element {
				return v.Mult32(x, 0xffffffff)
			},
		},
		{name: "Multiply", twoArgsF: (*Element).Multiply},
		{name: "Add", twoArgsF: (*Element).Add},
		{name: "Subtract", twoArgsF: (*Element).Subtract},
		{
			name: "SqrtRatio",
			twoArgsF: func(v, x, y *Element) *Element {

			t.Fatalf("error copying %s: %v", file, err)
		}
	}

	want := []devirtualization{
		// ExerciseIface
		{
			pos:    "./devirt.go:101:20",
			callee: "mult.Mult.Multiply",
		},
		{
			pos:    "./devirt.go:101:39",
			callee: "Add.Add",
		},
		// ExerciseFuncConcrete
		{
			pos:    "./devirt.go:173:36",
			callee: "AddFn",
		},
		{

        this("greeter")
    }

    SwiftLibWithXCTest(String projectName) {
        super(projectName)
        main = new SwiftLib(projectName)
        test = new SwiftLibTest(main, main.greeter, main.sum, main.multiply)
    }

                        Multiplier multiplier = new Multiplier();
                        Assert.assertEquals(1, multiplier.multiply(1, 1));
                        Assert.assertEquals(4, multiplier.multiply(2, 2));
                        Assert.assertEquals(2, multiplier.multiply(1, 2));
                    }
                }
            """
            file("transitive/build.gradle") << """

        List<XCTestSourceFileElement> getTestSuites() {
            return [
                new XCTestSourceFileElement("CombinedTests") {
                    final delegate = new SwiftLibTest(main, main.greeter, main.sum, main.multiply)

                    @Override
                    List<XCTestCaseElement> getTestCases() {
                        return delegate.sumTest.testCases + delegate.greeterTest.testCases + delegate.multiplyTest.testCases