}

func (wci *watchCacheInterval) fillBuffer() {
	wci.buffer.startIndex = 0
	wci.buffer.endIndex = 0
	for wci.startIndex < wci.endIndex && !wci.buffer.isFull() {
		event := wci.indexer(wci.startIndex)
		if event == nil {
			break
		}
		wci.buffer.buffer[wci.buffer.endIndex] = event
		wci.buffer.endIndex++
		wci.startIndex++
	}
}

const bufferSize = 100

            if (beginIndex > 0) {
                int endIndex = disposition.indexOf(';', beginIndex + 11); // find the next semicolon
                endIndex = endIndex < 0 ? disposition.length() : endIndex; // if no semicolon is found, then there is nothing else in the disposition
                endIndex -= 1; // ignore the closing quotes
                return disposition.substring(beginIndex + 10, endIndex);
            }

}


internal
fun CharSequence.splitIncluding(delimiter: Char) = sequence {
    var startIndex = 0
    while (true) {
        val endIndex = indexOf(delimiter, startIndex) + 1
        if (endIndex == 0) break
        yield(substring(startIndex, endIndex))
        startIndex = endIndex
    }
    if (startIndex <= lastIndex) {
        yield(substring(startIndex))
    }

			rest = next
		}

		var endIndex, endTrailerIndex int

		// If there were no headers, the END line might occur
		// immediately, without a leading newline.
		if len(p.Headers) == 0 && bytes.HasPrefix(rest, pemEnd[1:]) {
			endIndex = 0
			endTrailerIndex = len(pemEnd) - 1
		} else {
			endIndex = bytes.Index(rest, pemEnd)
			endTrailerIndex = endIndex + len(pemEnd)
		}

		if endIndex < 0 {

        @Throws(IOException::class)
        private
        fun processClassFile(zipEntry: ZipEntry, builder: Trie.Builder) {
            val endIndex = zipEntry.name.lastIndexOf("/")
            if (endIndex > 0) {
                val packageName = zipEntry.name.substring(0, endIndex)
                for (exclude in excludes) {
                    if ("$packageName/".startsWith("$exclude/")) {
                        return

            if (firstLine != null) {
                String trimmed = firstLine.trim();
                if (trimmed.startsWith("<?xml ")) {
                    int endIndex = trimmed.indexOf("?>");
                    String xmlDecl = trimmed.substring(0, endIndex + 2);
                    prefix = (xmlDecl + "\n" + DOCTYPE).getBytes();
                    bytesToSkip = xmlDecl.getBytes().length;
                }
            }

			// exercise it in tests, we just throw an error here.
			t.Error("Open watchers are not supported during compaction")
		}

		for c.watchCache.startIndex < c.watchCache.endIndex {
			index := c.watchCache.startIndex % c.watchCache.capacity
			if c.watchCache.cache[index].ResourceVersion > rv {
				break
			}

			c.watchCache.startIndex++
		}

    StringRef caller_name = mlir::cast<NameLoc>(caller).getName().strref();
    const size_t start_index = kQuantizationUnitPrefix.size();
    const size_t end_index = caller_name.rfind(kQuantizationUnitSuffix);
    std::string serialized_proto =
        caller_name.substr(start_index, end_index - start_index).str();
    QuantizationUnitLoc::QuantizationUnit quant_unit;
    if (quant_unit.ParseFromString(serialized_proto)) {
      return quant_unit;

	German               Tag = Tag{language: deIndex, locale: deIndex}
	Greek                Tag = Tag{language: elIndex, locale: elIndex}
	English              Tag = Tag{language: enIndex, locale: enIndex}
	AmericanEnglish      Tag = Tag{language: enUSIndex, locale: enUSIndex}
	BritishEnglish       Tag = Tag{language: enGBIndex, locale: enGBIndex}
	Spanish              Tag = Tag{language: esIndex, locale: esIndex}