scan:
	for {
		offset := d.pos - 1

		// read string key
		if c != '"' {
			err = d.mkError(ErrSyntax, "looking for beginning of object key string")
			break
		}
		if k, err = d.string(); err != nil {
			break
		}

		// read colon before value
		if c = d.skipSpaces(); c != ':' {
			err = d.mkError(ErrSyntax, "after object key")
			break
		}

		// read value
		d.skipSpaces()
		if d.emitKV {

 * encode/decode operation.
 */
public class DcerpcMessageTest {

    /**
     * A trivial concrete subclass used for testing. It simply writes a
     * single small value in {@code encode_in} and reads it in
     * {@code decode_out}.
     */
    private static class TestMessage extends DcerpcMessage {
        int decodedValue = 0;

        TestMessage() {
            /* nothing */
        }

// the [Scanner] returns it to the user. If the token is nil, the
// Scanner reads more data and continues scanning; if there is no more
// data--if atEOF was true--the [Scanner] returns. If the data does not
// yet hold a complete token, for instance if it has no newline while
// scanning lines, a [SplitFunc] can return (0, nil, nil) to signal the
// [Scanner] to read more data into the slice and try again with a

            shift += 7
          } else {
            result += b shl shift // Last byte.
            break
          }
        }
        return result
      }

      /** Reads a potentially Huffman encoded byte string. */
      @Throws(IOException::class)
      fun readByteString(): ByteString {
        val firstByte = readByte()
        val huffmanDecode = firstByte and 0x80 == 0x80 // 1NNNNNNN

    /**
     * Read bytes from the input stream into a buffer
     *
     * @param in the input stream to read from
     * @param b the buffer to read into
     * @param off the offset in the buffer to start writing
     * @param len the number of bytes to read
     * @return number of bytes read
     * @throws IOException if an I/O error occurs
     */

func ChecksumFromBytes(b []byte) *Checksum {
	if len(b) == 0 {
		return nil
	}

	// Read checksum type
	t, n := binary.Uvarint(b)
	if n <= 0 {
		return nil
	}
	b = b[n:]

	typ := ChecksumType(t)
	length := typ.RawByteLen()
	if length == 0 || len(b) < length {
		return nil
	}

	// Read raw checksum bytes
	raw := make([]byte, length)
	copy(raw, b[:length])
	b = b[length:]

// On success, enqueues `tensor` into a TF-managed FifoQueue given by
// `tensor_id`, associated with `session`. There must be a graph node named
// "fifo_queue_enqueue_<tensor_id>", to be executed by this API call. It reads
// from a placeholder node "arg_tensor_enqueue_<tensor_id>".
//
// `tensor` is still owned by the caller. This call will be blocked if the queue
// has reached its capacity, and will be unblocked when the queued tensors again

				return
			}
		}
	}

	// Start separate goroutine for each listener to handle connection.
	for idx, ln := range listener.listeners {
		go handleListener(idx, ln)
	}
}

// Accept - reads from httpListener.acceptCh for one of previously accepted TCP connection and returns the same.
func (listener *httpListener) Accept() (conn net.Conn, err error) {
	select {
	case result := <-listener.acceptCh:

        System.arraycopy(b, i, buf, index, l);
        advance(l);
    }

    /**
     * Reads an octet array from the buffer.
     *
     * @param b the byte array to read into
     * @param i the starting index in the array
     * @param l the number of bytes to read
     */
    public void readOctetArray(final byte[] b, final int i, final int l) {
        System.arraycopy(buf, index, b, i, l);

# 3. Add modifiers. Some modifiers for local execution are:
#      Ex. disk_cache -- Use a local cache
#      Ex. public_cache -- Use TF's public cache (read-only)
#      Ex. public_cache_push -- Use TF's public cache (read and write, Googlers only)
#      Ex. rbe        -- Use RBE for faster builds (Googlers only; see below)
#      Ex. no_docker  -- Disable docker on enabled platforms