// 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

	MOVWHI	R0, 0(R1)	// MOVWHI will write zeros up to next word boundary
	SUBU	R3, R2
	ADDU	R3, R1

setup:
	AND	$31, R2, R6
	AND	$3, R2, R5
	SUBU	R6, R4, R6	// end pointer for 32-byte chunks
	SUBU	R5, R4, R5	// end pointer for 4-byte chunks

large:
	BEQ	R1, R6, words
	MOVW	R0, 0(R1)
	MOVW	R0, 4(R1)
	MOVW	R0, 8(R1)
	MOVW	R0, 12(R1)
	MOVW	R0, 16(R1)
	MOVW	R0, 20(R1)
	MOVW	R0, 24(R1)
	MOVW	R0, 28(R1)

func (d *digest) Write(p []byte) (nn int, err error) {
	nn = len(p)
	d.len += uint64(nn)
	if d.nx > 0 {
		n := copy(d.x[d.nx:], p)
		d.nx += n
		if d.nx == chunk {
			block(d, d.x[:])
			d.nx = 0
		}
		p = p[n:]
	}
	if len(p) >= chunk {
		n := len(p) &^ (chunk - 1)
		block(d, p[:n])
		p = p[n:]
	}
	if len(p) > 0 {
		d.nx = copy(d.x[:], p)
	}
	return
}

func (d *digest) Sum(in []byte) []byte {

		host := req.Host
		if host == "" && req.URL != nil {
			host = req.URL.Host
		}
		if host != "" {
			fmt.Fprintf(&b, "Host: %s\r\n", host)
		}
	}

	chunked := len(req.TransferEncoding) > 0 && req.TransferEncoding[0] == "chunked"
	if len(req.TransferEncoding) > 0 {
		fmt.Fprintf(&b, "Transfer-Encoding: %s\r\n", strings.Join(req.TransferEncoding, ","))
	}

// whether or not a given page is scavenged in a single
// structure. It's effectively a pallocBits with
// additional functionality.
//
// Update the comment on (*pageAlloc).chunks should this
// structure change.
type pallocData struct {
	pallocBits
	scavenged pageBits
}

// allocRange sets bits [i, i+n) in the bitmap to 1 and
// updates the scavenged bits appropriately.

func (w *normWriter) Write(data []byte) (n int, err error) {
	// Process data in pieces to keep w.buf size bounded.
	const chunk = 4000

	for len(data) > 0 {
		// Normalize into w.buf.
		m := len(data)
		if m > chunk {
			m = chunk
		}
		w.rb.src = inputBytes(data[:m])
		w.rb.nsrc = m
		w.buf = doAppend(&w.rb, w.buf, 0)
		data = data[m:]
		n += m

  }

  @Test
  fun chunkedUpload_byteByByte() {
    doUpload(TransferKind.CHUNKED, WriteKind.BYTE_BY_BYTE)
  }

  @Test
  fun chunkedUpload_smallBuffers() {
    doUpload(TransferKind.CHUNKED, WriteKind.SMALL_BUFFERS)
  }

  @Test
  fun chunkedUpload_largeBuffers() {
    doUpload(TransferKind.CHUNKED, WriteKind.LARGE_BUFFERS)
  }

  @Test
  fun fixedLengthUpload_byteByByte() {

			// to a custom value for example: "aws-chunked,gzip".
			metadata[strings.ToLower(xhttp.ContentEncoding)] = contentEncoding
		} else {
			// Trimmed content encoding is empty when the header
			// value is set to "aws-chunked" only.

			// Make sure to delete the content-encoding parameter
			// for a streaming signature which is set to value
			// for example: "aws-chunked"

            "in": "query",
            "name": "limit",

			abi.FuncPCABIInternal(_System) + sys.PCQuantum,
		}
		p.log.write(nil, 0, hdr[:], lostStk[:])
		p.lostAtomic = 0
	}

}

// CPUProfile panics.
// It formerly provided raw access to chunks of
// a pprof-format profile generated by the runtime.
// The details of generating that format have changed,
// so this functionality has been removed.
//
// Deprecated: Use the [runtime/pprof] package,