): List<Cookie> {
    val result = mutableListOf<Cookie>()
    var pos = 0
    val limit = header.length
    var pairEnd: Int
    while (pos < limit) {
      pairEnd = header.delimiterOffset(";,", pos, limit)
      val equalsSign = header.delimiterOffset('=', pos, pairEnd)
      val name = header.trimSubstring(pos, equalsSign)
      if (name.startsWith("$")) {
        pos = pairEnd + 1
        continue
      }

            pos += 8;

            final int wsOffOff = writeSecurityBuffer(type1, pos, workstation);
            pos += 8;

            if ((flags & NTLMSSP_NEGOTIATE_VERSION) != 0) {
                System.arraycopy(NTLMSSP_VERSION, 0, type1, pos, NTLMSSP_VERSION.length);
                pos += NTLMSSP_VERSION.length;
            }

            pos += writeSecurityBufferContent(type1, pos, domOffOff, domain);

        pos++ // Consume '='.
        pos = value.indexOfNonWhitespace(pos)

        if (pos < value.length && value[pos] == '\"') {
          // Quoted string.
          pos++ // Consume '"' open quote.
          val parameterStart = pos
          pos = value.indexOf('"', pos)
          parameter = value.substring(parameterStart, pos)
          pos++ // Consume '"' close quote (if necessary).
        } else {

        // Parse each extension.
        var pos = 0
        while (pos < header.length) {
          val extensionEnd = header.delimiterOffset(',', pos)
          val extensionTokenEnd = header.delimiterOffset(';', pos, extensionEnd)
          val extensionToken = header.trimSubstring(pos, extensionTokenEnd)
          pos = extensionTokenEnd + 1

          when {

    private int pos;
    private int markPos;

    JavadocScanner(String rawCommentText) {
        pushText(rawCommentText);
    }

    @Override
    public String toString() {
        return input.substring(pos);
    }

    public boolean isEmpty() {
        return pos == input.length();
    }

    public void mark() {
        markPos = pos;
    }

    public void next() {

        }
        if (buf.indexOf("HH") == -1) {
            final int pos = buf.indexOf("H");
            if (pos != -1) {
                buf.replace(pos, pos + 1, "HH");
            }
        }
        if (buf.indexOf("mm") == -1) {
            final int pos = buf.indexOf("m");
            if (pos != -1) {
                buf.replace(pos, pos + 1, "mm");
            }
        }
        if (buf.indexOf("ss") == -1) {

        }
        if (buf.indexOf("yy") == -1) {
            final int pos = buf.indexOf("y");
            if (pos != -1) {
                buf.replace(pos, pos + 1, "yy");
            }
        }
        if (buf.indexOf("MM") == -1) {
            final int pos = buf.indexOf("M");
            if (pos != -1) {
                buf.replace(pos, pos + 1, "MM");
            }
        }
        if (buf.indexOf("dd") == -1) {

// streaming MetaValue channel for JSON values at the configured emitDepth.
func (d *Decoder) Stream() chan *MetaValue {
	go d.decode()
	return d.metaCh
}

// Pos returns the number of bytes consumed from the underlying reader
func (d *Decoder) Pos() int { return int(d.pos) }

// Err returns the most recent decoder error if any, or nil
func (d *Decoder) Err() error { return d.err }

// MaxDepth will set the maximum recursion depth.

      s: String,
      pos: Int,
      limit: Int,
    ): Long {
      var pos = pos
      pos = dateCharacterOffset(s, pos, limit, false)

      var hour = -1
      var minute = -1
      var second = -1
      var dayOfMonth = -1
      var month = -1
      var year = -1
      val matcher = TIME_PATTERN.matcher(s)

      while (pos < limit) {

	scanner := newScanner(r)
	for scanner.pos < atomic.LoadInt64(&scanner.end) {
		c := scanner.next()
		if scanner.readerErr != nil {
			t.Fatal(scanner.readerErr)
		}
		if c != data[i] {
			t.Fatalf("expected %s, got %s", string(data[i]), string(c))
		}
		t.Logf("pos=%d remaining=%d (%s)", i, r.Len(), string(c))
		i++
	}
}

type mockReader struct {
	pos       int
	mockData  byte
	failAfter int
}