}];

  let arguments = (ins
    Variadic<TFTensorType>:$operands,
    StrAttr:$func_name,
    I64ArrayAttr:$resource_indices,
    I64ArrayAttr:$used_output_indices
  );
  let results = (outs
    Variadic<TFTensorType>:$results
  );
}

			if !sig.Variadic() {
				// Skip checking non-variadic functions.
				return "", -1
			}
			idx := sig.Params().Len() - 2
			if idx < 0 {
				// Skip checking variadic functions without
				// fixed arguments.
				return "", -1
			}
			s, ok := stringConstantArg(pass, call, idx)
			if !ok {
				// The last argument before variadic args isn't a string.
				return "", -1
			}

//
// The implementation fn can assume that the argument [Value] slice
// has the number and type of arguments given by typ.
// If typ describes a variadic function, the final Value is itself
// a slice representing the variadic arguments, as in the
// body of a variadic function. The result Value slice returned by fn
// must have the number and type of results given by typ.
//

	// --------------+------------------+----------------+
	// variadic func | nargs >= npars-1 | nargs == npars |
	// --------------+------------------+----------------+

	nargs := len(args)
	npars := sig.params.Len()
	ddd := hasDots(call)

	// set up parameters
	sigParams := sig.params // adjusted for variadic functions (may be nil for empty parameter lists!)

>;

// Removes `stablehlo.custom_call @Sharding`. Assumes this call always accepts
// one input. Other attributes are ignored.
def RemoveShardingCustomCall : Pat<
  (StableHLO_CustomCallOp (variadic $input0), $call_target_name, $_, $_, $_, $_, $_, $_, $_),
  (replaceWithValue $input0),

include "tensorflow/compiler/mlir/tensorflow/ir/tf_ops.td"
include "mlir/IR/OpBase.td"
include "mlir/IR/PatternBase.td"
include "tensorflow/compiler/mlir/quantization/common/attrs_and_constraints.td"

// Combines the two variadic arguments ($in_tensors and $captured_tensors).
def GetBatchFunctionOpArgOperands:
    NativeCodeCall<"cast<TF::BatchFunctionOp>($0[0].getDefiningOp()).getArgOperands()">;

	// --------------+------------------+----------------+
	// variadic func | nargs >= npars-1 | nargs == npars |
	// --------------+------------------+----------------+

	nargs := len(args)
	npars := sig.params.Len()
	ddd := hasDots(call)

	// set up parameters
	sigParams := sig.params // adjusted for variadic functions (may be nil for empty parameter lists!)

    the `call` operation can only be with tfr.tensor and tfr.tensor_list types.
  }];

  let arguments = (ins
    FlatSymbolRefAttr:$callee,
    Variadic<TFR_allowedArgType>:$args);

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

  let extraClassDeclaration = [{
    // Get the argument operands to the called function.
    operand_range getArgOperands() { return getArgs(); }

  let summary = "XLA Launch Op. For use by the XLA JIT only.";

  let arguments = (ins
    Variadic<TF_Tensor>:$constants,
    Variadic<TF_Tensor>:$args,
    Variadic<TF_ResourceTensor>:$resources,

    SymbolRefAttr:$function
  );

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

  TF_DerivedOperandSizeAttr Nresources = TF_DerivedOperandSizeAttr<2>;

  );
}

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

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

    StrAttr:$output_file_path,
    StrArrayAttr:$ids,
    I32ArrayAttr:$calibration_methods
  );

  TF_DerivedOperandTypeListAttr Tin = TF_DerivedOperandTypeListAttr<0>;