// CHECK-NEXT:    %0 = stablehlo.custom_call @Sharding(%arg0) {mhlo.sharding = ""} : (tensor<2x3xi32>) -> tensor<2x3xi32>
// CHECK-NEXT:    %1 = stablehlo.multiply %0, %0 : tensor<2x3xi32>
// CHECK-NEXT:    return %1 : tensor<2x3xi32>
// CHECK-NEXT:  }

#include "mlir/Transforms/DialectConversion.h"  // from @llvm-project

namespace mlir {
namespace odml {
// Converts mhlo.dot_general to tfl.BatchMatMul. Reshape and Transpose ops will
// be inserted to convert to well-formed matrix multiply; i.e., mhlo.dot_general
// -> tfl.batch_matmul(mhlo.transpose(mhlo.reshape(operand)), ...).
// Note:
// 1) Reshape/transpose are inserted because tfl.BatchMatMul requires

    def "adds source dependencies Swift module of test component to Xcode indexer search path"() {
        def library = new SwiftLib()
        def test = new SwiftLibTest(library, library.greeter, library.sum, library.multiply)

        given:
        buildTestFixture.withBuildInSubDir()
        singleProjectBuild("greeter") {
            buildFile << """
                apply plugin: 'swift-library'
            """

  // CHECK: %[[INPUT1:.*]] = "tf.Placeholder.input"
  %1 = "tf.Placeholder.input"(%arg1) : (tensor<f32>) -> tensor<f32>
  %2 = arith.constant dense<true> : tensor<i1>

  // CHECK: "tf.Multiply"(%[[INPUT1]], %[[INPUT0]])
  %3 = "tf.If"(%2, %0, %1) {else_branch = @sub, then_branch = @addormul, is_stateless = true} : (tensor<i1>, tensor<f32>, tensor<f32>) -> tensor<f32>
  func.return %3 : tensor<f32>
}

  // expected-error @+1 {{Node `mhlo.dynamic_iota` must have compile-time constant}}
  %3 = "mhlo.dynamic_iota"(%2) <{iota_dimension = 0 : i64}> : (tensor<1xi64>) -> tensor<?xi32>
  %4 = mhlo.multiply %3, %3 : tensor<?xi32>
  return %4 : tensor<?xi32>

        if (flakinessRate == null || baseDuration == null) {
            return baseDuration;
        }
        return baseDuration + flakinessRate.multiply(BigDecimal.valueOf(baseDuration)).longValue();
    }

        BigDecimal runTests = BigDecimal.valueOf(getRunTestCount());
        BigDecimal successful = BigDecimal.valueOf(getRunTestCount() - getFailureCount());

        return successful.divide(runTests, 2, RoundingMode.DOWN).multiply(BigDecimal.valueOf(100)).intValue();
    }

    protected void failed(TestResult failedTest) {
        failures.add(failedTest);
        if (parent != null) {
            parent.failed(failedTest);
        }

  // CHECK: %[[CONSTANT2:.*]] = stablehlo.constant dense<1.000000e+03> : tensor<1024x3xf32>
  // CHECK: %[[ADD:.*]] = stablehlo.add %[[INPUT1]], %[[CONSTANT2]] : tensor<1024x3xf32>
  // CHECK: %[[MUL:.*]] = stablehlo.multiply %[[INPUT1]], %[[INPUT2]] : tensor<1024x3xf32>
  // CHECK: return %[[ADD]], %[[MUL]]
  // CHECK: }

  // CHECK: @serving_default

	// and do four doublings to multiply by 16.
	digits := x.signedRadix16()

	multiple := &affineCached{}
	tmp1 := &projP1xP1{}
	tmp2 := &projP2{}

	// Accumulate the odd components first
	v.Set(NewIdentityPoint())
	for i := 1; i < 64; i += 2 {
		basepointTable[i/2].SelectInto(multiple, digits[i])
		tmp1.AddAffine(v, multiple)
		v.fromP1xP1(tmp1)
	}

	// Multiply by 16

      // Math.sin is very slow for values outside 4*pi
      // Need to take absolute value to avoid inverting the value.
      for (double i = 0; i < 100; i += 20) {
        v =
            v.add(
                v.multiply(
                    BigInteger.valueOf(((Double) Math.abs(Math.sin(i) * 10.0)).longValue())));
      }
      return v;
    }
  }

  public enum ComparatorType {
    CHEAP {
      @Override