}

	type People []Person

	people := People{
		{"Gopher", 13},
		{"Alice", 20},
		{"Bob", 5},
		{"Vera", 24},
		{"Zac", 15},
	}

	// Chunk people into []Person 2 elements at a time.
	for c := range slices.Chunk(people, 2) {
		fmt.Println(c)
	}

	// Output:
	// [{Gopher 13} {Alice 20}]
	// [{Bob 5} {Vera 24}]
	// [{Zac 15}]

 private:
  // Quantize an DenseFPElementsAttr by the quantization parameters.
  DenseElementsAttr convert(DenseFPElementsAttr attr);

  // Get a uniform converter for the index-th chunk along the quantizationDim.
  // All the elements in this chunk is quantized by the returned converter.
  UniformQuantizedValueConverter getPerChunkConverter(int index) const {
    return UniformQuantizedValueConverter(scales_[index], zero_points_[index],

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

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

/** An HTTP request that came into the mock web server. */
@ExperimentalOkHttpApi
class RecordedRequest(
  val requestLine: String,
  /** All headers. */
  val headers: Headers,
  /**
   * The sizes of the chunks of this request's body, or an empty list if the request's body
   * was empty or unchunked.
   */
  val chunkSizes: List<Int>,
  /** The total size of the body of this POST request (before truncation).*/
  val bodySize: Long,

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

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

  /**
   * Parses a serialized trie representation of a map of reversed public suffixes into an immutable
   * map of public suffixes. The encoded trie string may be broken into multiple chunks to avoid the
   * 64k limit on string literal size. In-memory strings can be much larger (2G).
   */
  static ImmutableMap<String, PublicSuffixType> parseTrie(CharSequence... encodedChunks) {

        then:
        1 * context.progress(1024, 10240, "bytes", "1 KiB/10 KiB downloaded")
        1 * context.progress(2048, 10240, "bytes", "2 KiB/10 KiB downloaded")
        0 * context.progress(_)
    }

    def "last chunk of bytes <1KiB is not logged"() {
        given:
        def operation = new ResourceOperation(context, Type.download)
        operation.contentLength = 2000
        when:
        operation.logProcessedBytes(1000)

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