if _, ok := inst.Args[3].(Cond); ok {
		if _, ok := inst.Args[2].(Reg); ok {
			args[1], args[2] = args[2], args[1]
		} else {
			args[0], args[2] = args[2], args[0]
		}
	}
	// Reverse args, placing dest last.
	for i, j := 0, len(args)-1; i < j; i, j = i+1, j-1 {
		args[i], args[j] = args[j], args[i]
	}

	if args != nil {
		op += " " + strings.Join(args, ", ")
	}

			func(cmd string, args ...string) exec.Cmd { return fakeexec.InitFakeCmd(&fcmd, cmd, args...) },
			func(cmd string, args ...string) exec.Cmd { return fakeexec.InitFakeCmd(&fcmd, cmd, args...) },
			func(cmd string, args ...string) exec.Cmd { return fakeexec.InitFakeCmd(&fcmd, cmd, args...) },
			func(cmd string, args ...string) exec.Cmd { return fakeexec.InitFakeCmd(&fcmd, cmd, args...) },
		},
	}

    private final String messageCode;

    private final Object[] args;

    private final String sql;

    /**
     * {@link ClSQLException}を作成します。
     *
     * @param messageCode
     *            メッセージコード
     * @param args
     *            引数の並び
     */
    public ClSQLException(final String messageCode, final Object[] args) {
        this(messageCode, args, null, 0, null, null);
    }

    /**

)

func TestConvertToArgs(t *testing.T) {
	var tests = []struct {
		name         string
		args         map[string]string
		expectedArgs []kubeadmapi.Arg
	}{
		{
			name:         "nil map returns nil args",
			args:         nil,
			expectedArgs: nil,
		},
		{
			name: "valid args are parsed (sorted)",
			args: map[string]string{"c": "d", "a": "b"},
			expectedArgs: []kubeadmapi.Arg{
				{Name: "a", Value: "b"},

        given:
        1 * graph.getNodeValues("1", _, _) >> { args -> args[2] << "2"; args[2] << "3" }
        1 * graph.getNodeValues("2", _, _) >> { args -> args[2] << "4" }
        1 * graph.getNodeValues("3", _, _) >> { args -> }
        1 * graph.getNodeValues("4", _, _) >> { args -> args[2] << "5" }
        1 * graph.getNodeValues("5", _, _) >> { args -> }

        when:
        StringWriter writer = new StringWriter()

            }
        };
    }

    /**
     * Writes a set of args on a single line, escaping and quoting as required.
     */
    @Override
    public ArgWriter args(Object... args) {
        for (int i = 0; i < args.length; i++) {
            Object arg = args[i];
            if (i > 0) {
                writer.print(' ');
            }

	EvEventBatch: event.Spec{
		Name: "EventBatch",
		Args: []string{"gen", "m", "time", "size"},
	},
	EvStacks: event.Spec{
		Name: "Stacks",
	},
	EvStack: event.Spec{
		Name:    "Stack",
		Args:    []string{"id", "nframes"},
		IsStack: true,
	},
	EvStrings: event.Spec{
		Name: "Strings",
	},
	EvString: event.Spec{
		Name:    "String",
		Args:    []string{"id"},
		HasData: true,
	},

      break;
  }
}

void TF_VLog(int level, const char* fmt, ...) {
  va_list args;
  va_start(args, fmt);
  auto message = BuildMessage(fmt, args);
  va_end(args);
  VLOG(level) << message;
}

void TF_DVLog(int level, const char* fmt, ...) {
  va_list args;
  va_start(args, fmt);
  auto message = BuildMessage(fmt, args);
  va_end(args);
  DVLOG(level) << message;

	lockServers = make([]*lockServer, numberOfNodes)
)

func getLockArgs(r *http.Request) (args LockArgs, err error) {
	buf, err := io.ReadAll(r.Body)
	if err != nil {
		return args, err
	}
	_, err = args.UnmarshalMsg(buf)
	return args, err
}

type lockServerHandler struct {
	lsrv *lockServer
}

     * @param args args for the command
     * @return this
     */
    ExecSpec args(Iterable<?> args);

    /**
     * Sets the arguments for the command to be executed.
     *
     * @param args args for the command
     * @return this
     * @since 4.0
     */
    ExecSpec setArgs(List<String> args);

    /**
     * Sets the arguments for the command to be executed.
     *
     * @param args args for the command