);

  let results = (outs
    TensorOf<[TF_Float32]>:$output,
    TensorOf<[TF_Float32]>:$min,
    TensorOf<[TF_Float32]>:$max,
    TensorOf<[TF_Int64]>:$histogram
  );
}

def TF_CalibrationStatisticsSaverOp : TF_Op<"CalibrationStatisticsSaver", []> {
  let summary = "Aggregates and saves calibration statistics.";

  let arguments = (ins
    Variadic<TensorOf<[TF_Float32, TF_Int64]>>:$inputs,

          (TF_SubOp $max_range, $min_range),
          (TF_ConstOp (GetF32Scalar<255>)))),
      $min_range),
    /*truncate=*/ConstBoolAttrFalse),
  [(TensorOf<[TF_Qint8, TF_Quint8]> $input),
   (TF_Float32Tensor $min_range),
   (TF_Float32Tensor $max_range),
   (TensorOf<[TF_Float32, TF_Bfloat16]> $result)]>;

//===----------------------------------------------------------------------===//
// Difference op patterns.

  }];

  let arguments = (ins
    Arg<TensorOf<[TF_Bfloat16, TF_Float16, TF_Float32]>, [{A 4D Tensor for input data.}]>:$x,
    Arg<TensorOf<[TF_Bfloat16, TF_Float32]>, [{A 1D Tensor for scaling factor, to scale the normalized x.}]>:$scale,
    Arg<TensorOf<[TF_Bfloat16, TF_Float32]>, [{A 1D Tensor for offset, to shift to the normalized x.}]>:$offset,

    Variadic<TensorOf<[TF_Float32, TF_Int64, TF_Str]>>:$dense_values,   // len(Tdense)
    Variadic<TensorOf<[TF_Float32, TF_Int64, TF_Str]>>:$ragged_values,  // len(ragged_value_types)
                                                            //     = len(ragged_split_types)
    Variadic<TensorOf<[TF_Int32, TF_Int64]>>:$ragged_row_splits         // len(ragged_split_types)

  (TF_CastOp
    (TF_AddV2Op
      (CreateTFCastOpI32 $lhs, /*truncate=*/ConstBoolAttrFalse),
      (CreateTFCastOpI32 $rhs, /*truncate=*/ConstBoolAttrFalse)),
     /*truncate=*/ConstBoolAttrFalse),
  [(TensorOf<[TF_Uint32]> $lhs), (TensorOf<[TF_Uint32]> $rhs)]>;

//===----------------------------------------------------------------------===//
// Fill op patterns.
//===----------------------------------------------------------------------===//

    $quant_input,
    $bias, $padding, $stride_h, $stride_w, $faf),
  (TFL_TransposeConvOp $output_shape, $quant_weights,
    $quant_input, $bias, $padding, $stride_h, $stride_w, $faf), 

include "tensorflow/compiler/mlir/tensorflow/ir/tf_ops.td"
include "mhlo/IR/hlo_ops.td"

def SignedIntTensor : TensorOf<[I1, I8, I16, I32, I64]>;
def UnsignedIntTensor : TensorOf<[UI8, UI16, UI32, UI64]>;

// IEEE compliant floating point tensors.
def IEEEFloatTensor : TensorOf<[F16, F32, F64]>;

//===----------------------------------------------------------------------===//
// BatchNorm op patterns.

// TFL Relu doesn't support I32/I64 type, so legalizes TF Relu to TFL Maximum.
def LegalizeReluI32 :
  Pat<(TF_ReluOp TensorOf<[I32]>:$arg),
      (TFL_MaximumOp $arg,
        (Arith_ConstantOp ConstantAttr<RankedI32ElementsAttr<[]>,"0">))>;
def LegalizeReluI64 :
  Pat<(TF_ReluOp TensorOf<[I64]>:$arg),
      (TFL_MaximumOp $arg,
        (Arith_ConstantOp

  "allowed tfr.call result types">;

// standard tensor type and tfr.tensor types can be casted to each other.
def TFR_singleTensorType : Type<Or<[
    TFR_TensorType.predicate,
    TF_Tensor.predicate,
    TensorOf<[quant_QuantizedType]>.predicate]>, "single tensor or tfr.tensor type">;

// all allowed build list input types
def TFR_allowedBuiltListType : Type<Or<[
    TFR_TensorType.predicate,
    TF_ElementType.predicate,

class TFL_TensorOf<list<Type> allowedRuntimeTypes,
                   list<Type> allowedOpTypes = [AnyType]> :
  TensorOf<allowedOpTypes>, TFL_RuntimeType<TensorOf<allowedRuntimeTypes>> {
  // Set the summary equal to that representing the runtime types.
  let summary = TensorOf<allowedRuntimeTypes>.summary;
}

class TFL_TensorOfOrNone<list<Type> allowedRuntimeTypes, string description = "",