executed and dead values are immediately returned for every result.
  }];

  let arguments = (ins
    Variadic<TfeControlType>:$controlInputs
  );

  let results = (outs
    Variadic<AnyType>:$outputs,
    TfeControlType:$control
  );

  let regions = (region SizedRegion<1>:$body);

  let extraClassDeclaration = [{

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

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package a

type T2 struct{}

func (t *T2) M2(a, b float64) {
	variadic(a, b)
}

func variadic(points ...float64) {
	println(points)

    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{}}

// A derived attribute that returns the element type of `idx`-th ODS-declared
// operand. If the `idx`-th operand is a variadic operand, then this attribute
// just returns the element type of its first tensor, which is only meaningful
// when the variadic operand has at least one tensor and the tensors all have
// the same element type.
class TF_DerivedOperandTypeAttr<int idx> : DerivedTypeAttr<

      "MatMul",     // 2 inputs & attrs with default values
      "IdentityN",  // Variadic input+output
      "SparseSoftmaxCrossEntropyWithLogits",  // 2 outputs
      "AccumulatorApplyGradient",             // 0 outputs
      "VarHandleOp",                          // type, shape, list(string) attrs
      "RestoreV2",  // Variadic output-only, list(type) attr
  };

  cpp::CppConfig cpp_config(category, name_space);

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

// compile

// Copyright 2014 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// PR61255: gccgo failed to compile IncDec statements on variadic functions.

package main

func main() {
	append([]byte{}, 0)[0]++