case C_S16CON:
		return cmp(C_U15CON, b)
	case C_U16CON:
		return cmp(C_U15CON, b)
	case C_16CON:
		return cmp(C_S16CON, b) || cmp(C_U16CON, b)
	case C_U31CON:
		return cmp(C_U16CON, b)
	case C_U32CON:
		return cmp(C_U31CON, b)
	case C_S32CON:
		return cmp(C_U31CON, b) || cmp(C_S16CON, b)
	case C_32CON:
		return cmp(C_S32CON, b) || cmp(C_U32CON, b)
	case C_S34CON:

	)
	// Send cases.
	select {
	case ccr <- cr:
	case ccr <- c:
	}
	select {
	case ccs <- cs:
	case ccs <- c:
	}
	select {
	case ccr <- c:
	default:
	}
	// Receive cases.
	select {
	case cr = <-cc:
	case cs = <-cc:
	case c = <-cc:
	}
	select {
	case cr = <-cc:
	default:
	}
	select {
	case cr, ok = <-cc:
	case cs, ok = <-cc:
	case c = <-cc:
	}
      // Interfaces.

	case *ExprStmt:
		Walk(v, n.X)

	case *SendStmt:
		Walk(v, n.Chan)
		Walk(v, n.Value)

	case *IncDecStmt:
		Walk(v, n.X)

	case *AssignStmt:
		walkList(v, n.Lhs)
		walkList(v, n.Rhs)

	case *GoStmt:
		Walk(v, n.Call)

	case *DeferStmt:
		Walk(v, n.Call)

	case *ReturnStmt:
		walkList(v, n.Results)

	case *BranchStmt:
		if n.Label != nil {
			Walk(v, n.Label)
		}

	case DestinationRule_v1beta1:
		return false
	case DestinationRule_v1:
		return false
	case EndpointSlice:
		return false
	case Endpoints:
		return false
	case EnvoyFilter:
		return false
	case GRPCRoute:
		return false
	case GRPCRoute_v1alpha2:
		return false
	case Gateway:
		return false
	case Gateway_v1beta1:
		return false
	case Gateway_v1:
		return false
	case GatewayClass:

	case ObjectAccessedHead:
		return "s3:ObjectAccessed:Head"
	case ObjectAccessedAttributes:
		return "s3:ObjectAccessed:Attributes"
	case ObjectCreatedAll:
		return "s3:ObjectCreated:*"
	case ObjectCreatedCompleteMultipartUpload:
		return "s3:ObjectCreated:CompleteMultipartUpload"
	case ObjectCreatedCopy:
		return "s3:ObjectCreated:Copy"
	case ObjectCreatedPost:
		return "s3:ObjectCreated:Post"
	case ObjectCreatedPut:

func f4(e interface{}) {
	switch e.(type) {
	case int:
	case int: // ERROR "duplicate case int in type switch"
	case int64:
	case error:
	case error: // ERROR "duplicate case error in type switch"
	case fmt.Stringer:
	case fmt.Stringer: // ERROR "duplicate case fmt.Stringer in type switch"
	case struct {
		i int "tag1"
	}:
	case struct {
		i int "tag2"
	}:

		switch f*100 + t {
		default:
			println("missing case", i, v, f, t)
			w = v

		case ti8*100 + ti8:
			i8 = int8(v); i8 = int8(i8); w = big(i8)
		case ti8*100 + tu8:
			i8 = int8(v); u8 = uint8(i8); w = big(u8)
		case ti8*100 + ti16:
			i8 = int8(v); i16 = int16(i8); w = big(i16)
		case ti8*100 + tu16:
			i8 = int8(v); u16 = uint16(i8); w = big(u16)
		case ti8*100 + ti32:

	case AVACCQ:
		return op_VACC, 4, 0
	case AVAC:
		return op_VAC, 0, 0
	case AVACQ:
		return op_VAC, 4, 0
	case AVMSLG, AVMSLEG, AVMSLOG, AVMSLEOG:
		return op_VMSL, 3, 0
	case AVACCC:
		return op_VACCC, 0, 0
	case AVACCCQ:
		return op_VACCC, 4, 0
	case AVN:
		return op_VN, 0, 0
	case AVNC:
		return op_VNC, 0, 0
	case AVAVG:
		return op_VAVG, 0, 0
	case AVAVGB:
		return op_VAVG, 0, 0
	case AVAVGH:

		return 36
	case 7:
		return 49
	case 8:
		return 64
	default:
		return x * x
	}
}

// use jump tables for 8+ string lengths
func length(x string) int {
	// amd64:`JMP\s\(.*\)\(.*\)$`
	// arm64:`MOVD\s\(R.*\)\(R.*<<3\)`,`JMP\s\(R.*\)$`
	switch x {
	case "a":
		return 1
	case "bb":
		return 2
	case "ccc":
		return 3
	case "dddd":
		return 4
	case "eeeee":
		return 5
	case "ffffff":

	case *ast.DeferStmt:
		return 1 << nDeferStmt
	case *ast.Ellipsis:
		return 1 << nEllipsis
	case *ast.EmptyStmt:
		return 1 << nEmptyStmt
	case *ast.ExprStmt:
		return 1 << nExprStmt
	case *ast.Field:
		return 1 << nField
	case *ast.FieldList:
		return 1 << nFieldList
	case *ast.File:
		return 1 << nFile
	case *ast.ForStmt:
		return 1 << nForStmt
	case *ast.FuncDecl:
		return 1 << nFuncDecl