MOVQ	trap+0(FP), BP	// syscall entry
	// copy args down
	LEAQ	a1+8(FP), SI
	LEAQ	sysargs-160(SP), DI
	CLD
	MOVSQ
	MOVSQ
	MOVSQ
	SYSCALL
	MOVQ	AX, r1+32(FP)
	MOVQ	$0, r2+40(FP)
	CMPL	AX, $-1
	JNE	ok3

	LEAQ	errbuf-128(SP), AX
	MOVQ	AX, sysargs-160(SP)
	MOVQ	$128, sysargs1-152(SP)
	MOVQ	$SYS_ERRSTR, BP
	SYSCALL

	// copy args down
	LEAL	a1+4(FP), SI
	LEAL	sysargs-144(SP), DI
	CLD
	MOVSL
	MOVSL
	MOVSL
	INT	$64
	MOVL	AX, r1+16(FP)
	MOVL	$0, r2+20(FP)
	CMPL	AX, $-1
	JNE	ok3

	LEAL	errbuf-128(SP), AX
	MOVL	AX, sysargs-144(SP)
	MOVL	$128, sysargs1-140(SP)
	MOVL	$SYS_ERRSTR, AX
	INT	$64
	CALL	runtime·exitsyscall(SB)
	MOVL	sysargs-144(SP), AX
	MOVL	AX, errbuf-148(SP)
	CALL	runtime·gostring(SB)

TEXT ·seek(SB),NOSPLIT,$20-36
	NO_LOCAL_POINTERS
	MOVW	$newoffset_lo+20(FP), R6
	MOVW	R6, sysargs-20(SP)	// dest for return value
	MOVW	$fd+4(FP), R0		// move syscall args
	MOVW	$sysarg1-16(SP), R1
	MOVM.IA	(R0), [R2-R5]
	MOVM.IA	[R2-R5], (R1)
	MOVW	$SYS_SEEK, R0		// syscall num
	SWI		$0
	CMP		$-1, R0
	B.EQ	seekerr
	MOVW	$·emptystring+0(SB), R2
	B		seekok
seekerr:

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

//go:build !linux && !darwin && !dragonfly && !freebsd && !netbsd && !solaris

package runtime

func sysargs(argc int32, argv **byte) {

	setProcessCPUProfilerTimer(hz)
}

func setThreadCPUProfiler(hz int32) {
	setThreadCPUProfilerHz(hz)
}

//go:nosplit
func validSIGPROF(mp *m, c *sigctxt) bool {
	return true
}

func sysargs(argc int32, argv **byte) {
	n := argc + 1

	// skip over argv, envp to get to auxv
	for argv_index(argv, n) != nil {
		n++
	}

	// skip NULL separator
	n++

		"K8S_POD_UID=a09038c7-df3c-4c0e-8667-487b1fe8055f"

	k8sArgs := K8sArgs{}
	if err := types.LoadArgs(kubeletArgs, &k8sArgs); err != nil {
		t.Fatalf("LoadArgs failed with error: %v", err)
	}

	if string(k8sArgs.K8S_POD_NAMESPACE) == "" ||
		string(k8sArgs.K8S_POD_NAME) == "" ||
		string(k8sArgs.K8S_POD_UID) == "" {

	for k, v := range i.cfg.Values {
		setArgs = append(setArgs, fmt.Sprintf("values.%s=%s", k, v))
	}

	for k, v := range i.cfg.OperatorOptions {
		setArgs = append(setArgs, fmt.Sprintf("%s=%s", k, v))
	}

	if err := i.installer.Install(cluster, installArgs{
		ComponentName: "eastwestgateway",
		Revision:      revision,
		Files:         inFileNames,
		Set:           setArgs,
	}); err != nil {
		return err
	}

        getDelegate().args(args);
        return this;
    }

    @Override
    default ExecSpec setArgs(List<String> args) {
        getDelegate().setArgs(args);
        return this;
    }

    @Override
    default ExecSpec setArgs(Iterable<?> args) {
        getDelegate().setArgs(args);
        return this;
    }

    @Override
    default List<String> getArgs() {

	"strconv"
)

type argvalues struct {
	osargs []string
	goos   string
	goarch string
}

type argstate struct {
	state       argvalues
	initialized bool
}

func (a *argstate) Merge(state argvalues) {
	if !a.initialized {
		a.state = state
		a.initialized = true
		return
	}
	if !slices.Equal(a.state.osargs, state.osargs) {
		a.state.osargs = nil
	}
	if state.goos != a.state.goos {

        return this;
    }

    @Override
    public JavaExecSpec setArgs(@Nullable List<String> arguments) {
        argumentsSpec.setArgs(arguments);
        return this;
    }

    @Override
    public JavaExecSpec setArgs(@Nullable Iterable<?> arguments) {
        argumentsSpec.setArgs(arguments);
        return this;
    }

    @Nullable
    @Override