A. Unique TensorFlower <******@****.***> 1677804438 -0800

#ifdef _WIN32
#define EXPORT_FUNC __declspec(dllexport)
#else
#define EXPORT_FUNC
#endif

class Multiply {
public:
    int EXPORT_FUNC multiply(int a, int b);
};
"""))

    final SourceFileElement source = ofFile(new SourceFile("cpp", "multiply.cpp", """
#include "multiply.h"

int Multiply::multiply(int a, int b) {
    return a * b;
}
"""))

        return [greeter.sourceFile, sum.sourceFile, multiply.sourceFile]
    }

    @Override
    String getExpectedOutput() {
        return greeter.expectedOutput
    }

    @Override
    int sum(int a, int b) {
        return sum.sum(a, b)
    }

    @Override
    int multiply(int a, int b) {
        return multiply.multiply(a, b)
    }

		x2.Add(&x2, &z2)
		z2.Add(&x3, &z3)
		z3.Multiply(&tmp0, &x2)
		z2.Multiply(&z2, &tmp1)
		tmp0.Square(&tmp1)
		tmp1.Square(&x2)
		x3.Add(&z3, &z2)
		z2.Subtract(&z3, &z2)
		x2.Multiply(&tmp1, &tmp0)
		tmp1.Subtract(&tmp1, &tmp0)
		z2.Square(&z2)

		z3.Mult32(&tmp1, 121666)
		x3.Square(&x3)
		tmp0.Add(&tmp0, &z3)
		z3.Multiply(&x1, &z2)
		z2.Multiply(&tmp1, &tmp0)
	}

	x2.Swap(&x3, swap)

    }

    @Override
    int sum(int a, int b) {
        return sum.sum(a, b)
    }

    @Override
    int multiply(int a, int b) {
        return multiply.multiply(a, b)
    }

    final SwiftSourceElement main = app.application
    final SwiftSum sum = new SwiftSum()
    final SwiftMultiply multiply = new SwiftMultiply()
    final XCTestSourceElement test = new SwiftAppTest(main, app.greeter, sum, multiply)

    String expectedOutput = main.expectedOutput

    SwiftAppWithLibrariesAndXCTest() {
        super('app')
    }

    SourceElement getGreeter() {

    @Override
    SourceFile getSourceFile() {
        sourceFile("swift", "multiply.swift", """
             internal func multiply(a: Int, b: Int) -> Int {
                return a * b
             }
         """)
    }

    @Override
    int multiply(int a, int b) {
        return a * b
    }

  %0 = "mhlo.broadcast_in_dim"(%cst0) <{broadcast_dimensions = dense<3> : tensor<1xi64>}> : (tensor<4xi32>) -> tensor<1x1x2x4xi32>
  // CHECK: %[[MUL:.*]] = mhlo.multiply %[[BROADCAST]], %[[ARG]] : tensor<1x1x2x4xi32>
  %1 = mhlo.multiply %0, %arg0 : tensor<1x1x2x4xi32>
  // CHECK:      return %[[MUL]] : tensor<1x1x2x4xi32>
  func.return %1 : tensor<1x1x2x4xi32>

package mult

var sink int

type Multiplier interface {
	Multiply(a, b int) int
}

type Mult struct{}

func (Mult) Multiply(a, b int) int {
	for i := 0; i < 1000; i++ {
		sink++
	}
	return a * b
}

type NegMult struct{}

func (NegMult) Multiply(a, b int) int {
	for i := 0; i < 1000; i++ {
		sink++
	}
	return -1 * a * b
}

    final greeter = new CppGreeter()
    final sum = new CppSum()
    final multiply = new CppMultiply()

    final List<IncrementalElement.Transform> incrementalChanges = [
        preserve(greeter),
        rename(sum),
        delete(multiply)
    ]