def LegalizeArgMax : Pat<(TF_ArgMaxOp $input, $dim),
                         (TFL_ArgMaxOp $input, $dim)>;
def LegalizeArgMin : Pat<(TF_ArgMinOp $input, $dim),
                         (TFL_ArgMinOp $input, $dim)>;

def LegalizeBroadcastTo : Pat<(TF_BroadcastToOp $input, $dim),
                              (TFL_BroadcastToOp $input, $dim)>;

def LegalizeCeil : Pat<(TF_CeilOp $arg), (TFL_CeilOp $arg)>;

  opcode_index:uint;

  // Optional input are indicated by -1.
  inputs:[int];
  outputs:[int];

  builtin_options:BuiltinOptions;
  custom_options:[ubyte];
  custom_options_format:CustomOptionsFormat;

  // A list of booleans indicating the input tensors which are being mutated by
  // this operator.(e.g. used by RNN and LSTM).
  // For example, if the "inputs" array refers to 5 tensors and the second and

)

var Decode cbor.DecMode = func() cbor.DecMode {
	decode, err := cbor.DecOptions{
		// Maps with duplicate keys are well-formed but invalid according to the CBOR spec
		// and never acceptable. Unlike the JSON serializer, inputs containing duplicate map
		// keys are rejected outright and not surfaced as a strict decoding error.
		DupMapKey: cbor.DupMapKeyEnforcedAPF,

		// For JSON parity, decoding an RFC3339 string into time.Time needs to be accepted

      }

      // Collect all the quantized inputs and "clone" the matched op by these
      // inputs.
      SmallVector<Value, 4> inputs;
      inputs.reserve(quantizing_op->getNumOperands());
      for (const auto& operand : quantizing_op->getOperands()) {
        Type operand_type = operand.getType();
        if (operand_type.isa<NoneType>()) {
          inputs.push_back(operand);
          continue;
        }

            reduce_dataset.getF());

    // The reduce function arguments consist of three part in this order:
    // 1. Reduction state inputs.
    // 2. Dataset inputs.
    // 3. Captures inputs.
    // The number of dataset inputs can be indirectly determined to be
    // total_number_of_inputs - state_inputs - captured_inputs.
    auto func_inputs = reduce_func.getFunctionType().getInputs();

        }

        public <T, U> List<U> transformAll(Collection<T> inputs, ValueOrTransformProvider<T, U> valueOrTransformProvider) {
            assert !inputs.isEmpty();
            return cache.useCache(() -> {

                final List<U> results = new ArrayList<>(inputs.size());
                final List<Callable<Void>> transforms = new ArrayList<>(inputs.size());
                final Set<HashCode> seen = new HashSet<>();

  kQuantizationOp,  // Quantization ops have input/output attr.
};

// For each op type, the following axis carries axis information:
// kDynamicRangeOp: rhs_quantization_axis will carry axis information.
// kUnaryOp: quantization_axis will carry axis information.
// kBinaryOp: Among {lhs, rhs, output}_quantization_axis, only check rhs.
// kQuantizationOp: Among {input, output}_quantization_axis, only check input.

// Predicate denote logical formulas and mapping a node `n` to a predicate
// `pred` implies that `n` is live whenever `pred` is true.  Then we can deduce
// mismatching liveness in the inputs to node by comparing the predicate those
// inputs are mapped to.  The core logic of this pass resides in creating the
// map from TensorFlow nodes to predicates.
//
//
// MAPPING NODES TO PREDICATES, MODULO CYCLES

                    def input = inputArtifact.get().asFile
                    def output = outputs.file(input.name + ".\${targetColor}")
                    assert output.parentFile.directory && output.parentFile.list().length == 0
                    println "Transforming \${input.name} to \${output.name}"
                    println "Input exists: \${input.exists()}"

      func.func @main(%arg_0: tensor<!tf_type.string> {tf_saved_model.bound_input = @__tf_saved_model_asset0}) -> () attributes {tf.entry_function = {inputs = "arg_0:0", outputs = ""}} {
        return
      }
    }
  )mlir");

  FailureOr<SmallVector<AssetFileDef>> asset_file_defs =
      ConvertAssetArgs(*module_op);

  EXPECT_TRUE(succeeded(asset_file_defs));