);

  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,

// Tensor types
def TF_BoolTensor : TensorOf<[TF_Bool]>;

def TF_IntTensor : TensorOf<[TF_Int]>;
def TF_Int4Tensor : TensorOf<[TF_Int4]>;
def TF_Int8Tensor : TensorOf<[TF_Int8]>;
def TF_Int16Tensor : TensorOf<[TF_Int16]>;
def TF_Int32Tensor : TensorOf<[TF_Int32]>;
def TF_Int64Tensor : TensorOf<[TF_Int64]>;
def TF_I32OrI64Tensor : TensorOf<[TF_I32OrI64]>;

def TF_Uint4Tensor : TensorOf<[TF_Uint4]>;

def FuseTransposeFCLhsToBatchMatmul : Pat<
  (TFL_BatchMatMulOp
    (TFL_FullyConnectedOp:$fc_output
      (TFL_TransposeOp TensorOf<[F32]>:$fc_lhs,
                       (Arith_ConstantOp:$perm_value $p0)),
      TensorOf<[F32]>:$fc_rhs,
      $bias, $TFL_AF_None, $TFL_FCWO_Default,
      $keep_num_dims, $asymmetric_quantize_inputs_fc
    ),
    $bmm_rhs, ConstBoolAttrTrue, $transpose_rhs,

          (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.

    (TF_CastOp:$i8_cast
      (TF_ClipByValueOp:$clip $input, $min_value, $max_value),
      ConstBoolAttrFalse:$truncate2),
    ConstBoolAttrFalse:$truncate1),
  (TF_CastOp $clip, ConstBoolAttrFalse),
  [(TensorOf<[I8]> $i8_cast),
   (TensorOf<[I32]> $clip),
   (IsIntSplatValueEqual<"int32_t", "-128"> $min_value),
   (IsIntSplatValueEqual<"int32_t", "127"> $max_value)]>;

// This pattern optimizes:
//   (x + cst1) + cst2 -> x + cst

  }];

  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,

    Note: Additional result corresponds to the control output.
  }];

  let arguments = (ins
    TensorOf<[I1]>:$input,
    Variadic<TfeControlType>:$controlInputs
  );
  let results = (outs
    TensorOf<[I1]>:$output,
    TfeControlType:$control
  );

  let hasVerifier = 0;
}

    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.
//===----------------------------------------------------------------------===//

    (OpsTuple[0]
      $input,
      (OpsTuple[2] $zp_offset, $bias, $broadcast_dims_2), $broadcast_dims_1),
    [
      (IsNull $broadcast_dims_1),
      (IsNull $broadcast_dims_2),
      (TensorOf<[AnyInteger]> $input),
      (IsDefinedByConvOrDotGeneralOp $input)]>;