}
		return i, pallocChunkPages - 1
	}
	// Clear searchAddr, because we've exhausted the heap.
	cursor.Clear()
	return 0, 0
}

// alloc updates metadata for chunk at index ci with the fact that
// an allocation of npages occurred. It also eagerly attempts to collapse
// the chunk's memory into hugepage if the chunk has become sufficiently
// dense and we're not allocating the whole chunk at once (which suggests

	"internal/bytealg"
	"internal/goarch"
	"internal/stringslite"
	"runtime/internal/sys"
	"unsafe"
)

// The code in this file implements stack trace walking for all architectures.
// The most important fact about a given architecture is whether it uses a link register.
// On systems with link registers, the prologue for a non-leaf function stores the
// incoming value of LR at the bottom of the newly allocated stack frame.

.Mapping plugin IDs to dependency coordinates
====
include::sample[dir="snippets/kotlinDsl/androidSingleBuild/kotlin",files="settings.gradle.kts[tags=android];build.gradle.kts[tags=android]"]
====

		if err != nil {
			t.Fatalf("Failed to create pod: %v", err)
		}
	}

	// Block until the fake clientset writes are observable in the informer caches.
	// FUN FACT: This guarantees that the informer caches have updated, but it does
	// not guarantee that informer event handlers have completed. Fortunately,
	// DisruptionController does most of its logic by reading from informer

							t.Skip("https://github.com/istio/istio/issues/37307: " +
								"Source IP-based authz tests are not supported in multi-network configurations " +
								"due to the fact that the origin source IP will be lost when traversing the " +
								"east-west gateway.")
						}
					}

					cases := []struct {
						path    string
						headers http.Header

        // hasPackageName() will return true if ConstructedClassWithPackage#className has no dots.
        // but since the prefix may have them and the code there does ignore that
        // fact. We check here for ConstructedClassWithPackage.
        if (!type.hasPackageName() && module.hasPackageName() && !(type instanceof ConstructedClassWithPackage)) {
            type.setName(module.getPackageName() + name);

		// it does concurrently to both requests.  For the first request this should make the client
		// get a timeout response without directly affecting execution.  For the second request, the
		// fact that the timeout filter closes the request's Context.Done() causes the request to be
		// promptly ejected from its queue.  The goroutine doing the APF handling writes an HTTP
		// response message with status 429.

// - a C_HIDEXT which will be a csect containing all of its functions
// It needs several parameters to create .csect symbols such as its entry point and its section number.
//
// Currently, a new file is in fact a new package. It seems to be OK, but it might change
// in the future.
func (f *xcoffFile) writeSymbolNewFile(ctxt *Link, name string, firstEntry uint64, extnum int16) {
	ldr := ctxt.loader
	/* C_FILE */

            // highlighting
            if (highlightInfo != null) {
                buildHighlighter(queryHelper, queryFieldConfig, fessConfig);
            }

            // facets
            if (facetInfo != null) {
                buildFacet(queryHelper, queryFieldConfig, fessConfig);
            }

// were to just `_ = foo()` within a test function, the compiler could
// correctly deduce that foo() does nothing and doesn't need to be
// called. By writing results to a global variable, we hide that fact
// from the compiler and force it to keep the code under test.
var (
	sinkIP          Addr
	sinkStdIP       net.IP
	sinkAddrPort    AddrPort
	sinkPrefix      Prefix
	sinkPrefixSlice []Prefix