print("r12    ", hex(c.r12()), "\n")
	print("r13    ", hex(c.r13()), "\n")
	print("r14    ", hex(c.r14()), "\n")
	print("r15    ", hex(c.r15()), "\n")
	print("rip    ", hex(c.rip()), "\n")
	print("rflags ", hex(c.rflags()), "\n")
	print("cs     ", hex(c.cs()), "\n")
	print("fs     ", hex(c.fs()), "\n")
	print("gs     ", hex(c.gs()), "\n")
}

//go:nosplit
//go:nowritebarrierrec

func (c *sigctxt) r15() uint64 { return c.regs().r15 }

//go:nosplit
//go:nowritebarrierrec
func (c *sigctxt) rip() uint64 { return c.regs().rip }

func (c *sigctxt) rflags() uint64  { return c.regs().rflags }
func (c *sigctxt) cs() uint64      { return c.regs().cs }
func (c *sigctxt) fs() uint64      { return c.regs().fs }
func (c *sigctxt) gs() uint64      { return c.regs().gs }

func (c *sigctxt) r15() uint64 { return c.regs().__gregs[_REG_R15] }

//go:nosplit
//go:nowritebarrierrec
func (c *sigctxt) rip() uint64 { return c.regs().__gregs[_REG_RIP] }

func (c *sigctxt) rflags() uint64  { return c.regs().__gregs[_REG_RFLAGS] }
func (c *sigctxt) cs() uint64      { return c.regs().__gregs[_REG_CS] }
func (c *sigctxt) fs() uint64      { return c.regs().__gregs[_REG_FS] }

	print("r12     ", hex(r.r12), "\n")
	print("r13     ", hex(r.r13), "\n")
	print("r14     ", hex(r.r14), "\n")
	print("r15     ", hex(r.r15), "\n")
	print("rip     ", hex(r.rip), "\n")
	print("rflags  ", hex(r.eflags), "\n")
	print("cs      ", hex(r.segcs), "\n")
	print("fs      ", hex(r.segfs), "\n")
	print("gs      ", hex(r.seggs), "\n")
}

type _DISPATCHER_CONTEXT struct {
	controlPc        uint64

	uc_onstack  int32
	uc_sigmask  uint32
	uc_stack    stackt
	uc_link     *ucontext
	uc_mcsize   uint64
	uc_mcontext *mcontext64
}

type keventt struct {
	ident  uint64
	filter int16
	flags  uint16
	fflags uint32
	data   int64
	udata  *byte
}

type pthread uintptr
type pthreadattr struct {
	X__sig    int64
	X__opaque [56]int8
}
type pthreadmutex struct {
	X__sig    int64

	_       [6]byte
}

type BpfZbufHeader struct {
	Kernel_gen uint32
	Kernel_len uint32
	User_gen   uint32
	_          [5]uint32
}

type Termios struct {
	Iflag  uint32
	Oflag  uint32
	Cflag  uint32
	Lflag  uint32
	Cc     [20]uint8
	Ispeed uint32
	Ospeed uint32
}

type Winsize struct {
	Row    uint16
	Col    uint16
	Xpixel uint16
	Ypixel uint16
}

const (

package echo

import (
	"flag"
	"time"

	"istio.io/istio/pkg/test/util/retry"
)

var (
	callTimeout      = 30 * time.Second
	callDelay        = 20 * time.Millisecond
	callConverge     = 3
	readinessTimeout = 10 * time.Minute
	callsPerWorkload = 3
)

// init registers the command-line flags that we can exposed for "go test".
func init() {

					flags.Usage()
				}
			}
		} else {
			if !hasValue {
				fmt.Fprintf(flags.Output(), "go: flag needs an argument: %s (from %s)\n", name, where)
				flags.Usage()
			}
			if err := flags.Set(f.Name, value); err != nil {
				fmt.Fprintf(flags.Output(), "go: invalid value %q for flag %s (from %s): %v\n", value, name, where, err)
				flags.Usage()

package istio

import (
	"flag"
)

// init registers the command-line flags that we can exposed for "go test".
func init() {
	flag.StringVar(&settingsFromCommandline.SystemNamespace, "istio.test.kube.systemNamespace", settingsFromCommandline.SystemNamespace,
		"Specifies the namespace where the istiod resides in a typical deployment. Defaults to istio-system")

env GOFLAGS=-f
! go list runtime
stderr '^go: flag needs an argument: -f \(from (\$GOFLAGS|%GOFLAGS%)\)$'

env GOFLAGS=-e=asdf
! go list runtime
stderr '^go: invalid boolean value \"asdf\" for flag -e \(from (\$GOFLAGS|%GOFLAGS%)\)'

# except in go bug (untested) and go env
go env
stdout GOFLAGS

# Flags listed in GOFLAGS should be safe to duplicate on the command line.
env GOFLAGS=-tags=magic