nobackwardtail:
	BC	4, 5, LR		// blelr cr1, return if DWORDS == 0
	SRDCC	$2,DWORDS,QWORDS	// Compute number of 32B blocks and compare to 0
	BNE	backward32setup		// If QWORDS != 0, start the 32B copy loop.

backward24:
	// DWORDS is a value between 1-3.
	CMP	DWORDS, $2

	MOVD 	-8(SRC), TMP
	MOVD 	TMP, -8(TGT)
	BC	12, 0, LR		// bltlr, return if DWORDS == 1

	MOVD 	-16(SRC), TMP
	MOVD 	TMP, -16(TGT)

Russ Cox <******@****.***> 1648990796 -0400

    }

    private String makeName(String... words) {
        int expectedLength = 0;
        for (String word : words) {
            if (word != null) {
                expectedLength += word.length();
            }
        }
        StringBuilder builder = new StringBuilder(expectedLength);
        for (String word : words) {
            if (word == null || word.length() == 0) {
                continue;

        toWords("") == ""
        toWords("word") == "word"
        toWords("twoWords") == "two words"
        toWords("TwoWords") == "two words"
        toWords("two words") == "two words"
        toWords("Two Words") == "two words"
        toWords(" Two  \t words\n") == "two words"
        toWords("two_words") == "two words"
        toWords("two.words") == "two words"
        toWords("two,words") == "two words"

    private final boolean terminal;
    private final Trie[] transitions;

    public static Trie from(String... words) {
        return from(Arrays.asList(words));
    }

    public static Trie from(Iterable<String> words) {
        Builder builder = new Builder();
        for (String word : words) {
            builder.addWord(word);
        }
        return builder.build();
    }

    public static Builder builder() {

        result.add(sb.toString());
        // lines
        for (String line : lines) {
            sb.setLength(0);
            String[] words = S_FILTER.split(line);
            for (String word : words) {
                if (sb.length() >= remainder - word.length() - (sb.length() > 0 ? 1 : 0)) {
                    repeat(sb, ' ', remainder - sb.length());
                    result.add(BOX_CHAR + " " + sb + " " + BOX_CHAR);

    {
        exceptionCount++;
        // prepare context to resume execution
        CONTEXT *c = ExceptionInfo->ContextRecord;
#ifdef _AMD64_
        c->Rip = *(DWORD64 *)c->Rsp;
        c->Rsp += 8;
#elif defined(_X86_)
        c->Eip = *(DWORD *)c->Esp;
        c->Esp += 4;
#else
        c->Pc = c->Lr;
#endif
#ifdef _ARM64_
        // TODO: remove when windows/arm64 supports SEH stack unwinding.

    .386
    .model    flat

PUBLIC    _sum
_TEXT     SEGMENT
_sum    PROC
    mov    eax, DWORD PTR 4[esp]
    add    eax, DWORD PTR 8[esp]
    ret    0
_sum    ENDP
_TEXT   ENDS

		t = append(t, 'X')
		i++
	}
	// Invariant: if the next letter is lower case, it must be converted
	// to upper case.
	// That is, we process a word at a time, where words are marked by _, - or
	// upper case letter. Digits are treated as words.
	for ; i < len(s); i++ {
		c := s[i]
		if isWordSeparator(c) {
			// Skip the separate and capitalize the next letter.
			continue
		}
		if isASCIIDigit(c) {

        "nut",
        "store",
        "finger"
    ]

    private final Map<String, String> mappingCache = [:].withDefault {
        def size = mappingCache.size()
        size >WORDS.size() ? "word${size}" : WORDS[size]
    }

    /**
     * Converts an operation dumped as JSON into code which can be used to
     * check the result, to be used in {@link NormalizingExcludeFactory}
     *
     * @param json