// Append LRS related options.
	opts = append(opts, option.LoadStatsConfigJSONStr(cfg.Node))

	// TODO: allow reading a file with additional metadata (for example if created with
	// 'envref'. This will allow Istio to generate the right config even if the pod info
	// is not available (in particular in some multi-cluster cases)
	return option.NewTemplateParams(opts...)
}

<component name="ProjectDictionaryState">
  <dictionary name="svyatoslav.kuzmich">
    <words>
      <w>anyfunc</w>
      <w>copysign</w>
      <w>eqref</w>
      <w>exnref</w>
      <w>externref</w>
      <w>funcref</w>
      <w>jetbrains</w>
      <w>kotlinx</w>
      <w>ktor</w>
      <w>optref</w>
      <w>popcnt</w>
      <w>rotl</w>
      <w>rotr</w>
      <w>simd</w>
      <w>sqrt</w>
      <w>testsuite</w>

}

func mustNewEnvSet(ver *version.Version, opts []VersionedOptions) *EnvSet {
	envSet, err := newEnvSet(ver, opts)
	if err != nil {
		panic(fmt.Sprintf("Default environment misconfigured: %v", err))
	}
	return envSet
}

// NewExpressionsEnv returns the NewExpressions environment Type for this EnvSet.
// See NewExpressions for details.
func (e *EnvSet) NewExpressionsEnv() *cel.Env {
	return e.newExpressions
}

	loadFn func(envSet *environment.EnvSet) *cel.Env
}

func (pe alwaysNewEnvLoader) RuleEnv(envSet *environment.EnvSet, _ string) *cel.Env {
	return pe.loadFn(envSet)
}

func (pe alwaysNewEnvLoader) MessageExpressionEnv(envSet *environment.EnvSet, _ string) *cel.Env {
	return pe.loadFn(envSet)
}

// Compile compiles all the XValidations rules (without recursing into the schema) and returns a slice containing a

	context = &CompositionEnv{
		MapType:           context.MapType,
		EnvSet:            context.EnvSet,
		CompiledVariables: map[string]CompilationResult{},
	}
	compiler := NewCompiler(context.EnvSet)
	filterCompiler := NewFilterCompiler(context.EnvSet)
	return &CompositedCompiler{
		Compiler:       compiler,
		FilterCompiler: filterCompiler,
		CompositionEnv: context,
	}
}

    public final inner class kotlin/jvm/internal/Ref$IntRef
}

public final class ContextKt

public final class Foo {
    // source: 'context.kt'
    public method <init>(): void
    private final static method test$call(p0: Foo, p1: java.lang.String, p2: kotlin.jvm.internal.Ref$IntRef, p3: int): void
    public final method test(p0: java.lang.String): void

	))
}

func mustBuildEnvs(baseEnv *environment.EnvSet) map[string]*environment.EnvSet {
	buildEnvSet := func(envOpts []cel.EnvOption, declTypes []*apiservercel.DeclType) *environment.EnvSet {
		env, err := baseEnv.Extend(environment.VersionedOptions{
			IntroducedVersion: version.MajorMinor(1, 0),
			EnvOptions:        envOpts,

func (fd *FD) SetsockoptInt(level, name, arg int) error {
	if err := fd.incref(); err != nil {
		return err
	}
	defer fd.decref()
	return syscall.SetsockoptInt(fd.Sysfd, level, name, arg)
}

// SetsockoptInet4Addr wraps the setsockopt network call with an IPv4 address.
func (fd *FD) SetsockoptInet4Addr(level, name int, arg [4]byte) error {
	if err := fd.incref(); err != nil {
		return err
	}
	defer fd.decref()

// File locking support for Plan 9. This uses fdMutex from the
// internal/poll package.

// incref adds a reference to the file. It returns an error if the file
// is already closed. This method is on File so that we can incorporate
// a nil test.
func (f *File) incref(op string) (err error) {
	if f == nil {
		return ErrInvalid
	}
	if !f.fdmu.Incref() {
		err = ErrClosed
		if op != "" {
			err = &PathError{Op: op, Path: f.name, Err: err}

// the internal/poll tests can not be in package poll.

package poll

var Consume = consume

type XFDMutex struct {
	fdMutex
}

func (mu *XFDMutex) Incref() bool {
	return mu.incref()
}

func (mu *XFDMutex) IncrefAndClose() bool {
	return mu.increfAndClose()
}

func (mu *XFDMutex) Decref() bool {
	return mu.decref()
}

func (mu *XFDMutex) RWLock(read bool) bool {