using QuantizationUnit = std::pair<Operation*, int>;
using QuantizationUnits = llvm::SetVector<QuantizationUnit>;
using ::tensorflow::quantization::OpSet;

// Preprocesses ops to allow multi-axis quantization, prior to quantization
// passes. Currently, per-channel quantization only supports 1D results.
class PreprocessOpPass
    : public PassWrapper<PreprocessOpPass, OperationPass<ModuleOp>> {

	dk := k1 - k0
	if di >= dj && di >= dk && di >= threshold {
		// divide in two by y axis
		mi := i0 + di/2
		done1 := make(chan struct{}, 1)
		go matmult(done1, A, B, C, i0, mi, j0, j1, k0, k1, threshold)
		matmult(nil, A, B, C, mi, i1, j0, j1, k0, k1, threshold)
		<-done1
	} else if dj >= dk && dj >= threshold {
		// divide in two by x axis
		mj := j0 + dj/2
		done1 := make(chan struct{}, 1)

    %0:3 = "tf.Unpack"(%arg0) {axis = 0 : i64} : (tensor<3xi64>) -> (tensor<i64>, tensor<i64>, tensor<i64>)
    return
  }
})";

XlaComputation GetTestXlaComputation() {
  XlaBuilder xla_builder("test");
  auto param =

  TFE_TensorHandle* axis = TestAxisTensorHandle(ctx);
  TFE_Op* minOp = MinOp(ctx, input, axis);
  TFE_TensorHandle* retvals[1] = {nullptr};
  int num_retvals = 1;
  TFE_Execute(minOp, &retvals[0], &num_retvals, status);
  EXPECT_EQ(TF_OK, TF_GetCode(status)) << TF_Message(status);
  TFE_DeleteOp(minOp);
  TFE_DeleteTensorHandle(input);
  TFE_DeleteTensorHandle(axis);
  ASSERT_EQ(1, num_retvals);

// TorchIndexSelect op patterns.
//===----------------------------------------------------------------------===//

def : Pat<(MHLO_TorchIndexSelectOp $params, $indices, $axis, $batch_dims),

          type: "int"
          has_minimum: true
          minimum: 1
        }
        attr {
          name: "T"
          type: "type"
        }
        attr {
          name: "axis"
          type: "int"
          default_value {
            i: 0
          }
        }
      }
      op {
        name: "ParseExample"
        input_arg {
          name: "serialized"

                          bool per_axis) {
  auto *def_init = llvm::cast<llvm::DefInit>(input_value);
  auto *val = def_init->getDef()->getValue("tflRuntimeTypePredicate");

  // For non-per-axis op, no predicate means accepting AnyTensor.
  if (!val) return !per_axis;

  llvm::StringRef supported_types =
      def_init->getDef()->getValueAsString("tflRuntimeTypeDescription");

    const QuantizationSpecs& quant_specs,
    tensorflow::quantization::OpSet op_set);

// Creates an instance of the PreprocessOp pass, which will perform op
// preprocessing to allow multi-axis quantization, prior to quantization.
std::unique_ptr<OperationPass<ModuleOp>> CreatePreprocessOpPass(
    tensorflow::quantization::OpSet op_set,
    tensorflow::quantization::QuantizationMethod::PresetMethod

struct ConcatenationOptionsBuilder {
  typedef ConcatenationOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_axis(int32_t axis) {
    fbb_.AddElement<int32_t>(ConcatenationOptions::VT_AXIS, axis, 0);
  }
  void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {

_Fig._ 7.] be any refracting Lens, spherically Convex or Concave or Plane on either side, and let CD be its Axis (that is, the Line which cuts both its Surfaces perpendicularly, and passes through the Centres of the Spheres,) and in this Axis produced let F and _f_ be the Foci of the refracted Rays found as above, when the incident Rays on both sides the Lens are parallel to the same Axis; and upon the Diameter F_f_ bisected in E, describe a Circle. Suppose now that any Point Q be the Focus of any...