log.Errorf("CRD %v version %v invalid; ignoring: %v", crd.Name, bv, err)
		return false
	}
	// Ignore RC tags, etc. We 'round up' those.
	nv, err := fv.SetPrerelease("")
	if err != nil {
		log.Errorf("CRD %v version %v invalid; ignoring: %v", crd.Name, bv, err)
		return false
	}
	fv = &nv
	if fv.LessThan(mv) {
		log.Infof("CRD %v version %v is below minimum version %v, ignoring", crd.Name, fv, mv)
		return false
	}

mr: मराठी
ms: Bahasa Malaysia
mt: Malti
my: ဗမာစာ
na: Ekakairũ Naoero
nb: Norsk bokmål
nd: isiNdebele
ne: नेपाली
ng: Owambo
nl: Nederlands
nn: Norsk nynorsk
'no': Norsk
nr: isiNdebele
nv: Diné bizaad
ny: chiCheŵa
oc: occitan
oj: ᐊᓂᔑᓈᐯᒧᐎᓐ
om: Afaan Oromoo
or: ଓଡ଼ିଆ
os: ирон æвзаг
pa: ਪੰਜਾਬੀ
pi: पाऴि
pl: Polski
ps: پښتو
pt: português
qu: Runa Simi

					}
				case metav1.LabelSelectorOpNotIn:
					v, ok := podLabels[me.Key]
					if !ok {
						continue
					}
					for _, nv := range me.Values {
						if nv == v {
							return fmt.Sprintf("Pod has %s=%s label, preventing injection", me.Key, v), false
						}
					}
				}
			}
		} else if podMatched {

	CINC	NV, R2, R3                                       // ERROR "invalid condition"
	CINVW	AL, R2, R3                                       // ERROR "invalid condition"
	CINV	NV, R2, R3                                       // ERROR "invalid condition"
	CNEG	AL, R2, R3                                       // ERROR "invalid condition"

	return resourcesStringImpl(r.Root, "")
}

func resourcesStringImpl(node any, prefix string) string {
	out := ""
	if node == nil {
		return ""
	}
	nv := node.(map[string]any)
	for k, n := range nv {
		out += prefix + k + "\n"
		out += resourcesStringImpl(n, prefix+"  ")
	}

	return out
}

// PodKey returns a unique key based on the namespace and pod name.

				err = msgp.WrapError(err, "Object")
				return
			}
		case "no":
			z.NumObjects, err = dc.ReadUint64()
			if err != nil {
				err = msgp.WrapError(err, "NumObjects")
				return
			}
		case "nv":
			z.NumVersions, err = dc.ReadUint64()
			if err != nil {
				err = msgp.WrapError(err, "NumVersions")
				return
			}
		case "bs":
			z.Bytes, err = dc.ReadUint64()
			if err != nil {

	"cmd/internal/obj"
	"fmt"
)

var strcond = [16]string{
	"EQ",
	"NE",
	"HS",
	"LO",
	"MI",
	"PL",
	"VS",
	"VC",
	"HI",
	"LS",
	"GE",
	"LT",
	"GT",
	"LE",
	"AL",
	"NV",
}

func init() {
	obj.RegisterRegister(obj.RBaseARM64, REG_SPECIAL+1024, rconv)
	obj.RegisterOpcode(obj.ABaseARM64, Anames)
	obj.RegisterRegisterList(obj.RegListARM64Lo, obj.RegListARM64Hi, rlconv)

				heap.Push(priq, v)
			}
		}

		// Produce the schedule. Pick the highest priority scheduleable value,
		// add it to the schedule, add any of its uses that are now scheduleable
		// to the queue, and repeat.
		nv := len(b.Values)
		b.Values = b.Values[:0]
		for priq.Len() > 0 {
			// Schedule the next schedulable value in priority order.
			v := heap.Pop(priq).(*Value)
			b.Values = append(b.Values, v)

000000b0  c5 aa 8d 7d f2 ef f3 40  22 9d db d3 83 49 45 94  |...}...@"....IE.|
000000c0  96 c6 85 74 ac f1 64 e2  80 7a 47 1e c1 f7 45 bb  |...t..d..zG...E.|
000000d0  6e 56 b5 5b 90 1f 11 6e  47 d5 52 b7 5d d3 02 80  |nV.[...nG.R.]...|
000000e0  55 59 94 53 05 ab 5c aa  18 f8 7d d0 24 1d 6f 7a  |UY.S..\...}.$.oz|
000000f0  c7 8e e9 80 61 dc b3 2b  c0 74 09 d3 58 be e9 cb  |....a..+.t..X...|

		if inv.Patch > -1 {
			if r := compareVersion(pversion.Patch, inv.Patch); r != 0 {
				return r
			}
		}
	}
	return 0
}

func compareVersion(ov, nv int) int {
	if ov == nv {
		return 0
	}
	if ov < nv {
		return -1
	}
	return 1
}

var NodeTypes = [...]NodeType{SidecarProxy, Router, Waypoint, Ztunnel}