}
	e.writeChunk(e.tmp[:3*len(p)], "PLTE")
	if last != -1 {
		e.writeChunk(e.tmp[3*256:3*256+1+last], "tRNS")
	}
}

// An encoder is an io.Writer that satisfies writes by writing PNG IDAT chunks,
// including an 8-byte header and 4-byte CRC checksum per Write call. Such calls
// should be relatively infrequent, since writeIDATs uses a [bufio.Writer].
//

			chunkMax = len(s)
		}
	}

	var b Builder
	b.Grow(n)
	b.WriteString(s)
	for b.Len() < n {
		chunk := n - b.Len()
		if chunk > b.Len() {
			chunk = b.Len()
		}
		if chunk > chunkMax {
			chunk = chunkMax
		}
		b.WriteString(b.String()[:chunk])
	}
	return b.String()
}

// ToUpper returns s with all Unicode letters mapped to their upper case.

          contentLength = header.substring(15).trim().toLong()
        }
        if (lowercaseHeader.startsWith("transfer-encoding:") &&
          lowercaseHeader.substring(18).trim() == "chunked"
        ) {
          chunked = true
        }
      }

      val peek = dispatcher.peek()
      for (response in peek.informationalResponses) {
        writeHttpResponse(socket, sink, response)
      }

// It's used by sha1block_generic.go and tests.
func blockGeneric(dig *digest, p []byte) {
	var w [16]uint32

	h0, h1, h2, h3, h4 := dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4]
	for len(p) >= chunk {
		// Can interlace the computation of w with the
		// rounds below if needed for speed.
		for i := 0; i < 16; i++ {
			j := i * 4
			w[i] = uint32(p[j])<<24 | uint32(p[j+1])<<16 | uint32(p[j+2])<<8 | uint32(p[j+3])
		}

// SavedModel proto filename prefix.
inline constexpr char kSavedModelFilenamePrefix[] = "saved_model";
// SavedModel proto filename.
inline constexpr char kSavedModelFilenamePb[] = "saved_model.pb";

// SavedModel chunked proto filename.
inline constexpr char kSavedModelFilenameCpb[] = "saved_model.cpb";

// SavedModel text format proto filename.
inline constexpr char kSavedModelFilenamePbTxt[] = "saved_model.pbtxt";

		finalized.Store(true)
	})

	// Write three chunks worth of pointer data. Three gives us a
	// high likelihood that when we write 2 later, we'll get the behavior
	// we want.
	a := NewUserArena()
	for i := 0; i < int(UserArenaChunkBytes/goarch.PtrSize*3); i++ {
		var x any
		x = (*smallPointer)(nil)
		a.New(&x)
	}
	a.Free()

	// Recycle the arena chunks.
	GC()
	GC()

	a = NewUserArena()

		// write one chunk at a time
		for i, chunk := range strings.Split(responseHeadersAndBody, "split") {
			if i > 0 {
				n, err := hic.Write([]byte("split"))
				require.Equal(t, n, len("split"))
				require.NoError(t, err)
			}
			n, err := hic.Write([]byte(chunk))
			require.Equal(t, n, len(chunk))
			require.NoError(t, err)
		}
		assert.True(t, hic.initialized)

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

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.operations;

/**
 * Represents some chunk of work.
 */
public interface BuildOperation {
    /**
     * Returns a description of the build operation for visualization purposes.
     */
    BuildOperationDescriptor.Builder description();

      .assertLogMatch(Regex("""Transfer-encoding: chunked"""))
      .assertLogEqual("<-- END HTTP (streaming)")
      .assertNoMoreLogs()
    applicationLogs
      .assertLogEqual("--> GET $url")
      .assertLogEqual("--> END GET")
      .assertLogMatch(Regex("""<-- 200 OK $url \(\d+ms\)"""))
      .assertLogEqual("Content-Type: text/event-stream")
      .assertLogMatch(Regex("""Transfer-encoding: chunked"""))