count += len; // update number of bytes
        final int partLen = BLOCK_LENGTH - bufferNdx;
        int i = 0;
        if (len >= partLen) {
            System.arraycopy(input, offset, buffer, bufferNdx, partLen);

            transform(buffer, 0);

            for (i = partLen; i + BLOCK_LENGTH - 1 < len; i += BLOCK_LENGTH) {
                transform(input, offset + i);
            }

{* ../../docs_src/query_params/tutorial001_py310.py hl[9] *}

Die <abbr title="Abfrage">Query</abbr> ist die Menge von Schlüssel-Wert-Paaren, die nach dem `?` in einer URL folgen und durch `&`-Zeichen getrennt sind.

Zum Beispiel sind in der URL:

```
http://127.0.0.1:8000/items/?skip=0&limit=10
```

... die Query-Parameter:

	percent    rune = '%'
	underscore rune = '_'
	runeZero   rune = 0
)

func evalSQLLike(text, pattern string, escape rune) (match bool, err error) {
	s := []rune{}
	prev := runeZero
	hasLeadingPercent := false
	patLen := len([]rune(pattern))
	for i, r := range pattern {
		if i > 0 && prev == escape {
			switch r {
			case percent, escape, underscore:
				s = append(s, r)
				prev = r
				if r == escape {
					prev = runeZero

      "00000010",
      "00000011",
      "END_HEADERS",
      "END_STREAM|END_HEADERS",
      "00000110",
      "00000111",
      "PADDED",
      "END_STREAM|PADDED",
      "00001010",
      "00001011",
      "00001100",
      "END_STREAM|END_HEADERS|PADDED",
      "00001110",
      "00001111",
      "00010000",
      "00010001",
      "00010010",
      "00010011",
      "00010100",

     * @param maxLen the maximum length to search
     * @return position of terminating null byte
     */
    public static int findTermination(final byte[] buffer, final int bufferIndex, final int maxLen) {
        int len = 0;
        while (buffer[bufferIndex + len] != (byte) 0x00) {
            len++;
            if (len > maxLen) {

        int oidLen = oidDer.length;
        int nameLen = nameBytes.length;

        byte[] buf = new byte[2 + 2 + oidLen + 4 + nameLen];
        int i = 0;
        // TOK_ID
        buf[i++] = tokId[0];
        buf[i++] = tokId[1];
        // MECH_OID_LEN (2 bytes big-endian)
        buf[i++] = (byte) ((oidLen >>> 8) & 0xFF);
        buf[i++] = (byte) (oidLen & 0xFF);
        // MECH_OID

     *
     * @param val the integer value to convert to hexadecimal
     * @param size the desired length of the resulting hex string (will be left-padded with zeros)
     * @return a hexadecimal string representation of the value, padded to the specified size
     */
    public static String toHexString(final int val, final int size) {
        final char[] c = new char[size];
        toHexChars(val, c, 0, size);

     *
     * @param val the integer value to convert to hexadecimal
     * @param size the desired length of the resulting hex string (will be left-padded with zeros)
     * @return a hexadecimal string representation of the value, padded to the specified size
     */
    public static String toHexString(final int val, final int size) {
        final char[] c = new char[size];
        toHexChars(val, c, 0, size);

  init {
    FLAGS[FLAG_NONE] = ""
    FLAGS[FLAG_END_STREAM] = "END_STREAM"

    val prefixFlags = intArrayOf(FLAG_END_STREAM)

    FLAGS[FLAG_PADDED] = "PADDED"
    for (prefixFlag in prefixFlags) {
      FLAGS[prefixFlag or FLAG_PADDED] = FLAGS[prefixFlag] + "|PADDED"
    }

    FLAGS[FLAG_END_HEADERS] = "END_HEADERS" // Same as END_PUSH_PROMISE.
    FLAGS[FLAG_PRIORITY] = "PRIORITY" // Same as FLAG_COMPRESSED.

### Dateien und Async { #files-and-async }

In den meisten Fällen sind dateiähnliche Objekte standardmäßig nicht mit async und await kompatibel.

Beispielsweise haben sie kein `await file.read()` oder `async for chunk in file`.

Und in vielen Fällen wäre das Lesen eine blockierende Operation (die die Event-Loop blockieren könnte), weil von der Festplatte oder aus dem Netzwerk gelesen wird.