multiplyDistributesOverAdd := func(x, y, z Scalar) bool {
		// Compute t1 = (x+y)*z
		var t1 Scalar
		t1.Add(&x, &y)
		t1.Multiply(&t1, &z)

		// Compute t2 = x*z + y*z
		var t2 Scalar
		var t3 Scalar
		t2.Multiply(&x, &z)
		t3.Multiply(&y, &z)
		t2.Add(&t2, &t3)

		reprT1, reprT2 := t1.Bytes(), t2.Bytes()

		return t1 == t2 && isReduced(reprT1) && isReduced(reprT2)
	}

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.nativeplatform.fixtures.app;

public interface MultiplyElement {
    int multiply(int a, int b);

def TFL_ArithmeticCount : OpInterface<"TflArithmeticCountOpInterface"> {
  let description = [{
    Interface for TFLite ops to calculate arithmetic count (Multiply-Add Count).
  }];

  let methods = [
    StaticInterfaceMethod<
      [{Returns an integer representing the op's arithmetic count (Multiply-Add
      Count), return -1 if the arithmetic count cannot be determined.}],
       "int64_t", "GetArithmeticCount", (ins "Operation*":$op)
    >,

	}

	for name, f := range map[string]interface{}{
		"Negate": func(v, x Scalar) bool {
			return checkAliasingOneArg((*Scalar).Negate, v, x)
		},
		"Multiply": func(v, x, y Scalar) bool {
			return checkAliasingTwoArgs((*Scalar).Multiply, v, x, y)
		},
		"Add": func(v, x, y Scalar) bool {
			return checkAliasingTwoArgs((*Scalar).Add, v, x, y)
		},
		"Subtract": func(v, x, y Scalar) bool {

class SwiftAppWithXCTest extends MainWithXCTestSourceElement implements AppElement {
    final SwiftApp main = new SwiftApp()
    final XCTestSourceElement test = new SwiftAppTest(main, main.greeter, main.sum, main.multiply)

    String expectedOutput = main.expectedOutput

    SwiftAppWithXCTest() {
        super('app')
    }

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

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

// CHECK:         %[[SUB:.*]] = s32[] subtract(s32[] %[[CONVERT_1]],
// CHECK:         %[[CONVERT_2:.*]] = f32[] convert(s32[] %[[SUB]])
// CHECK:         %[[MUL:.*]] = f32[] multiply(f32[] %[[CONVERT_2]],

        super(projectName)
        main = new SwiftLibWithCppDep(projectName, cppGreeter)
        test = new SwiftLibTest(main, main.greeter, main.sum, main.multiply)
    }

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

	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