if p1 > p2 {
		p1, p2 = p2, p1
	}

	// The lowest common ancestor is the minimum depth block
	// on the tour from p1 to p2.  We've precomputed minimum
	// depth blocks for powers-of-two subsequences of the tour.
	// Combine the right two precomputed values to get the answer.
	logS := uint(log64(int64(p2 - p1)))
	bid1 := lca.rangeMin[logS][p1]
	bid2 := lca.rangeMin[logS][p2-1<<logS+1]

using ::tensorflow::protobuf::Map;
using ::tensorflow::protobuf::Message;
using ::tensorflow::protobuf::RepeatedPtrField;

// Number of sequential FieldIndex matches of `a` in `b`. (Length of initial
// subsequence.)
// Example: `a = {4, 2}`, `b = {4, 2, 1, 3}`, `fieldTagMatches(a, b) == 2`
absl::StatusOr<int> fieldTagMatches(
    const RepeatedPtrField<::tensorflow::proto_splitter::FieldIndex>& a,

	}
	return l
}

// tgs returns the pairs of indexes of the longest common subsequence
// of unique lines in x and y, where a unique line is one that appears
// once in x and once in y.
//
// The longest common subsequence algorithm is as described in
// Thomas G. Szymanski, “A Special Case of the Maximal Common
// Subsequence Problem,” Princeton TR #170 (January 1975),
// available at https://research.swtch.com/tgs170.pdf.

        def td = table.select("tfoot td:eq(2)").first()
        String totalCoverage = td.text().replaceAll(NON_BREAKING_WHITESPACE, '') // remove non-breaking whitespace
        return totalCoverage.endsWith("%") ? totalCoverage.subSequence(0, totalCoverage.length() - 1) as BigDecimal : null
    }

    int numberOfClasses() {
        def parsedHtmlReport = Jsoup.parse(htmlDir.file("index.html"), "UTF-8")

    }

    /**
     * Append content to the message buffer.
     *
     * @param value the content to append
     * @param start the starting index of the subsequence to be appended
     * @param end the end index of the subsequence to be appended
     * @return the current builder
     */
    @Nonnull
    default MessageBuilder a(CharSequence value, int start, int end) {

    val result = StringBuilder(length)

    for (range in ranges.sortedBy { it.first }) {

        result.append(this, result.length, range.first)

        for (ch in subSequence(range)) {
            result.append(
                if (Character.isWhitespace(ch)) ch
                else ' '
            )
        }
    }

                .filter { it.identifier === id }
                .singleBlockSectionOrNull()
        }
    }

    private
    fun ProgramSourceFragment.isNotBlank() =
        source.text.subSequence(section.block.first + 1, section.block.last).isNotBlank()
}


internal
fun checkForTopLevelBlockOrder(
    topLevelBlocks: List<TopLevelBlock>
) {

        text(csq == null ? "null" : csq);
        return this;
    }

    @Override
    public StyledTextOutput append(CharSequence csq, int start, int end) {
        text(csq == null ? "null" : csq.subSequence(start, end));
        return this;
    }

    @FormatMethod
    @Override
    public StyledTextOutput format(String pattern, Object... args) {
        text(String.format(pattern, args));
        return this;

//
// The implementation runs in O(n log n) time, where n = len(words),
// using the algorithm described in D. S. Hirschberg and L. L. Larmore,
// “[The least weight subsequence problem],” FOCS 1985, pp. 137-143.
//
// [The least weight subsequence problem]: https://doi.org/10.1109/SFCS.1985.60
func wrap(words []string, max int) (seq []int) {
	// The algorithm requires that our scoring function be concave,

     */
    public static ExhaustiveLinesSearcher useUnifiedDiff() {
        return new ExhaustiveLinesSearcher(true);
    }

    /**
     * Uses the LCS (longest common subsequence) algorithm for presenting matches.
     *
     * @return searcher that uses a unified diff output
     */
    public static ExhaustiveLinesSearcher useLcsDiff() {
        return new ExhaustiveLinesSearcher(false);
    }