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}

					switch msgp.UnsafeString(field) {
					case "ts":
						za0002.TotalSize, err = dc.ReadUint64()
						if err != nil {
							err = msgp.WrapError(err, "Tiers", za0001, "TotalSize")
							return
						}
					case "nv":
						za0002.NumVersions, err = dc.ReadInt()
						if err != nil {
							err = msgp.WrapError(err, "Tiers", za0001, "NumVersions")
							return
						}
					case "no":
						za0002.NumObjects, err = dc.ReadInt()

00000000  17 03 03 00 1e 97 3a d5  e2 f1 22 da d5 0a 3a 2c  |......:..."...:,|
00000010  c1 c0 53 ff 44 bd 06 02  02 eb b6 91 c5 b3 d7 c7  |..S.D...........|
00000020  c2 6e 56 17 03 03 00 13  af c2 91 94 6e db 5e 62  |.nV.........n.^b|

00000130  d7 2f f0 23 51 a1 d3 71  68 9d 4c 01 98 a9 07 e0  |./.#Q..qh.L.....|
00000140  b0 fd f8 74 0c bc eb 5e  57 1d 48 65 ac 80 d4 f4  |...t...^W.He....|
00000150  4e 56 1d 89 ce ab 21 5e  5f a0 5c ed a3 e7 07 5d  |NV....!^_.\....]|
00000160  c3 d9 9d 31 62 e0 91 2b  c6 e2 5c f6 69 2a 06 b8  |...1b..+..\.i*..|
00000170  e1 24 92 39 7b 06 58 72  a1 84 87 c4 e9 53 83 12  |.$.9{.Xr.....S..|

00000160  2c 21 b1 68 9e 09 74 76  77 65 f4 85 07 dc f3 0e  |,!.h..tvwe......|
00000170  27 97 4d 60 47 35 31 13  92 15 90 f4 ca 24 84 6e  |'.M`G51......$.n|
00000180  da 91 13 a3 37 54 4e 52  d4 9c 2f 82 6e 76 fd d7  |....7TNR../.nv..|
00000190  81 29 fa 76 ac be 32 04  0d 7e d0 09 b0 47 ff 6d  |.).v..2..~...G.m|
000001a0  37 32 6d 2c 8e d3 06 94  da 3f 20 87 56 f8 4a 2f  |72m,.....? .V.J/|

	appendError := func(err, err2 error) error {
		if err == nil {
			return err2
		} else if err2 == nil {
			return err
		}
		return multierror.Append(err, err2)
	}

	for _, nv := range vs {
		switch t := nv.(type) {
		case Validation:
			v.Err = appendError(v.Err, t.Err)
			v.Warning = appendError(v.Warning, t.Warning)
		default:
			v.Err = appendError(v.Err, t)
		}
	}
	return v
}

	ReplicationState ReplicationState `msg:"rs"` // Internal replication state to be passed back in ObjectInfo

	Data []byte `msg:"d,allownil"` // optionally carries object data

	NumVersions      int       `msg:"nv"`
	SuccessorModTime time.Time `msg:"smt"`

	Fresh bool `msg:"fr"` // indicates this is a first time call to write FileInfo.

	// Position of this version or object in a multi-object delete call,

		}
	}
	if len(args) == arrow+3 {
		nv, err = parseVersion(verb, ns, &args[arrow+2], fix)
		if err != nil {
			return nil, wrapError(err)
		}
		if IsDirectoryPath(ns) {
			return nil, errorf("replacement module directory path %q cannot have version", ns)
		}
	}
	return &Replace{
		Old:    module.Version{Path: s, Version: v},
		New:    module.Version{Path: ns, Version: nv},
		Syntax: line,
	}, nil
}

		s.blockOrder[b.ID] = int32(i)
	}

	s.regs = make([]regState, s.numRegs)
	nv := f.NumValues()
	if cap(s.f.Cache.regallocValues) >= nv {
		s.f.Cache.regallocValues = s.f.Cache.regallocValues[:nv]
	} else {
		s.f.Cache.regallocValues = make([]valState, nv)
	}
	s.values = s.f.Cache.regallocValues
	s.orig = s.f.Cache.allocValueSlice(nv)
	s.copies = make(map[*Value]bool)
	for _, b := range s.visitOrder {