static final String ARG_1 = "argument1"
    static final String ARG_2 = "argument2"

    def setup() {
        buildFile << """
            if(hasProperty('$ARG_1')) logger.quiet("$ARG_1")
            if(hasProperty('$ARG_2')) logger.quiet("$ARG_2")
        """
    }

    def "Appends additional JVM arguments"() {
        when:

	// For instance, if this abiSeq represents 3 arguments
	// passed to a function, then the 2nd argument's steps
	// begin at steps[valueStart[1]].
	//
	// Because reflect accepts Go arguments in distinct
	// Values and each Value is stored separately, each abiStep
	// that begins a new argument will have its offset
	// field == 0.
	steps      []abiStep
	valueStart []int

	stackBytes   uintptr // stack space used

    }
  }
  std::vector<string> arguments;
  arguments.reserve(args_without_default_val.size() +
                    args_with_default_val.size());
  arguments.insert(arguments.end(),
                   std::make_move_iterator(args_without_default_val.begin()),
                   std::make_move_iterator(args_without_default_val.end()));
  arguments.insert(arguments.end(),
                   std::make_move_iterator(args_with_default_val.begin()),

// (and corresponding expressions).
// If the callee is variadic, arguments adjusts its signature to match the provided
// arguments. The type parameters and arguments of the callee and all its arguments
// are used together to infer any missing type arguments, and the callee and argument
// functions are instantiated as necessary.
// The result signature is the (possibly adjusted and instantiated) function signature.

	// Note: We must do this _before_ calling exprList because exprList evaluates
	//       all arguments.
	if id == _Len || id == _Cap {
		defer func(b bool) {
			check.hasCallOrRecv = b
		}(check.hasCallOrRecv)
		check.hasCallOrRecv = false
	}

	// Evaluate arguments for built-ins that use ordinary (value) arguments.
	// For built-ins with special argument handling (make, new, etc.),
	// evaluation is done by the respective built-in code.

            printer: PrettyPrinter,
        ) {
            if (annotation.arguments.isEmpty()) return
            printer.printCollection(annotation.arguments, prefix = "(", postfix = ")") { argument ->
                append(argument.name.render())
                append(" = ")
                append(KaAnnotationValueRenderer.render(argument.expression))
            }
        }
    }
}

}

// TODO(b/260267885): We may add a device argument when we want to support
// GPU MIG.
def TransferToDeviceOp: Gpu_Op<"transfer_to_device"> {
  let summary = "Transfer a CPU tensor to device.";

  let description = [{
    Transfer a CPU tensor to device.

    Example:
      %device_tensor = gpurt.transfer_to_device %cpu_tensor
  }];

  let arguments = (ins TFTensorType);
  let results = (outs TFTensorType);

//
// nor too many:
//
//	fmt.Printf("%d", 1, 2) // fmt.Printf call needs 1 arg, but has 2 args
//
// Explicit argument indexes must be no greater than the number of
// arguments:
//
//	fmt.Printf("%[3]d", 1, 2) // fmt.Printf call has invalid argument index 3
//
// The checker also uses a heuristic to report calls to Print-like
// functions that appear to have been intended for their Printf-like

	_ = complex(f1()) // ERROR "not enough arguments"
	_ = complex(f2())
	_ = complex(f3()) // ERROR "too many arguments"
}

func copy1() {
	copy() // ERROR "not enough arguments"
	copy("foo") // ERROR "not enough arguments"
	copy([ /* ERROR "copy expects slice arguments" */ ...]int{}, []int{})
	copy([ /* ERROR "copy expects slice arguments" */ ]int{}, [...]int{})

model to StableHLO with static input shape `4x3x224x224` for input argument with
type `tensor<?x3x224x224xf32>`.

```bash
tf-to-stablehlo-translate <saved-model-path> --input-arg-shapes=4,3,224,224
```

* To convert
[google-bert/bert-large-uncased](https://huggingface.co/google-bert/bert-large-uncased)
to StableHLO with static input shapes `1x12`, `1x12`, and `1x12` for input
arguments with types `tensor<?x?xi32>, tensor<?x?xi32>, tensor<?x?xi32>`.