// Expressions

func walkBinary(e *ast.BinaryExpr) (has4, has5 bool, maxProblem int) {
	switch e.Op.Precedence() {
	case 4:
		has4 = true
	case 5:
		has5 = true
	}

	switch l := e.X.(type) {
	case *ast.BinaryExpr:
		if l.Op.Precedence() < e.Op.Precedence() {
			// parens will be inserted.
			// pretend this is an *ast.ParenExpr and do nothing.
			break
		}

            val incDecPrecedence = when (psi) {
                is KtPostfixExpression -> KaCompoundAccess.IncOrDecOperation.Precedence.POSTFIX
                else -> KaCompoundAccess.IncOrDecOperation.Precedence.PREFIX
            }
            val incOrDecOperationKind = psi.getInOrDecOperationKind()
            val baseExpression = deparenthesize(psi.baseExpression)

				// We must enforce flag precedence by re-parsing the command line into the new object.
				// This is necessary to preserve backwards-compatibility across binary upgrades.
				// See issue #56171 for more details.
				if err := kubeletConfigFlagPrecedence(kubeletConfig, args); err != nil {
					return fmt.Errorf("failed to precedence kubeletConfigFlag: %w", err)
				}

					Attributes: ServiceAttributes{
						Name:      "foo",
						Namespace: "ns",
					},
				},
			},
			nil,
		},
		{
			"no-sidecar-config-k8s-service-take-precedence",
			nil,
			services25,
			nil,
			[]*Service{
				{
					Hostname: "foobar.svc.cluster.local",
					Ports:    port7443,
					Attributes: ServiceAttributes{
						Name:      "bar",

    visibility = ["//visibility:public"],
)

# This condition takes precedence over :linux_x86_64
config_setting(
    name = "linux_x86_64_no_sse",
    values = {
        "cpu": "k8",
        "copt": "-mno-sse4.2",
    },
    visibility = ["//visibility:public"],
)

# This condition takes precedence over :linux_x86_64
# TODO(b/290533709): Remove this with PJRT build rule cleanup.
config_setting(

			},
			expectedGateway: map[string][]string{
				// No overrides, use default
				"alt-known.default.svc.cluster.local": {"outbound|80||alt-known.default.svc.cluster.local"},
				// Explicit has precedence
				"known.default.svc.cluster.local": {"outbound|80||explicit.example.com"},
				// Last is our wildcard
				"*.cluster.local": {"outbound|80||wild.example.com"},
			},
			oldestWins: true,
		},
		{

				},
				"test-duplicate-domains.default:80": {"test-duplicate-domains.default"},
			},
			map[string]string{
				"allow_any": "PassthroughCluster",
				// Virtual service destination takes precedence
				"test-duplicate-domains.default.svc.cluster.local:80": "outbound|80||test-duplicate-domains.default",
				"test-duplicate-domains.default:80":                   "outbound|80||test-duplicate-domains.default",
			},
		},

    // end_mask.
    revised_begin_mask |= strided_slice_op.getNewAxisMask();
    revised_end_mask |= strided_slice_op.getNewAxisMask();

    // Enforce operator precedence.
    uint64_t revised_shrink_axis_mask = strided_slice_op.getShrinkAxisMask() &
                                        ~strided_slice_op.getNewAxisMask();

    auto attribute_type = rewriter.getIntegerType(64);

		if operations.Authority != "" && action.HostRewriteSpecifier == nil {
			// Ideally, if the weighted cluster overwrites authority, it has precedence. This mirrors behavior of headers,
			// because for headers we append the weighted last which allows it to Set and wipe out previous Adds.

func (p *parser) parseBinaryExpr(lhs bool, prec1 int) ast.Expr {
	if p.trace {
		defer un(trace(p, "BinaryExpr"))
	}

	x := p.parseUnaryExpr(lhs)
	for prec := p.tok.Precedence(); prec >= prec1; prec-- {
		for p.tok.Precedence() == prec {
			pos, op := p.pos, p.tok
			p.next()
			if lhs {
				p.resolve(x)
				lhs = false
			}
			y := p.parseBinaryExpr(false, prec+1)