I32Attr:$calibration_method,
    // The number of histogram bins.
    I32Attr:$num_bins,
    // Min percentile to be included in the selected range, only used in the
    // `HISTOGRAM_PERCENTILE` method.
    F32Attr:$min_percentile,
    // Max percentile to be included in the selected range, only used in the
    // `HISTOGRAM_PERCENTILE` method.
    F32Attr:$max_percentile
  );

    TF_Float32Tensor:$momenta,
    TF_Int32Tensor:$num_minibatches_per_physical_sparse_core,

    BoolAttr:$use_nesterov,
    F32Attr:$exponent,
    F32Attr:$beta1,
    F32Attr:$beta2,
    F32Attr:$epsilon,
    F32Attr:$clip_weight_min,
    F32Attr:$clip_weight_max,
    StrAttr:$table_name
  );

  let results = (outs
    TF_Float32Tensor:$updated_embedding_table,

    $t, $m, $v, $beta, $gamma, F32Attr:$variance_epsilon, ConstBoolAttrFalse:$scale_after_normalization),
  (TF_AddOp
    (TF_MulOp $t, (TF_RsqrtOp:$rsqrt (TF_AddOp $v, (TF_ConstOp $variance_epsilon)))),
    (TF_SubOp $beta, (TF_MulOp $m, $rsqrt)))>;
def ConvertBatchNormWithGlobalNormalization_2 : Pat<
  (TF_BatchNormWithGlobalNormalizationOp

                           (TFL_FloorModOp $arg0, $arg1)>;
def LegalizeExp : Pat<(TF_ExpOp $arg0), (TFL_ExpOp $arg0)>;

def LegalizeLRN : Pat<
  (TF_LRNOp $arg0, $radius, F32Attr:$bias, F32Attr:$alpha, F32Attr:$beta),
  (TFL_LocalResponseNormalizationOp $arg0, (convertIntAttrTo32Bit $radius),
    $bias, $alpha, $beta)>;

def LegalizeNonMaxSuppressionV4 : Pat<

    TFL_TensorOf<[F32]>:$filter,
    TFL_TensorOfOrNone<[F32]>:$bias,
    I32Attr:$dilation_d_factor,
    I32Attr:$dilation_h_factor,
    I32Attr:$dilation_w_factor,
    TFL_AFAttr:$fused_activation_function,
    TFL_PaddingAttr:$padding,
    I32Attr:$stride_d,
    I32Attr:$stride_h,
    I32Attr:$stride_w
  );

  let results = (outs TFL_TensorOf<[F32]>:$output);

    Arg<TensorOf<[TF_Bfloat16, TF_Float16, TF_Float32]>, [{4-D.}]>:$input,

    DefaultValuedOptionalAttr<I64Attr, "5">:$depth_radius,
    DefaultValuedOptionalAttr<F32Attr, "1.0f">:$bias,
    DefaultValuedOptionalAttr<F32Attr, "1.0f">:$alpha,
    DefaultValuedOptionalAttr<F32Attr, "0.5f">:$beta
  );

  let results = (outs
    TensorOf<[TF_Bfloat16, TF_Float16, TF_Float32]>:$output
  );

// is then to compute
//   (x * multiplier) + (offset - mean * multiplier).
//
// def : Pattern<
//     (TF_FusedBatchNormV3Op:$root
//         $x, $scale, $offset, $mean, $variance,
//         F32Attr:$epsilon, $exponential_avg_factor,
//         $data_format, FalseBoolAttr:$is_training),
//     [(TF_AddOp
//         (TF_MulOp
//             $x,
//             (TF_MulOp:$multiplier
//                 $scale,

}

static tflite::TensorType ConvertDerivedTypeAttrForOptionWriter(
    mlir::Type type, flatbuffers::FlatBufferBuilder* builder) {
  return tflite::ConvertTypeToTensorType(type);
}

// I32Attr already returns an int as required by flatbuffer builders.
static int ConvertI32AttrForOptionWriter(
    int i, flatbuffers::FlatBufferBuilder* builder) {
  return i;
}

  let summary = "The Fallback CreateOp";

  let description = [{
    The CreateOp creates the tensorflow::OpKernel in the fallback context.
  }];

  let arguments = (ins
    StrAttr:$node_def,
    I32Attr:$op_key
  );

  let assemblyFormat = "attr-dict";
}

def ConstOp: TensorflowMlrt_Op<"constop", []> {
  let summary = "The tf_mlrt ConstOp";

  let description = [{

  }];

  let arguments = (ins
    TF_Tensor:$max_iterations,
    Variadic<TF_Tensor>:$tensor_list_or_flow_in,
    Variadic<TF_Tensor>:$invariant_args,
    FlatSymbolRefAttr:$body_fn,
    I32Attr:$num_tensor_list_or_flow_in
  );

  let results = (outs
     Variadic<TF_Tensor>:$result
  );