// live/dead over the same time period, so a good fit for batch
// allocation.

type BatchCounterAlloc struct {
	pool []uint32
}

func (ca *BatchCounterAlloc) AllocateCounters(n int) []uint32 {
	const chunk = 8192
	if n > cap(ca.pool) {
		siz := chunk
		if n > chunk {
			siz = n
		}
		ca.pool = make([]uint32, siz)
	}
	rv := ca.pool[:n]
	ca.pool = ca.pool[n:]
	return rv

	_ = x[passInlinableFuncToIndCallAdj-512]
	_ = x[passInlinableFuncToNestedIndCallAdj-1024]
	_ = x[returnFeedsConstToIfAdj-2048]
	_ = x[returnFeedsFuncToIndCallAdj-4096]
	_ = x[returnFeedsInlinableFuncToIndCallAdj-8192]
	_ = x[returnFeedsConcreteToInterfaceCallAdj-16384]
}

var _scoreAdjustTyp_value = [...]uint64{
	0x1,    /* panicPathAdj */
	0x2,    /* initFuncAdj */
	0x4,    /* inLoopAdj */
	0x8,    /* passConstToIfAdj */

		// Tell the server to return when we return.
		defer close(c)

		// Loop writing to the server. The server is not reading
		// anything, so this will eventually block, and then time out.
		b := bytes.Repeat([]byte{'a'}, 8192)
		cagain := 0
		for {
			n, err := ss.conn.fd.pfd.WriteOnce(b)
			if n > 0 {
				cagain = 0
			}
			switch err {
			case nil:
			case syscall.EAGAIN:
				if cagain == 0 {

        buffers.offer(buffer);
    }

    private byte[] takeBuffer() {
        byte[] buffer = buffers.poll();
        if (buffer == null) {
            buffer = new byte[8192];
        }
        return buffer;
    }

	// should stop at this function.
	TOPFRAME = 2048

	// Function is an ABI wrapper.
	ABIWRAPPER = 4096

	// Function is a compiler-generated package init function.
	PKGINIT = 8192

        given:
        def tasks = [
            ':docs:docs',
            ':docs:docsTest',
            "-D${StartParameterBuildOptions.ConfigurationCacheMaxProblemsOption.PROPERTY_NAME}=8192".toString(), // TODO:configuration-cache remove
        ]

        when:
        configurationCacheRun(tasks, 0)

        then:
        result.assertConfigurationCacheStateStored()

        when:

   * write to {@code sink()} and close it to complete the post.
   */
  static final class PipeBody extends RequestBody {
    private final Pipe pipe = new Pipe(8192);
    private final BufferedSink sink = Okio.buffer(pipe.sink());

    public BufferedSink sink() {
      return sink;
    }

    @Override public MediaType contentType() {
      return MEDIA_TYPE_MARKDOWN;

pkg debug/pe, const IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE = 32768
pkg debug/pe, const IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE ideal-int
pkg debug/pe, const IMAGE_DLLCHARACTERISTICS_WDM_DRIVER = 8192
pkg debug/pe, const IMAGE_DLLCHARACTERISTICS_WDM_DRIVER ideal-int
pkg debug/pe, const IMAGE_FILE_32BIT_MACHINE = 256
pkg debug/pe, const IMAGE_FILE_32BIT_MACHINE ideal-int
pkg debug/pe, const IMAGE_FILE_AGGRESIVE_WS_TRIM = 16

func BenchmarkDecode(b *testing.B) {
	data := make([]byte, StdEncoding.EncodedLen(8192))
	StdEncoding.Encode(data, make([]byte, 8192))
	buf := make([]byte, 8192)
	b.SetBytes(int64(len(data)))
	for i := 0; i < b.N; i++ {
		StdEncoding.Decode(buf, data)
	}
}
func BenchmarkDecodeString(b *testing.B) {
	data := StdEncoding.EncodeToString(make([]byte, 8192))
	b.SetBytes(int64(len(data)))
	for i := 0; i < b.N; i++ {

// enormous receiver + enormous method frame, so wrapper splits stack to call M,
// and then M splits stack to allocate its frame.
// recover must look back two frames to find the panic.
type T6 [8192]byte

var global byte

func (T6) M() {
	var x [8192]byte
	x[0] = 1
	x[1] = 2
	for i := range x {
		global += x[i]
	}
	mustRecoverBody(doubleRecover(), recover(), recover(), 14)
}

func test14() {