case ASUBW:
			p.As, p.From.Offset = AADDIW, -p.From.Offset
		case ASLLW:
			p.As = ASLLIW
		case ASRLW:
			p.As = ASRLIW
		case ASRAW:
			p.As = ASRAIW
		case AROR:
			p.As = ARORI
		case ARORW:
			p.As = ARORIW
		case ABCLR:
			p.As = ABCLRI
		case ABEXT:
			p.As = ABEXTI
		case ABINV:
			p.As = ABINVI
		case ABSET:
			p.As = ABSETI
		}
	}

	switch p.As {
	case obj.AJMP:

			return
		}
		switch msgp.UnsafeString(field) {
		case "Name":
			z.Name, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Name")
				return
			}
		case "Created":
			z.Created, bts, err = msgp.ReadTimeBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Created")
				return
			}
		case "Deleted":
			z.Deleted, bts, err = msgp.ReadTimeBytes(bts)

	}
	return p
}

func cpuProfilingBroken() bool {
	switch runtime.GOOS {
	case "plan9":
		// Profiling unimplemented.
		return true
	case "aix":
		// See https://golang.org/issue/45170.
		return true
	case "ios", "dragonfly", "netbsd", "illumos", "solaris":
		// See https://golang.org/issue/13841.
		return true
	case "openbsd":
		if runtime.GOARCH == "arm" || runtime.GOARCH == "arm64" {

	switch under(typ).(type) {
	case *Array:
		return "array"
	case *Slice:
		return "slice"
	case *Struct:
		return "struct"
	case *Pointer:
		return "pointer"
	case *Signature:
		return "func"
	case *Interface:
		if isTypeParam(typ) {
			return check.sprintf("type parameter %s", typ)
		}
		return "interface"
	case *Map:
		return "map"
	case *Chan:
		return "chan"
	default:

func computeRZlog(userSize uintptr) uintptr {
	switch {
	case userSize <= (64 - 16):
		return 16 << 0
	case userSize <= (128 - 32):
		return 16 << 1
	case userSize <= (512 - 64):
		return 16 << 2
	case userSize <= (4096 - 128):
		return 16 << 3
	case userSize <= (1<<14)-256:
		return 16 << 4
	case userSize <= (1<<15)-512:
		return 16 << 5
	case userSize <= (1<<16)-1024:
		return 16 << 6
	default:

					switch msgp.UnsafeString(field) {
					case "b":
						za0002.Bucket, err = dc.ReadString()
						if err != nil {
							err = msgp.WrapError(err, "Entries", za0001, "Bucket")
							return
						}
					case "o":
						za0002.Object, err = dc.ReadString()
						if err != nil {
							err = msgp.WrapError(err, "Entries", za0001, "Object")
							return
						}
					case "rc":

	switch under(typ).(type) {
	case *Array:
		return "array"
	case *Slice:
		return "slice"
	case *Struct:
		return "struct"
	case *Pointer:
		return "pointer"
	case *Signature:
		return "func"
	case *Interface:
		if isTypeParam(typ) {
			return check.sprintf("type parameter %s", typ)
		}
		return "interface"
	case *Map:
		return "map"
	case *Chan:
		return "chan"
	default:

			switch node.(type) {
			case *syntax.File:
				kind = "file"
			case *syntax.FuncType:
				kind = "func"
			case *syntax.BlockStmt:
				kind = "block"
			case *syntax.IfStmt:
				kind = "if"
			case *syntax.SwitchStmt:
				kind = "switch"
			case *syntax.SelectStmt:
				kind = "select"
			case *syntax.CaseClause:
				kind = "case"
			case *syntax.CommClause:
				kind = "comm"

	push *model.PushContext,
) []*listener.Listener {
	builder := NewListenerBuilder(node, push)

	switch node.Type {
	case model.SidecarProxy:
		builder = configgen.buildSidecarListeners(builder)
	case model.Waypoint:
		builder = configgen.buildWaypointListeners(builder)
	case model.Router:
		builder = configgen.buildGatewayListeners(builder)
	}

	builder.patchListeners()
	l := builder.getListeners()

		return &model.Proxy{ConfigNamespace: ns}
	}
	cases := []struct {
		name            string
		cfg             []Configer
		proxy           *model.Proxy
		routeName       string
		expected        map[string][]string
		expectedGateway map[string][]string
		oldestWins      bool
	}{
		// Port 80 has special cases as there is defaulting logic around this port
		{
			name: "simple port 80",