Execute $a_true_fn with $args if $cond is true; otherwise, %b_false_fn is
    executed.
  }];

  let arguments = (ins
    I1:$cond,
    Variadic<AnyType>:$args,
    SymbolRefAttr:$a_true_fn,
    SymbolRefAttr:$b_false_fn
  );

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

  let assemblyFormat = [{
    $cond $a_true_fn $b_false_fn `(` $args `)` attr-dict `:` `(` type($args) `)` `->` `(` type($results) `)`

        (MHLO_CompositeOp:$composite
          (variadic $inputs),
          ConstantStrAttr<StrAttr, "aten.gelu.default">, $attrs, $_, $_),
        (TFL_GeluOp $inputs, ConstBoolAttrFalse),
        [(IsStrCompositeAttribute<"approximate", "none"> $attrs)]>;

def LegalizeCompositeApproximateAtenGELU : Pat<
        (MHLO_CompositeOp:$composite
          (variadic $inputs),

  }];

  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
  );

var _ float64 = foo(42, []float64{1.0}, &s)

// Type inference works in a straight-forward manner even
// for variadic functions.
func variadic[A, B any](A, B, ...B) int { panic(0) }

// var _ = variadic(1) // ERROR "not enough arguments"
var _ = variadic(1, 2.3)
var _ = variadic(1, 2.3, 3.4, 4.5)
var _ = variadic[int, float64](1, 2.3, 3.4, 4)

// Type inference also works in recursive function calls where

    Note that the trailing number indicates the number of results.
  }];

  let arguments = (ins
    Variadic<TFTensorType>,
    StrAttr:$node_def,
    I32Attr:$op_key
  );

  let results = (outs Variadic<TFTensorType>);

  let assemblyFormat = "`(`operands`)` attr-dict `:` functional-type(operands, results)";
}

    element of `args` is a key to a loaded array corresponding to a variable.
  }];

  let arguments = (ins
    Variadic<TF_Tensor> : $args,
    I64Attr : $program_id,
    I32ArrayAttr : $variable_arg_indices
  );

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

  TF_DerivedOperandTypeListAttr Tin = TF_DerivedOperandTypeListAttr<0>;

func tuple() (int, int, int) { return 1, 2, 3 }

var (
	_ = sum(tuple())
	_ = sum(tuple()...) // ERROR "\.{3} with 3-valued|multiple-value"
	_ = sum3(tuple())
	_ = sum3(tuple()...) // ERROR "\.{3} in call to non-variadic|multiple-value|invalid use of .*[.][.][.]"
)

type T []T

func funny(args ...T) int { return 0 }

var (
	_ = funny(nil)
	_ = funny(nil, nil)
	_ = funny([]T{}) // ok because []T{} is a T; passes []T{[]T{}}

// ops that match the behaviour of tfl.average_pool_2d are directly lowered.
def LegalizeAvgPool2dComposite: Pat<
                    (MHLO_CompositeOp:$old_val
                    (variadic $a_input), 
                    ConstantStrAttr<StrAttr, "aten.avg_pool2d.default">, $attrs, $_, $_),
                    (TFL_TransposeOp 
                        (TFL_AveragePool2DOp 

  }];

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

  }];
  let arguments = (ins
    Variadic<TFTensorType>:$operands_and_static_shapes,
    DenseI32ArrayAttr:$constant_operand_indices,
    StrAttr:$metadata,
    StrAttr:$mlir_module,
    UI32Attr:$num_operands,
    DenseI32ArrayAttr:$operands_with_static_shape,
    StrAttr:$producer_name
  );

  let results = (outs
    TFTensorType:$rendezvous_key_base,
    Variadic<MlrtFutureType>:$results
  );