{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YxmEvex, YxrEvex}},
	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{YxmEvex, Yknot0, YxrEvex}},
	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YxmEvex, YyrEvex}},
	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{YxmEvex, Yknot0, YyrEvex}},
	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YxmEvex, Yzr}},
	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{YxmEvex, Yknot0, Yzr}},

	{Zm_ibo, 2, argList{Yml, Yi8}},
	{Z_il, 1, argList{Yax, Yi32}},
	{Zm_ilo, 2, argList{Yml, Yi32}},
	{Zm_r, 1, argList{Yml, Yrl}},
	{Zr_m, 1, argList{Yrl, Yml}},
}

var yshb = []ytab{
	{Zo_m, 2, argList{Yi1, Ymb}},
	{Zibo_m, 2, argList{Yu8, Ymb}},
	{Zo_m, 2, argList{Ycx, Ymb}},
}

var yshl = []ytab{
	{Zo_m, 2, argList{Yi1, Yml}},
	{Zibo_m, 2, argList{Yu8, Yml}},
	{Zo_m, 2, argList{Ycl, Yml}},

            copy.call();
        } else {
            Object[] argList = new Object[inputs.size() + 1];
            argList[0] = subject;
            int i = 1;
            for (Object arg : inputs) {
                argList[i++] = arg;
            }
            copy.call(argList);
        }
    }

    private List<Class<?>> parseInputTypes(Closure<?> closure) {

    protected String filename;

    protected List<String> argList = new ArrayList<>();

    public PythonJob filename(final String filename) {
        this.filename = filename;
        return this;
    }

    public PythonJob arg(final String value) {
        argList.add(value);
        return this;
    }

    public PythonJob args(final String... values) {

			// position, code, format string, and arguments to format
			if n := len(call.ArgList); n < errorfMinArgCount {
				t.Errorf("%s: got %d arguments, want at least %d", call.Pos(), n, errorfMinArgCount)
				return false
			}
			format := call.ArgList[errorfFormatIndex]
			syntax.Inspect(format, func(n syntax.Node) bool {

// Max len(obj.Prog.RestArgs) can be inferred from this to be 4.
const argListMax int = 6

type argList [argListMax]uint8

type ytab struct {
	zcase   uint8
	zoffset uint8

	// Last arg is usually destination.
	// For unary instructions unaryDst is used to determine
	// if single argument is a source or destination.
	args argList
}

// Returns true if yt is compatible with args.
//

	argList := call.Args

	// append is the only built-in that permits the use of ... for the last argument
	bin := predeclaredFuncs[id]
	if hasDots(call) && id != _Append {
		check.errorf(dddErrPos(call),
			InvalidDotDotDot,
			invalidOp+"invalid use of ... with built-in %s", bin.name)
		check.use(argList...)
		return
	}

	if sig.variadic {
		if ddd {
			// variadic_func(a, b, c...)
			if len(call.ArgList) == 1 && nargs > 1 {
				// f()... is not permitted if f() is multi-valued
				//check.errorf(call.Ellipsis, "cannot use ... with %d-valued %s", nargs, call.ArgList[0])
				check.errorf(call, InvalidDotDotDot, "cannot use ... with %d-valued %s", nargs, call.ArgList[0])
				return
			}
		} else {
			// variadic_func(a, b, c)

		registerTaintsUsingFlags: registerTaintsUsingFlags,
	}
	stringMap := buildKubeletArgs(flagOpts)
	argList := kubeadmutil.ArgumentsToCommand(stringMap, nodeReg.KubeletExtraArgs)
	envFileContent := fmt.Sprintf("%s=%q\n", constants.KubeletEnvFileVariableName, strings.Join(argList, " "))

	return writeKubeletFlagBytesToDisk([]byte(envFileContent), kubeletDir)
}

	argList := call.ArgList

	// append is the only built-in that permits the use of ... for the last argument
	bin := predeclaredFuncs[id]
	if hasDots(call) && id != _Append {
		check.errorf(dddErrPos(call),
			InvalidDotDotDot,
			invalidOp+"invalid use of ... with built-in %s", bin.name)
		check.use(argList...)
		return
	}