// for reading from msg.Body.
func ReadMessage(r io.Reader) (msg *Message, err error) {
	tp := textproto.NewReader(bufio.NewReader(r))

	hdr, err := readHeader(tp)
	if err != nil && (err != io.EOF || len(hdr) == 0) {
		return nil, err
	}

	return &Message{
		Header: Header(hdr),
		Body:   tp.R,
	}, nil
}

// readHeader reads the message headers from r.

	Index    int
	Template *Template
}

func (tp *TemplateParam) print(ps *printState) {
	if tp.Template == nil {
		panic("TemplateParam Template field is nil")
	}
	if tp.Index >= len(tp.Template.Args) {
		panic("TemplateParam Index out of bounds")
	}
	ps.print(tp.Template.Args[tp.Index])
}

func (tp *TemplateParam) Traverse(fn func(AST) bool) {
	fn(tp)
	// Don't traverse Template--it points elsewhere in the AST.

	MOVV	$69, R2			// sys_setitimer
	SYSCALL
	RET

// func walltime() (sec int64, nsec int32)
TEXT runtime·walltime(SB), NOSPLIT, $32
	MOVW	CLOCK_REALTIME, R4	// arg 1 - clock_id
	MOVV	$8(R29), R5		// arg 2 - tp
	MOVV	$87, R2			// sys_clock_gettime
	SYSCALL

	MOVV	8(R29), R4		// sec
	MOVV	16(R29), R5		// nsec
	MOVV	R4, sec+0(FP)
	MOVW	R5, nsec+8(FP)

	RET

// int64 nanotime1(void) so really

			if named, f := svc.PortNames[int32(port.ServicePort)]; f && named.TargetPortName != "" {
				// Pods only match on TargetPort names
				tp, ok := FindPortName(p, named.TargetPortName)
				if !ok {
					// Port not present for this workload. Exclude the port entirely
					continue
				}
				targetPort = uint32(tp)
			}

			pl.Ports = append(pl.Ports, &workloadapi.Port{
				ServicePort: port.ServicePort,
				TargetPort:  targetPort,

func collectResourcePaths(t *testing.T, resourcename string, path *field.Path, name string, tp reflect.Type) sets.Set[string] {
	resourcename = strings.ToLower(resourcename)
	resourcePaths := sets.New[string]()

	if tp.Kind() == reflect.Pointer {
		resourcePaths.Insert(sets.List[string](collectResourcePaths(t, resourcename, path, name, tp.Elem()))...)
		return resourcePaths
	}

		st.advance(2)
		name := mk("$T", &st.typeTemplateParamCount)
		tp := &TypeTemplateParam{
			Name: name,
		}
		return tp, name
	case 'k':
		st.advance(2)
		constraint, _ := st.name()
		name := mk("$T", &st.typeTemplateParamCount)
		tp := &ConstrainedTypeTemplateParam{
			Name:       name,
			Constraint: constraint,
		}
		return tp, name
	case 'n':
		st.advance(2)

	SYS_SETSOCKOPT               = 105 // { int setsockopt(int s, int level, int name, \
	SYS_LISTEN                   = 106 // { int listen(int s, int backlog); }
	SYS_GETTIMEOFDAY             = 116 // { int gettimeofday(struct timeval *tp, \
	SYS_GETRUSAGE                = 117 // { int getrusage(int who, \
	SYS_GETSOCKOPT               = 118 // { int getsockopt(int s, int level, int name, \
	SYS_READV                    = 120 // { int readv(int fd, struct iovec *iovp, \

	MOVD	F0, 4(X5)				// 27b20200
	MOVD	F0, F1					// d3000022

	// TLS load with local-exec (LUI + ADDIW + ADD of TP + load)
	MOV	tls(SB), X5				// b70f00009b8f0f00b38f4f0083b20f00
	MOVB	tls(SB), X5				// b70f00009b8f0f00b38f4f0083820f00

	// TLS store with local-exec (LUI + ADDIW + ADD of TP + store)
	MOV	X5, tls(SB)				// b70f00009b8f0f00b38f4f0023b05f00
	MOVB	X5, tls(SB)				// b70f00009b8f0f00b38f4f0023805f00

	}

	exp := tracetest.NewInMemoryExporter()
	tp := sdktrace.NewTracerProvider(
		sdktrace.WithSyncer(exp),
	)
	kubelet.tracer = tp.Tracer(instrumentationScope)

	fakeRuntime, endpoint := createAndStartFakeRemoteRuntime(t)
	defer func() {
		fakeRuntime.Stop()
	}()
	runtimeSvc := createRemoteRuntimeService(endpoint, t, tp)
	kubelet.runtimeService = runtimeSvc

	SizeofMsghdr          = 0x38
	SizeofCmsghdr         = 0x10
)

const (
	SizeofSockFprog = 0x10
)

type PtraceRegs struct {
	Pc  uint64
	Ra  uint64
	Sp  uint64
	Gp  uint64
	Tp  uint64
	T0  uint64
	T1  uint64
	T2  uint64
	S0  uint64
	S1  uint64
	A0  uint64
	A1  uint64
	A2  uint64
	A3  uint64
	A4  uint64
	A5  uint64
	A6  uint64
	A7  uint64
	S2  uint64