ISTIO_META_ENABLE_HBONE: "true"
global:
  variant: distroless
pilot:
  env:
    PILOT_ENABLE_AMBIENT: "true"
cni:
  ambient:
    enabled: true

# Ztunnel doesn't use a namespace, so everything here is mostly for ztunnel

def operation = factory.$operation([
   ${operands.indexed().collect { i, e -> "operand$i" }.join(",\n   ")}
] as Set)
"""
    }

    private String toExclude(it) {
        if (it == 'excludes everything') {
            return 'everything()'
        }
        assert it instanceof Map
        assert it.keySet().size() == 1
        String key = it.keySet()[0]
        Object value = it[key]
        toExclude(key, value)
    }

	logger.V(3).Info("Cache comparer started")
	defer logger.V(3).Info("Cache comparer finished")

	nodes, err := c.NodeLister.List(labels.Everything())
	if err != nil {
		return err
	}

	pods, err := c.PodLister.List(labels.Everything())
	if err != nil {
		return err
	}

	dump := c.Cache.Dump()

	pendingPods, _ := c.PodQueue.PendingPods()

	if m&0o22 == 0o22 { // group and world are unwritable by default
		return 0o700
	}
	if m&0o2 == 0o2 { // group is writable by default, but not world
		return 0o770
	}
	return 0o777 // everything is writable by default

            // this repository *only* contains artifacts with group "my.company"
            includeGroup("my.company")
        }
    }
    mavenCentral {
        content {
            // this repository contains everything BUT artifacts with group starting with "my.company"
            excludeGroupByRegex("my\\.company.*")
        }
    }
}
// end::repository-filter[]

// tag::exclusive-repository-filter[]
repositories {

     * <ul>
     * <li>{@code *} = everything,</li>
     * <li>{@code external:*} = everything not on the localhost and not file based,</li>
     * <li>{@code external:http:*} = any repository not on the localhost using HTTP,</li>
     * <li>{@code repo,repo1} = {@code repo} or {@code repo1},</li>
     * <li>{@code *,!repo1} = everything except {@code repo1}.</li>
     * </ul>
     *

[!cgo] skip
[cross] skip

# Assume we're on a system that can enable cgo normally.
env CGO_ENABLED=
go env CGO_ENABLED
stdout 1

# Clearing CC and removing everything but Go from the PATH should usually
# disable cgo: no C compiler anymore (unless the baked-in defaultCC is an
# absolute path and exists.
env CC=
env PATH=$GOROOT/bin
go env CGO_ENABLED
[!abscc] stdout 0

@file:Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")

package okhttp3

import java.net.CookieHandler

/**
 * A cookie jar that delegates to a [java.net.CookieHandler].
 *
 * This implementation delegates everything to [okhttp3.java.net.cookiejar.JavaNetCookieJar], which
 * conforms to the package-naming limitations of JPMS.
 *
 * Callers should prefer to use [okhttp3.java.net.cookiejar.JavaNetCookieJar] directly.
 */

package p

//go:noinline
func nonleaf() {}

const truth = true

func f() int { // ERROR "can inline f"
	if truth {
		return 0
	}
	// If everything below is removed, as it should,
	// function f should be inlineable.
	nonleaf()
	for {
		panic("")
	}
}

func g() int { // ERROR "can inline g"
	return f() // ERROR "inlining call to f"
}

	if !cache.WaitForNamedCacheSync("crd-autoregister", stopCh, c.crdSynced) {
		return
	}

	// process each item in the list once
	if crds, err := c.crdLister.List(labels.Everything()); err != nil {
		utilruntime.HandleError(err)
	} else {
		for _, crd := range crds {
			for _, version := range crd.Spec.Versions {