SwiftAppTest(SwiftSourceElement tested, GreeterElement greeter, SumElement sum, MultiplyElement multiply) {
        super(tested.projectName)
        greeterTest = new SwiftGreeterTest(greeter).withImport(tested.moduleName)
        sumTest = new SwiftSumTest(sum).withImport(tested.moduleName)
        multiplyTest = new SwiftMultiplyTest(multiply).withTestableImport(tested.moduleName)
    }

    final List<XCTestSourceFileElement> getTestSuites() {

    SwiftLibTest(SwiftSourceElement tested, GreeterElement greeter, SumElement sum, MultiplyElement multiply) {
        super(tested.projectName)
        sumTest = new SwiftSumTest(sum).withImport(tested.moduleName)
        greeterTest = new SwiftGreeterTest(greeter).withImport(tested.moduleName)
        multiplyTest = new SwiftMultiplyTest(multiply).withTestableImport(tested.moduleName)
    }

    List<XCTestSourceFileElement> getTestSuites() {

	// Second number is 0<<32 + 12
	n2 := []uint32{0, 12}
	// Multiply them together without producing overflow.
	hi, lo := bits.Mul32(n1[1], n2[1])
	nsum := []uint32{hi, lo}
	fmt.Printf("%v * %v = %v\n", n1[1], n2[1], nsum)

	// First number is 0<<32 + 2147483648
	n1 = []uint32{0, 0x80000000}
	// Second number is 0<<32 + 2
	n2 = []uint32{0, 2}
	// Multiply them together producing overflow.
	hi, lo = bits.Mul32(n1[1], n2[1])

class SwiftApp extends SwiftSourceElement implements AppElement {
    final greeter = new SwiftGreeter()
    final sum = new SwiftSum()
    final multiply = new SwiftMultiply()
    final main = new SwiftMain(greeter, sum)
    List<SourceFile> files = [main.sourceFile, greeter.sourceFile, sum.sourceFile, multiply.sourceFile]

    SwiftApp() {
        super('app')
    }

    @Override
    String getExpectedOutput() {

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

		// Compute t2 = x*z + y*z
		t2 := new(Element)
		t3 := new(Element)
		t2.Multiply(&x, &z)
		t3.Multiply(&y, &z)
		t2.Add(t2, t3)

		return t1.Equal(t2) == 1 && isInBounds(t1) && isInBounds(t2)
	}

func NewScalar() *Scalar {
	return &Scalar{}
}

// MultiplyAdd sets s = x * y + z mod l, and returns s. It is equivalent to
// using Multiply and then Add.
func (s *Scalar) MultiplyAdd(x, y, z *Scalar) *Scalar {
	// Make a copy of z in case it aliases s.
	zCopy := new(Scalar).Set(z)
	return s.Multiply(x, y).Add(s, zCopy)
}

// Add sets s = x + y mod l, and returns s.
func (s *Scalar) Add(x, y *Scalar) *Scalar {
	// s = 1 * x + y mod l

  CreateModule(kNonStaticWithBoundsSuccess);

  auto result = Run();

  EXPECT_TRUE(result.succeeded());
  EXPECT_EQ(legal_error.Delta("mhlo.multiply"), 0);
  EXPECT_EQ(static_error.Delta("mhlo.multiply"), 0);
}

TEST_F(VerifyTfxlaLegalizationTest, RecordsMultipleFailures) {
  // Using a string constant here instead of testdata to make this compatible
  // with open source.

TEXT time·now(SB),NOSPLIT,$0-20
	MOVW	$_INTERRUPT_TIME, R3
loop:
	MOVW	time_hi1(R3), R1
	DMB	MB_ISH
	MOVW	time_lo(R3), R0
	DMB	MB_ISH
	MOVW	time_hi2(R3), R2
	CMP	R1, R2
	BNE	loop

	// wintime = R1:R0, multiply by 100
	MOVW	$100, R2
	MULLU	R0, R2, (R4, R3)    // R4:R3 = R1:R0 * R2
	MULA	R1, R2, R4, R4

	// wintime*100 = R4:R3
	MOVW	R3, mono+12(FP)
	MOVW	R4, mono+16(FP)

	MOVW	$_SYSTEM_TIME, R3
wall:

  %2 = stablehlo.divide %arg0, %0 : tensor<2xf32>
  return %2 : tensor<2xf32>
}

// CHECK-LABEL: divideToMulReciprocalSplat
// CHECK: stablehlo.constant dense<5.000000e-01> : tensor<2xf32>
// CHECK: stablehlo.multiply

// -----

func.func @divideToMulReciprocal(%arg0: tensor<2xf32>) -> tensor<2xf32> {
  %0 = stablehlo.constant dense<[2.0, 3.0]> : tensor<2xf32>
  %2 = stablehlo.divide %arg0, %0 : tensor<2xf32>

initscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath 'org.apache.commons:commons-math:2.0'
    }
}
// end::declare-classpath[]

println Fraction.ONE_FIFTH.multiply(2)