}
    }

    protected QueryBuilder buildFilterQuery(final String fieldName, final List<String> words) {
        final BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery().minimumShouldMatch(1);
        words.stream().forEach(word -> boolQueryBuilder.should(QueryBuilders.termQuery(fieldName, word)));
        return boolQueryBuilder;
    }

	parsed := &Rule{Raw: rule}

	// Split rule into "words" (where a quoted string is a single word).
	var words []string
	for _, match := range wordRegex.FindAllStringSubmatch(rule, -1) {
		words = append(words, strings.Trim(match[1], `"`))
	}

	// The chain name must come first (and can't be the only thing there)
	if len(words) < 2 || words[0] != "-A" {

    .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

labels.suggest_word_configuration=Suggest Word
labels.suggest_word_title_details=Suggest Word
labels.suggest_word_type=Word Type
labels.suggest_word_number=Word Count
labels.suggest_word_type_all=All
labels.suggest_word_type_document=Document
labels.suggest_word_type_query=Query
labels.elevate_word_configuration=Additional Word
labels.elevate_word_title_details=Additional Word
labels.elevate_word_link_list=List

	MOVD R7, c+56(FP)
	RET

// func shlVU(z, x []Word, s uint) (c Word)
TEXT ·shlVU(SB), NOSPLIT, $0
	BR ·shlVU_g(SB)

// func shrVU(z, x []Word, s uint) (c Word)
TEXT ·shrVU(SB), NOSPLIT, $0
	BR ·shrVU_g(SB)

// CX = R4, r8 = r8, r9=r9, r10 = r2, r11 = r5, DX = r3, AX = r6, BX = R1, (R0 set to 0) + use R11 + use R7 for i
// func mulAddVWW(z, x []Word, y, r Word) (c Word)
TEXT ·mulAddVWW(SB), NOSPLIT, $0
	MOVD z+0(FP), R2

        }
        refresh();
    }

    public void deleteElevateWord(final String word, final boolean apply) {
        suggester.indexer().deleteElevateWord(word, apply);
        refresh();
    }

    public void addElevateWord(final String word, final String reading, final String[] tags, final String[] permissions, final Float boost,
            final boolean apply) {

        "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

labels.elevate_word_button_upload=Upload
labels.elevate_word_list_suggest_word=Word
labels.elevate_word_suggest_word=Word
labels.elevate_word_reading=Reading
labels.elevate_word_permissions=Permissions
labels.elevate_word_boost=Boost
labels.elevate_word_file=Additional Word File
labels.bad_word_configuration=Bad Word
labels.bad_word_title_details=Bad Word
labels.bad_word_link_list=List
labels.bad_word_link_edit=Создать новый

	BEQ	done
copy_4:				// no carry flag, copy the rest
	vwOneIterCopy(R0, done)
	B	copy_4

// func shlVU(z, x []Word, s uint) (c Word)
// This implementation handles the shift operation from the high word to the low word,
// which may be an error for the case where the low word of x overlaps with the high
// word of z. When calling this function directly, you need to pay attention to this
// situation.
TEXT ·shlVU(SB),NOSPLIT,$0

		fmt.Fprintln(w)
	}
	fmt.Fprintln(w, "\tRET")
}

func zeroARM64(w io.Writer) {
	// ZR: always zero
	// R20: ptr to memory to be zeroed
	// On return, R20 points to the last zeroed dword.
	fmt.Fprintln(w, "TEXT runtime·duffzero<ABIInternal>(SB), NOSPLIT|NOFRAME, $0-0")
	for i := 0; i < 63; i++ {
		fmt.Fprintln(w, "\tSTP.P\t(ZR, ZR), 16(R20)")
	}
	fmt.Fprintln(w, "\tSTP\t(ZR, ZR), (R20)")