Grammalecte  Check-in [44de2cad94]

import colorsys
import time

import compile_rules_js_convert as jsconv
import compile_rules_graph as crg


dDEFINITIONS = {}
dDECLENSIONS = {}
lFUNCTIONS = []

aRULESET = set()     # set of rule-ids to check if there is several rules with the same id
nRULEWITHOUTNAME = 0

dJSREGEXES = {}

        return None

    # quotes ?
    if sRegex.startswith('"') and sRegex.endswith('"'):
        sRegex = sRegex[1:-1]

    ## definitions
    for sDef, sRepl in dDEFINITIONS.items():
        sRegex = sRegex.replace(sDef, sRepl)

    ## count number of groups (must be done before modifying the regex)
    nGroup = countGroupInRegex(sRegex)
    if nGroup > 0:
        if not tGroups:
            print("# Warning: groups positioning code for JavaScript should be defined at line " + sLineId)

        elif sLine.startswith("#"):
            # comment
            pass
        elif sLine.startswith("DEF:"):
            # definition
            m = re.match("DEF: +([a-zA-Z_][a-zA-Z_0-9]*) +(.+)$", sLine.strip())
            if m:
                dDEFINITIONS["{"+m.group(1)+"}"] = m.group(2)
            else:
                print("Error in definition: ", end="")
                print(sLine.strip())
        elif sLine.startswith("DECL:"):
            # declensions
            m = re.match(r"DECL: +(\+\w+) (.+)$", sLine.strip())
            if m:
                dDECLENSIONS[m.group(1)] = m.group(2).strip().split()
            else:
                print("Error in declension list: ", end="")
                print(sLine.strip())
        elif sLine.startswith("TEST:"):
            # test
            lTest.append("{:<8}".format(i) + "  " + sLine[5:].strip())
        elif sLine.startswith("TODO:"):
            # todo
            pass
        elif sLine.startswith(("OPTGROUP/", "OPTSOFTWARE:", "OPT/", \

        # Graph rules
        elif sLine.startswith("@@@@GRAPH:"):
            # rules graph call
            m = re.match(r"@@@@GRAPH: *(\w+)", sLine.strip())
            if m:
                printBookmark(0, "GRAPH: " + m.group(1), i)
                lRuleLine.append([i, "@@@@"+m.group(1)])

                lGraphRule.append([i, sLine])
                bGraph = True
            else:
                print("Graph error at line", i)
        elif sLine.startswith(("@@@@END_GRAPH", "@@@@ENDGRAPH")):
            #lGraphRule.append([i, sLine])
            printBookmark(0, "ENDGRAPH", i)
            bGraph = False
        elif re.match("@@@@ *$", sLine):
            pass
        elif bGraph:
            lGraphRule.append([i, sLine])

        "sentence_rules": mergeRulesByOption(lSentenceRules),
        "paragraph_rules_JS": jsconv.writeRulesToJSArray(mergeRulesByOption(lParagraphRulesJS)),
        "sentence_rules_JS": jsconv.writeRulesToJSArray(mergeRulesByOption(lSentenceRulesJS))
    }
    dVars.update(dOptions)

    # compile graph rules
    dVars2 = crg.make(lGraphRule, sLang, dDEFINITIONS, dDECLENSIONS, dOptPriority)
    dVars.update(dVars2)

    with open("_build/data_cache.json", "w", encoding="utf-8") as hDst:
        hDst.write(json.dumps(dVars, ensure_ascii=False))
    return dVars

import darg
import compile_rules_js_convert as jsconv


dACTIONS = {}
dFUNCTIONS = {}
dFUNCNAME = {}
dDECLENSIONS = {}
dANTIPATTERNS = {}


def createFunction (sType, sCode, bStartWithEqual=False):
    "create a function (stored in <dFUNCTIONS>) and return function name"
    sCode = prepareFunction(sCode)
    if sType not in dFUNCNAME:
        dFUNCNAME[sType] = {}

def prepareFunction (sCode):
    "convert simple rule syntax to a string of Python code"
    if sCode[0:1] == "=":
        sCode = sCode[1:]
    sCode = sCode.replace("__also__", "bCondMemo")
    sCode = sCode.replace("__else__", "not bCondMemo")
    sCode = sCode.replace("sContext", "_sAppContext")
    sCode = re.sub(r"\b(morph|morphVC|analyse|value|tag|displayInfo)[(]\\(\d+)", 'g_\\1(lToken[nTokenOffset+\\2]', sCode)
    sCode = re.sub(r"\b(morph|morphVC|analyse|value|tag|displayInfo)[(]\\-(\d+)", 'g_\\1(lToken[nLastToken-\\2+1]', sCode)
    sCode = re.sub(r"\b(select|exclude|define|define_from|add_morph|change_meta)[(][\\](\d+)", 'g_\\1(lToken[nTokenOffset+\\2]', sCode)
    sCode = re.sub(r"\b(select|exclude|define|define_from|add_morph|change_meta)[(][\\]-(\d+)", 'g_\\1(lToken[nLastToken-\\2+1]', sCode)
    sCode = re.sub(r"\b(tag_before|tag_after)[(][\\](\d+)", 'g_\\1(lToken[nTokenOffset+\\2], dTags', sCode)
    sCode = re.sub(r"\b(tag_before|tag_after)[(][\\]-(\d+)", 'g_\\1(lToken[nLastToken-\\2+1], dTags', sCode)
    sCode = re.sub(r"\bspace_after[(][\\](\d+)", 'g_space_between_tokens(lToken[nTokenOffset+\\1], lToken[nTokenOffset+\\1+1]', sCode)
    sCode = re.sub(r"\bspace_after[(][\\]-(\d+)", 'g_space_between_tokens(lToken[nLastToken-\\1+1], lToken[nLastToken-\\1+2]', sCode)
    sCode = re.sub(r"\banalyse_with_next[(][\\](\d+)", 'g_merged_analyse(lToken[nTokenOffset+\\1], lToken[nTokenOffset+\\1+1]', sCode)
    sCode = re.sub(r"\banalyse_with_next[(][\\]-(\d+)", 'g_merged_analyse(lToken[nLastToken-\\1+1], lToken[nLastToken-\\1+2]', sCode)
    sCode = re.sub(r"\b(morph|analyse|tag|value)\(>1", 'g_\\1(lToken[nLastToken+1]', sCode)                       # next token
    sCode = re.sub(r"\b(morph|analyse|tag|value)\(<1", 'g_\\1(lToken[nTokenOffset]', sCode)                       # previous token
    sCode = re.sub(r"\b(morph|analyse|tag|value)\(>(\d+)", 'g_\\1(g_token(lToken, nLastToken+\\2)', sCode)        # next token
    sCode = re.sub(r"\b(morph|analyse|tag|value)\(<(\d+)", 'g_\\1(g_token(lToken, nTokenOffset+1-\\2)', sCode)    # previous token
    sCode = re.sub(r"\bspell *[(]", '_oSpellChecker.isValid(', sCode)
    sCode = re.sub(r"\bbefore\(\s*", 'look(sSentence[:lToken[1+nTokenOffset]["nStart"]], ', sCode)          # before(sCode)
    sCode = re.sub(r"\bafter\(\s*", 'look(sSentence[lToken[nLastToken]["nEnd"]:], ', sCode)                 # after(sCode)
    sCode = re.sub(r"\bbefore0\(\s*", 'look(sSentence0[:lToken[1+nTokenOffset]["nStart"]], ', sCode)        # before0(sCode)
    sCode = re.sub(r"\bafter0\(\s*", 'look(sSentence[lToken[nLastToken]["nEnd"]:], ', sCode)                # after0(sCode)
    sCode = re.sub(r"\banalyseWord[(]", 'analyse(', sCode)
    sCode = re.sub(r"[\\](\d+)", 'lToken[nTokenOffset+\\1]["sValue"]', sCode)
    sCode = re.sub(r"[\\]-(\d+)", 'lToken[nLastToken-\\1+1]["sValue"]', sCode)
    sCode = re.sub(r">1", 'lToken[nLastToken+1]["sValue"]', sCode)
    sCode = re.sub(r"<1", 'lToken[nTokenOffset]["sValue"]', sCode)
    return sCode


def genTokenLines (sTokenLine, dDef, dDecl):
    "tokenize a string and return a list of lines of tokens"

    lTokenLines = []
    for sTokBlock in sTokenLine.split():
        # replace merger characters by spaces
        if "␣" in sTokBlock:
            sTokBlock = sTokBlock.replace("␣", " ")
        # optional token?
        bNullPossible = sTokBlock.startswith("?") and sTokBlock.endswith("¿")
        if bNullPossible:
            sTokBlock = sTokBlock[1:-1]
        # token with definition?
        if sTokBlock.startswith("({") and sTokBlock.endswith("})") and sTokBlock[1:-1] in dDef:
            sTokBlock = "(" + dDef[sTokBlock[1:-1]] + ")"
        elif sTokBlock.startswith("{") and sTokBlock.endswith("}") and sTokBlock in dDef:
            sTokBlock = dDef[sTokBlock]
        if ( (sTokBlock.startswith("[") and sTokBlock.endswith("]")) or (sTokBlock.startswith("([") and sTokBlock.endswith("])")) ):
            # multiple token
            bSelectedGroup = sTokBlock.startswith("(") and sTokBlock.endswith(")")
            if bSelectedGroup:
                sTokBlock = sTokBlock[1:-1]
            lToken = createTokenList(sTokBlock, dDecl)
            if not lTokenLines:
                lTokenLines = [ ["("+s+")"]  for s  in lToken ]  if bSelectedGroup  else [ [s]  for s  in lToken ]
                if bNullPossible:
                    lTokenLines.extend([ []  for i  in range(len(lToken)+1) ])
            else:
                lNewTemp = []
                if bNullPossible:
                    for aRule in lTokenLines:
                        for sElem in lToken:
                            aNewRule = list(aRule)
                            aNewRule.append(sElem)
                            lNewTemp.append(aNewRule)
                else:
                    sElem1 = lToken.pop(0)
                    for aRule in lTokenLines:
                        for sElem in lToken:
                            aNewRule = list(aRule)
                            aNewRule.append("(" + sElem + ")"  if bSelectedGroup  else sElem)
                            lNewTemp.append(aNewRule)
                        aRule.append("(" + sElem1 + ")"  if bSelectedGroup  else sElem1)
                lTokenLines.extend(lNewTemp)
        else:
            # simple token
            if not lTokenLines:
                lTokenLines = [[sTokBlock], []]  if bNullPossible  else [[sTokBlock]]
            else:
                if bNullPossible:
                    lNewTemp = []
                    for aRule in lTokenLines:
                        lNew = list(aRule)
                        lNew.append(sTokBlock)
                        lNewTemp.append(lNew)
                    lTokenLines.extend(lNewTemp)
                else:
                    for aRule in lTokenLines:
                        aRule.append(sTokBlock)
    for aRule in lTokenLines:
        yield aRule


def createTokenList (sTokBlock, dDeclensions):
    "return a list of tokens from a block of tokens"
    lToken = []
    for sToken in sTokBlock[1:-1].split("|"):
        if "+" in sToken and not sToken.startswith("+"):
            for sCode in dDeclensions:
                if sToken.endswith(sCode):
                    sToken = sToken[:-len(sCode)]
                    lToken.append(sToken)
                    for sSuffix in dDeclensions[sCode]:
                        lToken.append(sToken+sSuffix)
                    break
        else:
            lToken.append(sToken)
    return lToken


def createRule (iLine, sRuleName, sTokenLine, iActionBlock, sActions, nPriority, dOptPriority, dDef, dDecl):
    "generator: create rule as list"
    # print(iLine, "//", sRuleName, "//", sTokenLine, "//", sActions, "//", nPriority)
    if sTokenLine.startswith("!!") and sTokenLine.endswith("¡¡"):
        # antipattern
        sTokenLine = sTokenLine[2:-2].strip()
        if sRuleName not in dANTIPATTERNS:
            dANTIPATTERNS[sRuleName]= []
        for lToken in genTokenLines(sTokenLine, dDef, dDecl):
            dANTIPATTERNS[sRuleName].append(lToken)
    else:
        # pattern
        for lToken in genTokenLines(sTokenLine, dDef, dDecl):
            if sRuleName in dANTIPATTERNS and lToken in dANTIPATTERNS[sRuleName]:
                # <lToken> matches an antipattern -> discard
                continue
            # Calculate positions
            dPos = {}   # key: iGroup, value: iToken
            iGroup = 0
            #if iLine == 15818: # debug
            #    print(" ".join(lToken))
            for i, sToken in enumerate(lToken):
                if sToken.startswith("(") and sToken.endswith(")"):
                    lToken[i] = sToken[1:-1]
                    iGroup += 1
                    dPos[iGroup] = i + 1    # we add 1, for we count tokens from 1 to n (not from 0)

            # Parse actions
            for iAction, sAction in enumerate(sActions.split(" <<- ")):
                sAction = sAction.strip()
                if sAction:
                    sActionId = sRuleName + "__b" + str(iActionBlock) + "_a" + str(iAction)
                    aAction = createAction(sActionId, sAction, nPriority, dOptPriority, len(lToken), dPos)
                    if aAction:
                        sActionName = storeAction(sActionId, aAction)
                        lResult = list(lToken)
                        lResult.extend(["##"+str(iLine), sActionName])
                        #if iLine == 13341:
                        #    print("  ".join(lToken))
                        #    print(sActionId, aAction)
                        yield lResult
                    else:
                        print(" # Error on action at line:", iLine)
                        print(sTokenLine, "\n", sActions)


def changeReferenceToken (sText, dPos):
    "change group reference in <sText> with values in <dPos>"
    if "\\" not in sText:
        return sText
    for i in range(len(dPos), 0, -1):

        if int(x.group(1)) > nToken:
            print("# Error in token index at line " + sActionId + " ("+str(nToken)+" tokens only)")
            print(sText)


def checkIfThereIsCode (sText, sActionId):
    "check if there is code in <sText> (debugging)"
    if re.search(r"[.]\w+[(]|sugg\w+[(]|\(\\[0-9]|\[[0-9]", sText):
        print("# Warning at line " + sActionId + ":  This message looks like code. Line should probably begin with =")
        print(sText)


def createAction (sActionId, sAction, nPriority, dOptPriority, nToken, dPos):
    "create action rule as a list"
    # Option
    sOption = False
    m = re.match("/(\\w+)/", sAction)
    if m:
        sOption = m.group(1)
        sAction = sAction[m.end():].strip()
    if nPriority == -1:
        nPriority = dOptPriority.get(sOption, 4)

    # valid action?
    m = re.search(r"(?P<action>[-=~/!>])(?P<start>-?\d+\.?|)(?P<end>:\.?-?\d+|)(?P<casing>:|)>>", sAction)
    if not m:
        print("\n# Error. No action found at: ", sActionId)
        return None

    # Condition
    sCondition = sAction[:m.start()].strip()
    if sCondition:
        sCondition = changeReferenceToken(sCondition, dPos)
        sCondition = createFunction("cond", sCondition)

    cStartLimit = "<"
    cEndLimit = ">"
    if not m.group("start"):
        iStartAction = 1
        iEndAction = 0
    else:
        if cAction != "-" and (m.group("start").endswith(".") or m.group("end").startswith(":.")):
            print("\n# Error. Wrong selection on tokens.", sActionId)
            return None
        if m.group("start").endswith("."):
            cStartLimit = ">"
        iStartAction = int(m.group("start").rstrip("."))
        if not m.group("end"):
            iEndAction = iStartAction
        else:

    if cAction == "-":
        ## error
        iMsg = sAction.find(" # ")
        if iMsg == -1:
            sMsg = "# Error. Error message not found."
            sURL = ""
            print("\n" + sMsg + " Action id: " + sActionId)
        else:
            sMsg = sAction[iMsg+3:].strip()
            sAction = sAction[:iMsg].strip()
            sURL = ""
            mURL = re.search("[|] *(https?://.*)", sMsg)
            if mURL:
                sURL = mURL.group(1).strip()

    checkTokenNumbers(sAction, sActionId, nToken)

    if cAction == ">":
        ## no action, break loop if condition is False
        return [sOption, sCondition, cAction, ""]

    if not sAction and cAction != "!":
        print("\n# Error in action at line <" + sActionId + ">:  This action is empty.")

    if sAction[0:1] != "=" and cAction != "=":
        checkIfThereIsCode(sAction, sActionId)

    if cAction == "-":
        ## error detected --> suggestion
        if sAction[0:1] == "=":
            sAction = createFunction("sugg", sAction, True)
        elif sAction.startswith('"') and sAction.endswith('"'):
            sAction = sAction[1:-1]
        if not sMsg:
            print("\n# Error in action at line <" + sActionId + ">:  The message is empty.")
        return [sOption, sCondition, cAction, sAction, iStartAction, iEndAction, cStartLimit, cEndLimit, bCaseSensitivity, nPriority, sMsg, sURL]
    if cAction == "~":
        ## text processor
        if sAction[0:1] == "=":
            sAction = createFunction("tp", sAction, True)
        elif sAction.startswith('"') and sAction.endswith('"'):
            sAction = sAction[1:-1]
        elif sAction not in "␣*_":
            nToken = sAction.count("|") + 1
            if iStartAction > 0 and iEndAction > 0:
                if (iEndAction - iStartAction + 1) != nToken:
                    print("\n# Error in action at line <" + sActionId + ">: numbers of modified tokens modified.")
            elif iStartAction < 0 or iEndAction < 0 and iStartAction != iEndAction:
                print("\n# Warning in action at line <" + sActionName + ">: rewriting with possible token position modified.")
        return [sOption, sCondition, cAction, sAction, iStartAction, iEndAction, bCaseSensitivity]
    if cAction in "!/":
        ## tags
        return [sOption, sCondition, cAction, sAction, iStartAction, iEndAction]
    if cAction == "=":
        ## disambiguator
        if "define(" in sAction and not re.search(r"define\(\\-?\d+ *, *\[.*\] *\)", sAction):
            print("\n# Error in action at line <" + sActionId + ">: second argument for <define> must be a list of strings")
        sAction = createFunction("da", sAction)
        return [sOption, sCondition, cAction, sAction]
    print("\n# Unknown action.", sActionId)
    return None


def make (lRule, sLang, dDef, dDecl, dOptPriority):
    "compile rules, returns a dictionary of values"
    # for clarity purpose, don’t create any file here

    # removing comments, zeroing empty lines, creating definitions, storing tests, merging rule lines
    print("  parsing rules...")
    lTokenLine = []
    sActions = ""

                exit()
        elif sLine.startswith("__") and sLine.endswith("__"):
            # new rule group
            m = re.match("__(\\w+)(!\\d|)__", sLine)
            if m:
                sRuleName = m.group(1)
                if sRuleName in aRuleName:
                    print("Error at line " + str(i) + ". Rule name <" + sRuleName + "> already exists.")
                    exit()
                aRuleName.add(sRuleName)
                iActionBlock = 1
                nPriority = int(m.group(2)[1:]) if m.group(2)  else -1
            else:
                print("Syntax error in rule group: ", sLine, " -- line:", i)
                exit()
        elif re.search("^    +<<- ", sLine) or (sLine.startswith("        ") and not sLine.startswith("        ||")) \
                or re.search("^    +#", sLine) or re.search(r"[-=~/!>](?:-?\d\.?(?::\.?-?\d+|)|)>> ", sLine) :
            # actions
            sActions += " " + sLine.strip()
        elif re.match("[  ]*$", sLine):
            # empty line to end merging
            if not lTokenLine:
                continue
            if not sActions:

    # processing rules
    print("  preparing rules...")
    for sGraphName, lRuleLine in dAllGraph.items():
        print("{:>8,} rules in {:<24} ".format(len(lRuleLine), "<"+sGraphName+">"), end="")
        lPreparedRule = []
        for i, sRuleGroup, sTokenLine, iActionBlock, sActions, nPriority in lRuleLine:
            for aRule in createRule(i, sRuleGroup, sTokenLine, iActionBlock, sActions, nPriority, dOptPriority, dDef, dDecl):
                lPreparedRule.append(aRule)
        # Graph creation
        oDARG = darg.DARG(lPreparedRule, sLang)
        dAllGraph[sGraphName] = oDARG.createGraph()
        # Debugging
        if False:
            print("\nRULES:")

        # Used as a key in a python dictionary.
        # Nodes are equivalent if they have identical arcs, and each identical arc leads to identical states.
        return self.__str__() == other.__str__()

    def getNodeAsDict (self):
        "returns the node as a dictionary structure"
        dNode = {}
        dReValue = {}   # regex for token values
        dReMorph = {}   # regex for morph
        dMorph = {}     # simple search in morph
        dLemma = {}
        dMeta = {}
        dTag = {}
        dRule = {}
        for sArc, oNode in self.dArcs.items():
            if sArc.startswith("@") and len(sArc) > 1:
                dReMorph[sArc[1:]] = oNode.__hash__()
            elif sArc.startswith("$") and len(sArc) > 1:
                dMorph[sArc[1:]] = oNode.__hash__()
            elif sArc.startswith("~") and len(sArc) > 1:
                dReValue[sArc[1:]] = oNode.__hash__()
            elif sArc.startswith(">") and len(sArc) > 1:
                dLemma[sArc[1:]] = oNode.__hash__()
            elif sArc.startswith("*") and len(sArc) > 1:
                dMeta[sArc[1:]] = oNode.__hash__()
            elif sArc.startswith("/") and len(sArc) > 1:
                dTag[sArc[1:]] = oNode.__hash__()
            elif sArc.startswith("##"):
                dRule[sArc[1:]] = oNode.__hash__()
            else:
                dNode[sArc] = oNode.__hash__()
        if dReValue:
            dNode["<re_value>"] = dReValue
        if dReMorph:
            dNode["<re_morph>"] = dReMorph
        if dMorph:
            dNode["<morph>"] = dMorph
        if dLemma:
            dNode["<lemmas>"] = dLemma
        if dTag:
            dNode["<tags>"] = dTag
        if dMeta:
            dNode["<meta>"] = dMeta
        if dRule:
            dNode["<rules>"] = dRule
        #if self.bFinal:
        #    dNode["<final>"] = 1
        return dNode

= GRAMMALECTE =

Grammar checker

By Olivier R.

Website: http://grammalecte.net

License: GPL 3 -- http://www.gnu.org/copyleft/gpl.html

Grammalecte is a fork of Lightproof
    from László Németh (nemeth /at/ numbertext /dot/ org)
    http://cgit.freedesktop.org/libreoffice/lightproof/

        }
    }

    update (sSentence, bDebug=false) {
        // update <sSentence> and retokenize
        this.sSentence = sSentence;
        let lNewToken = Array.from(_oTokenizer.genTokens(sSentence, true));
        for (let oToken of lNewToken) {
            if (this.dTokenPos.gl_get(oToken["nStart"], {}).hasOwnProperty("lMorph")) {
                oToken["lMorph"] = this.dTokenPos.get(oToken["nStart"])["lMorph"];
            }
            if (this.dTokenPos.gl_get(oToken["nStart"], {}).hasOwnProperty("aTags")) {
                oToken["aTags"] = this.dTokenPos.get(oToken["nStart"])["aTags"];
            }
        }
        this.lToken = lNewToken;
        this.dTokenPos.clear();
        for (let oToken of this.lToken) {
            if (oToken["sType"] != "INFO") {
                this.dTokenPos.set(oToken["nStart"], oToken);
            }
        }
        if (bDebug) {
            console.log("UPDATE:");
            console.log(this.asString());
        }
    }

    * _getNextPointers (oToken, oGraph, oPointer, bDebug=false) {
        // generator: return nodes where <oToken> “values” match <oNode> arcs
        try {
            let oNode = oGraph[oPointer["iNode"]];
            let iToken1 = oPointer["iToken1"];
            let bTokenFound = false;
            // token value
            if (oNode.hasOwnProperty(oToken["sValue"])) {
                if (bDebug) {
                    console.log("  MATCH: " + oToken["sValue"]);
                }
                yield { "iToken1": iToken1, "iNode": oNode[oToken["sValue"]] };
                bTokenFound = true;
            }
            if (oToken["sValue"].slice(0,2).gl_isTitle()) { // we test only 2 first chars, to make valid words such as "Laissez-les", "Passe-partout".
                let sValue = oToken["sValue"].toLowerCase();
                if (oNode.hasOwnProperty(sValue)) {
                    if (bDebug) {
                        console.log("  MATCH: " + sValue);
                    }
                    yield { "iToken1": iToken1, "iNode": oNode[sValue] };
                    bTokenFound = true;
                }
            }
            else if (oToken["sValue"].gl_isUpperCase()) {
                let sValue = oToken["sValue"].toLowerCase();
                if (oNode.hasOwnProperty(sValue)) {
                    if (bDebug) {
                        console.log("  MATCH: " + sValue);
                    }
                    yield { "iToken1": iToken1, "iNode": oNode[sValue] };
                    bTokenFound = true;
                }
                sValue = oToken["sValue"].gl_toCapitalize();
                if (oNode.hasOwnProperty(sValue)) {
                    if (bDebug) {
                        console.log("  MATCH: " + sValue);
                    }
                    yield { "iToken1": iToken1, "iNode": oNode[sValue] };
                    bTokenFound = true;
                }
            }
            // regex value arcs
            if (oToken["sType"] != "INFO"  &&  oToken["sType"] != "PUNC"  &&  oToken["sType"] != "SIGN") {
                if (oNode.hasOwnProperty("<re_value>")) {
                    for (let sRegex in oNode["<re_value>"]) {
                        if (!sRegex.includes("¬")) {
                            // no anti-pattern
                            if (oToken["sValue"].search(sRegex) !== -1) {
                                if (bDebug) {
                                    console.log("  MATCH: ~" + sRegex);
                                }
                                yield { "iToken1": iToken1, "iNode": oNode["<re_value>"][sRegex] };
                                bTokenFound = true;
                            }
                        } else {
                            // there is an anti-pattern
                            let [sPattern, sNegPattern] = sRegex.split("¬", 2);
                            if (sNegPattern && oToken["sValue"].search(sNegPattern) !== -1) {
                                continue;
                            }
                            if (!sPattern || oToken["sValue"].search(sPattern) !== -1) {
                                if (bDebug) {
                                    console.log("  MATCH: ~" + sRegex);
                                }
                                yield { "iToken1": iToken1, "iNode": oNode["<re_value>"][sRegex] };
                                bTokenFound = true;
                            }
                        }
                    }
                }
            }
            // analysable tokens
            if (oToken["sType"].slice(0,4) == "WORD") {
                // token lemmas
                if (oNode.hasOwnProperty("<lemmas>")) {
                    for (let sLemma of _oSpellChecker.getLemma(oToken["sValue"])) {
                        if (oNode["<lemmas>"].hasOwnProperty(sLemma)) {
                            if (bDebug) {
                                console.log("  MATCH: >" + sLemma);
                            }
                            yield { "iToken1": iToken1, "iNode": oNode["<lemmas>"][sLemma] };
                            bTokenFound = true;
                        }
                    }
                }
                // morph arcs
                if (oNode.hasOwnProperty("<morph>")) {
                    let lMorph = (oToken.hasOwnProperty("lMorph")) ? oToken["lMorph"] : _oSpellChecker.getMorph(oToken["sValue"]);
                    if (lMorph.length > 0) {
                        for (let sSearch in oNode["<morph>"]) {
                            if (!sSearch.includes("¬")) {
                                // no anti-pattern
                                if (lMorph.some(sMorph  =>  (sMorph.includes(sSearch)))) {
                                    if (bDebug) {
                                        console.log("  MATCH: $" + sSearch);
                                    }
                                    yield { "iToken1": iToken1, "iNode": oNode["<morph>"][sSearch] };
                                    bTokenFound = true;
                                }
                            } else {
                                // there is an anti-pattern
                                let [sPattern, sNegPattern] = sSearch.split("¬", 2);
                                if (sNegPattern == "*") {
                                    // all morphologies must match with <sPattern>
                                    if (sPattern) {
                                        if (lMorph.every(sMorph  =>  (sMorph.includes(sPattern)))) {
                                            if (bDebug) {
                                                console.log("  MATCH: $" + sSearch);
                                            }
                                            yield { "iToken1": iToken1, "iNode": oNode["<morph>"][sSearch] };
                                            bTokenFound = true;
                                        }
                                    }
                                } else {
                                    if (sNegPattern  &&  lMorph.some(sMorph  =>  (sMorph.includes(sNegPattern)))) {
                                        continue;
                                    }
                                    if (!sPattern  ||  lMorph.some(sMorph  =>  (sMorph.includes(sPattern)))) {
                                        if (bDebug) {
                                            console.log("  MATCH: $" + sSearch);
                                        }
                                        yield { "iToken1": iToken1, "iNode": oNode["<morph>"][sSearch] };
                                        bTokenFound = true;
                                    }
                                }
                            }
                        }
                    }
                }
                // regex morph arcs
                if (oNode.hasOwnProperty("<re_morph>")) {
                    let lMorph = (oToken.hasOwnProperty("lMorph")) ? oToken["lMorph"] : _oSpellChecker.getMorph(oToken["sValue"]);
                    if (lMorph.length > 0) {
                        for (let sRegex in oNode["<re_morph>"]) {
                            if (!sRegex.includes("¬")) {
                                // no anti-pattern
                                if (lMorph.some(sMorph  =>  (sMorph.search(sRegex) !== -1))) {
                                    if (bDebug) {
                                        console.log("  MATCH: @" + sRegex);
                                    }
                                    yield { "iToken1": iToken1, "iNode": oNode["<re_morph>"][sRegex] };
                                    bTokenFound = true;
                                }
                            } else {
                                // there is an anti-pattern
                                let [sPattern, sNegPattern] = sRegex.split("¬", 2);
                                if (sNegPattern == "*") {
                                    // all morphologies must match with <sPattern>
                                    if (sPattern) {
                                        if (lMorph.every(sMorph  =>  (sMorph.search(sPattern) !== -1))) {
                                            if (bDebug) {
                                                console.log("  MATCH: @" + sRegex);
                                            }
                                            yield { "iToken1": iToken1, "iNode": oNode["<re_morph>"][sRegex] };
                                            bTokenFound = true;
                                        }
                                    }
                                } else {
                                    if (sNegPattern  &&  lMorph.some(sMorph  =>  (sMorph.search(sNegPattern) !== -1))) {
                                        continue;
                                    }
                                    if (!sPattern  ||  lMorph.some(sMorph  =>  (sMorph.search(sPattern) !== -1))) {
                                        if (bDebug) {
                                            console.log("  MATCH: @" + sRegex);
                                        }
                                        yield { "iToken1": iToken1, "iNode": oNode["<re_morph>"][sRegex] };
                                        bTokenFound = true;
                                    }
                                }
                            }
                        }
                    }
                }
            }
            // token tags
            if (oToken.hasOwnProperty("aTags") && oNode.hasOwnProperty("<tags>")) {
                for (let sTag of oToken["aTags"]) {
                    if (oNode["<tags>"].hasOwnProperty(sTag)) {
                        if (bDebug) {
                            console.log("  MATCH: /" + sTag);
                        }
                        yield { "iToken1": iToken1, "iNode": oNode["<tags>"][sTag] };
                        bTokenFound = true;
                    }
                }
            }
            // meta arc (for token type)
            if (oNode.hasOwnProperty("<meta>")) {
                for (let sMeta in oNode["<meta>"]) {
                    // no regex here, we just search if <oNode["sType"]> exists within <sMeta>
                    if (sMeta == "*" || oToken["sType"] == sMeta) {
                        if (bDebug) {
                            console.log("  MATCH: *" + sMeta);
                        }
                        yield { "iToken1": iToken1, "iNode": oNode["<meta>"][sMeta] };
                        bTokenFound = true;
                    }
                    else if (sMeta.includes("¬")) {
                        if (!sMeta.includes(oToken["sType"])) {
                            if (bDebug) {
                                console.log("  MATCH: *" + sMeta);
                            }
                            yield { "iToken1": iToken1, "iNode": oNode["<meta>"][sMeta] };
                            bTokenFound = true;
                        }
                    }
                }
            }
            if (!bTokenFound  &&  oPointer.hasOwnProperty("bKeep")) {
                yield oPointer;
            }
            // JUMP
            // Warning! Recurssion!
            if (oNode.hasOwnProperty("<>")) {
                let oPointer2 = { "iToken1": iToken1, "iNode": oNode["<>"], "bKeep": true };
                yield* this._getNextPointers(oToken, oGraph, oPointer2, bDebug);
            }
        }
        catch (e) {
            console.error(e);
        }
    }

    parseGraph (oGraph, sCountry="${country_default}", dOptions=null, bShowRuleId=false, bDebug=false, bContext=false) {
        // parse graph with tokens from the text and execute actions encountered
        let lPointer = [];
        let bTagAndRewrite = false;
        try {
            for (let [iToken, oToken] of this.lToken.entries()) {
                if (bDebug) {
                    console.log("TOKEN: " + oToken["sValue"]);
                }
                // check arcs for each existing pointer
                let lNextPointer = [];
                for (let oPointer of lPointer) {
                    lNextPointer.push(...this._getNextPointers(oToken, oGraph, oPointer, bDebug));
                }
                lPointer = lNextPointer;
                // check arcs of first nodes
                lPointer.push(...this._getNextPointers(oToken, oGraph, { "iToken1": iToken, "iNode": 0 }, bDebug));
                // check if there is rules to check for each pointer
                for (let oPointer of lPointer) {
                    if (oGraph[oPointer["iNode"]].hasOwnProperty("<rules>")) {
                        let bChange = this._executeActions(oGraph, oGraph[oPointer["iNode"]]["<rules>"], oPointer["iToken1"]-1, iToken, dOptions, sCountry, bShowRuleId, bDebug, bContext);
                        if (bChange) {
                            bTagAndRewrite = true;
                        }
                    }
                }
            }
        } catch (e) {
            console.error(e);
        }
        if (bTagAndRewrite) {
            this.rewriteFromTags(bDebug);
        }
        if (bDebug) {
            console.log(this.asString());
        }
        return this.sSentence;
    }

    _executeActions (oGraph, oNode, nTokenOffset, nLastToken, dOptions, sCountry, bShowRuleId, bDebug, bContext) {
        // execute actions found in the DARG
        let bChange = false;
        for (let [sLineId, nextNodeKey] of Object.entries(oNode)) {
            let bCondMemo = null;
            for (let sRuleId of oGraph[nextNodeKey]) {
                try {
                    if (bDebug) {
                        console.log("   >TRY: " + sRuleId + " " + sLineId);
                    }
                    let [sOption, sFuncCond, cActionType, sWhat, ...eAct] = gc_rules_graph.dRule[sRuleId];
                    // Suggestion    [ option, condition, "-", replacement/suggestion/action, iTokenStart, iTokenEnd, cStartLimit, cEndLimit, bCaseSvty, nPriority, sMessage, sURL ]
                    // TextProcessor [ option, condition, "~", replacement/suggestion/action, iTokenStart, iTokenEnd, bCaseSvty ]

                                } else {
                                    this.dTags.set(sWhat, [Math.min(nTokenStart, this.dTags.get(sWhat)[0]), Math.max(nTokenEnd, this.dTags.get(sWhat)[1])]);
                                }
                            }
                            else if (cActionType == "!") {
                                // immunity
                                if (bDebug) {
                                    console.log("    IMMUNITY: " + sLineId + " / " + sRuleId);
                                }
                                let nTokenStart = (eAct[0] > 0) ? nTokenOffset + eAct[0] : nLastToken + eAct[0];
                                let nTokenEnd = (eAct[1] > 0) ? nTokenOffset + eAct[1] : nLastToken + eAct[1];
                                if (nTokenEnd - nTokenStart == 0) {
                                    this.lToken[nTokenStart]["bImmune"] = true;
                                    let nErrorStart = this.nOffsetWithinParagraph + this.lToken[nTokenStart]["nStart"];
                                    if (this.dError.has(nErrorStart)) {

                }
                this.lToken[nTokenRewriteStart]["sNewValue"] = sWhat;
            }
            else {
                // several tokens
                let lTokenValue = sWhat.split("|");
                if (lTokenValue.length != (nTokenRewriteEnd - nTokenRewriteStart + 1)) {
                    if (bDebug) {
                        console.log("Error. Text processor: number of replacements != number of tokens.");
                    }
                    return;
                }
                let j = 0;
                for (let i = nTokenRewriteStart;  i <= nTokenRewriteEnd;  i++) {
                    let sValue = lTokenValue[j];
                    if (!sValue || sValue === "*") {
                        this.lToken[i]["bToRemove"] = true;

    rewriteFromTags (bDebug=false) {
        // rewrite the sentence, modify tokens, purge the token list
        if (bDebug) {
            console.log("REWRITE");
        }
        let lNewToken = [];
        let nMergeUntil = 0;
        let oMergingToken = null;
        for (let [iToken, oToken] of this.lToken.entries()) {
            let bKeepToken = true;
            if (oToken["sType"] != "INFO") {
                if (nMergeUntil && iToken <= nMergeUntil) {
                    oMergingToken["sValue"] += " ".repeat(oToken["nStart"] - oMergingToken["nEnd"]) + oToken["sValue"];
                    oMergingToken["nEnd"] = oToken["nEnd"];
                    if (bDebug) {
                        console.log("  MERGED TOKEN: " + oMergingToken["sValue"]);
                    }
                    bKeepToken = false;
                }
                if (oToken.hasOwnProperty("nMergeUntil")) {
                    if (iToken > nMergeUntil) { // this token is not already merged with a previous token
                        oMergingToken = oToken;
                    }
                    if (oToken["nMergeUntil"] > nMergeUntil) {
                        nMergeUntil = oToken["nMergeUntil"];
                    }
                    delete oToken["nMergeUntil"];
                }
                else if (oToken.hasOwnProperty("bToRemove")) {
                    if (bDebug) {
                        console.log("  REMOVED: " + oToken["sValue"]);
                    }
                    this.sSentence = this.sSentence.slice(0, oToken["nStart"]) + " ".repeat(oToken["nEnd"] - oToken["nStart"]) + this.sSentence.slice(oToken["nEnd"]);
                    bKeepToken = false;
                }
            }
            //
            if (bKeepToken) {
                lNewToken.push(oToken);
                if (oToken.hasOwnProperty("sNewValue")) {
                    // rewrite token and sentence
                    if (bDebug) {
                        console.log(oToken["sValue"] + " -> " + oToken["sNewValue"]);
                    }
                    oToken["sRealValue"] = oToken["sValue"];
                    oToken["sValue"] = oToken["sNewValue"];
                    let nDiffLen = oToken["sRealValue"].length - oToken["sNewValue"].length;
                    let sNewRepl = (nDiffLen >= 0) ? oToken["sNewValue"] + " ".repeat(nDiffLen) : oToken["sNewValue"].slice(0, oToken["sRealValue"].length);
                    this.sSentence = this.sSentence.slice(0,oToken["nStart"]) + sNewRepl + this.sSentence.slice(oToken["nEnd"]);
                    delete oToken["sNewValue"];
                }
            }
            else {
                try {
                    this.dTokenPos.delete(oToken["nStart"]);
                }
                catch (e) {
                    console.log(this.asString());
                    console.log(oToken);
                }
            }
        }
        if (bDebug) {
            console.log("  TEXT REWRITED: " + this.sSentence);
        }
        this.lToken.length = 0;

    // search sPattern
    return lMorph.some(sMorph  =>  (sMorph.search(sPattern) !== -1));
}


//// Analyse tokens for graph rules

function g_value (oToken, sValues, nLeft=null, nRight=null) {
    // test if <oToken['sValue']> is in sValues (each value should be separated with |)
    let sValue = (nLeft === null) ? "|"+oToken["sValue"]+"|" : "|"+oToken["sValue"].slice(nLeft, nRight)+"|";
    if (sValues.includes(sValue)) {
        return true;
    }
    if (oToken["sValue"].slice(0,2).gl_isTitle()) { // we test only 2 first chars, to make valid words such as "Laissez-les", "Passe-partout".
        if (sValues.includes(sValue.toLowerCase())) {
            return true;
        }
    }
    else if (oToken["sValue"].gl_isUpperCase()) {
        //if sValue.lower() in sValues:
        //    return true;
        sValue = "|"+sValue.slice(1).gl_toCapitalize();
        if (sValues.includes(sValue)) {
            return true;
        }
        sValue = sValue.toLowerCase();
        if (sValues.includes(sValue)) {
            return true;
        }
    }
    return false;
}

function g_morph (oToken, sPattern, sNegPattern="", nLeft=null, nRight=null, bMemorizeMorph=true) {
    // analyse a token, return True if <sNegPattern> not in morphologies and <sPattern> in morphologies
    let lMorph;
    if (oToken.hasOwnProperty("lMorph")) {
        lMorph = oToken["lMorph"];
    }
    else {
        if (nLeft !== null) {
            let sValue = (nRight !== null) ? oToken["sValue"].slice(nLeft, nRight) : oToken["sValue"].slice(nLeft);
            lMorph = _oSpellChecker.getMorph(sValue);
            if (bMemorizeMorph) {
                oToken["lMorph"] = lMorph;
            }
        } else {
            lMorph = _oSpellChecker.getMorph(oToken["sValue"]);
        }
    }
    if (lMorph.length == 0) {
        return false;
    }
    // check negative condition
    if (sNegPattern) {

            }
        }
    }
    // search sPattern
    return lMorph.some(sMorph  =>  (sMorph.search(sPattern) !== -1));
}

function g_analyse (oToken, sPattern, sNegPattern="", nLeft=null, nRight=null, bMemorizeMorph=true) {
    // analyse a token, return True if <sNegPattern> not in morphologies and <sPattern> in morphologies
    let lMorph;
    if (nLeft !== null) {
        let sValue = (nRight !== null) ? oToken["sValue"].slice(nLeft, nRight) : oToken["sValue"].slice(nLeft);
        lMorph = _oSpellChecker.getMorph(sValue);
        if (bMemorizeMorph) {
            oToken["lMorph"] = lMorph;
        }
    } else {
        lMorph = _oSpellChecker.getMorph(oToken["sValue"]);
    }
    if (lMorph.length == 0) {
        return false;
    }
    // check negative condition
    if (sNegPattern) {
        if (sNegPattern == "*") {
            // all morph must match sPattern
            return lMorph.every(sMorph  =>  (sMorph.search(sPattern) !== -1));
        }
        else {
            if (lMorph.some(sMorph  =>  (sMorph.search(sNegPattern) !== -1))) {
                return false;
            }
        }
    }
    // search sPattern
    return lMorph.some(sMorph  =>  (sMorph.search(sPattern) !== -1));
}

function g_merged_analyse (oToken1, oToken2, cMerger, sPattern, sNegPattern="", bSetMorph=true) {
    // merge two token values, return True if <sNegPattern> not in morphologies and <sPattern> in morphologies (disambiguation off)
    let lMorph = _oSpellChecker.getMorph(oToken1["sValue"] + cMerger + oToken2["sValue"]);
    if (lMorph.length == 0) {
        return false;
    }
    // check negative condition
    if (sNegPattern) {
        if (sNegPattern == "*") {
            // all morph must match sPattern
            let bResult = lMorph.every(sMorph  =>  (sMorph.search(sPattern) !== -1));
            if (bResult && bSetMorph) {
                oToken1["lMorph"] = lMorph;
            }
            return bResult;
        }
        else {
            if (lMorph.some(sMorph  =>  (sMorph.search(sNegPattern) !== -1))) {
                return false;
            }
        }
    }
    // search sPattern
    let bResult = lMorph.some(sMorph  =>  (sMorph.search(sPattern) !== -1));
    if (bResult && bSetMorph) {
        oToken1["lMorph"] = lMorph;
    }
    return bResult;
}

function g_tag_before (oToken, dTags, sTag) {
    if (!dTags.has(sTag)) {
        return false;
    }
    if (oToken["i"] > dTags.get(sTag)[0]) {
        return true;
    }
    return false;
}

function g_tag_after (oToken, dTags, sTag) {
    if (!dTags.has(sTag)) {
        return false;
    }
    if (oToken["i"] < dTags.get(sTag)[1]) {
        return true;
    }
    return false;
}

function g_tag (oToken, sTag) {
    return oToken.hasOwnProperty("aTags") && oToken["aTags"].has(sTag);
}

function g_space_between_tokens (oToken1, oToken2, nMin, nMax=null) {
    let nSpace = oToken2["nStart"] - oToken1["nEnd"]
    if (nSpace < nMin) {
        return false;
    }
    if (nMax !== null && nSpace > nMax) {
        return false;
    }
    return true;

    dTokenPos.get(nPos)["lMorph"] = lMorph;
    return true;
}


//// Disambiguation for graph rules

function g_select (oToken, sPattern, lDefault=null) {
    // select morphologies for <oToken> according to <sPattern>, always return true
    let lMorph = (oToken.hasOwnProperty("lMorph")) ? oToken["lMorph"] : _oSpellChecker.getMorph(oToken["sValue"]);
    if (lMorph.length === 0  || lMorph.length === 1) {
        if (lDefault) {
            oToken["lMorph"] = lDefault;
        }
        return true;
    }
    let lSelect = lMorph.filter( sMorph => sMorph.search(sPattern) !== -1 );
    if (lSelect.length > 0) {
        if (lSelect.length != lMorph.length) {
            oToken["lMorph"] = lSelect;
        }
    } else if (lDefault) {
        oToken["lMorph"] = lDefault;
    }
    return true;
}

function g_exclude (oToken, sPattern, lDefault=null) {
    // select morphologies for <oToken> according to <sPattern>, always return true
    let lMorph = (oToken.hasOwnProperty("lMorph")) ? oToken["lMorph"] : _oSpellChecker.getMorph(oToken["sValue"]);
    if (lMorph.length === 0  || lMorph.length === 1) {
        if (lDefault) {
            oToken["lMorph"] = lDefault;
        }
        return true;
    }
    let lSelect = lMorph.filter( sMorph => sMorph.search(sPattern) === -1 );
    if (lSelect.length > 0) {
        if (lSelect.length != lMorph.length) {
            oToken["lMorph"] = lSelect;
        }
    } else if (lDefault) {
        oToken["lMorph"] = lDefault;
    }
    return true;
}

function g_add_morph (oToken, lNewMorph) {
    "Disambiguation: add a morphology to a token"
    let lMorph = (oToken.hasOwnProperty("lMorph")) ? oToken["lMorph"] : _oSpellChecker.getMorph(oToken["sValue"]);
    lMorph.push(...lNewMorph);
    oToken["lMorph"] = lMorph;
    return true;
}

function g_define (oToken, lMorph) {
    // set morphologies of <oToken>, always return true
    oToken["lMorph"] = lMorph;
    return true;
}

function g_define_from (oToken, nLeft=null, nRight=null) {
    let sValue = oToken["sValue"];
    if (nLeft !== null) {
        sValue = (nRight !== null) ? sValue.slice(nLeft, nRight) : sValue.slice(nLeft);
    }
    oToken["lMorph"] = _oSpellChecker.getMorph(sValue);
    return true;
}

function g_change_meta (oToken, sType) {
    // Disambiguation: change type of token
    oToken["sType"] = sType;
    return true;
}



//////// GRAMMAR CHECKER PLUGINS

${pluginsJS}

// JavaScript

/* jshint esversion:6, -W097 */
/* jslint esversion:6 */
/* global require, exports, console */

"use strict";


var text = {

    _zEndOfSentence: new RegExp ('[.?!:;…]+[»”’)]?[   ]+[»”’]?(?=[«"“‘–—   ]*[A-ZÀÂÉÈÊÎÔÇ])', "g"),

    getSentenceBoundaries: function* (sText) {
        // generator: returns start and end of sentences found in <sText>
        let iStart = 0;
        let m;
        while ((m = this._zEndOfSentence.exec(sText)) !== null) {
            yield [iStart, this._zEndOfSentence.lastIndex];

except ImportError:
    _bWriterError = False


__all__ = [ "lang", "locales", "pkg", "name", "version", "author", \
            "load", "parse", "getSpellChecker", \
            "setOption", "setOptions", "getOptions", "getDefaultOptions", "getOptionsLabels", "resetOptions", "displayOptions", \
            "ignoreRule", "resetIgnoreRules", "reactivateRule", "listRules", "displayRules", "setWriterUnderliningStyle" ]

__version__ = "${version}"


lang = "${lang}"
locales = ${loc}
pkg = "${implname}"

_sAppContext = ""                           # what software is running
_dOptions = None
_dOptionsColors = None
_oSpellChecker = None
_oTokenizer = None
_aIgnoredRules = set()

# Writer underlining style
_bMulticolor = True
_nUnderliningStyle = 0


#### Initialization

def load (sContext="Python", sColorType="aRGB"):
    "initialization of the grammar checker"
    global _oSpellChecker

    "generator: returns typle (sOption, sLineId, sRuleId)"
    if sFilter:
        try:
            zFilter = re.compile(sFilter)
        except re.error:
            echo("# Error. List rules: wrong regex.")
            sFilter = None
    # regex rules
    for sOption, lRuleGroup in chain(_getRules(True), _getRules(False)):
        if sOption != "@@@@":
            for _, _, sLineId, sRuleId, _, _ in lRuleGroup:
                if not sFilter or zFilter.search(sRuleId):
                    yield ("RegEx", sOption, sLineId, sRuleId)
    # tokens rules
    for sRuleName, lActions in _rules_graph.dRule.items():
        sOption, _, cActionType, *_ = lActions
        if cActionType == "-":
            yield("Tokens", sOption, "", sRuleName)


def displayRules (sFilter=None):
    "display the name of rules, with the filter <sFilter>"
    echo("List of rules. Filter: << " + str(sFilter) + " >>")
    for sOption, sLineId, sRuleId, sType in listRules(sFilter):
        echo("{:<8} {:<10} {:<10} {}".format(sOption, sLineId, sRuleId, sType))


#### Options

def setOption (sOpt, bVal):
    "set option <sOpt> with <bVal> if it exists"
    if sOpt in _dOptions:

def getOptionsLabels (sLang):
    "return options labels"
    return gc_options.getUI(sLang)


def displayOptions (sLang="${lang}"):
    "display the list of grammar checking options"
    echo("Options:")
    echo("\n".join( [ k+":\t"+str(v)+"\t"+gc_options.getUI(sLang).get(k, ("?", ""))[0]  for k, v  in sorted(_dOptions.items()) ] ))
    echo("")


def resetOptions ():
    "set options to default values"
    global _dOptions
    _dOptions = getDefaultOptions()


def setWriterUnderliningStyle (sStyle="BOLDWAVE", bMulticolor=True):
    "set underlining style for Writer (WAVE, BOLDWAVE, BOLD)"
    global _nUnderliningStyle
    global _bMulticolor
    # https://api.libreoffice.org/docs/idl/ref/FontUnderline_8idl.html
    # WAVE: 10, BOLD: 12, BOLDWAVE: 18 DASH: 5
    if sStyle == "WAVE":
        _nUnderliningStyle = 0  # 0 for default Writer setting
    elif sStyle == "BOLDWAVE":
        _nUnderliningStyle = 18
    elif sStyle == "BOLD":
        _nUnderliningStyle = 12
    elif sStyle == "DASH":
        _nUnderliningStyle = 5
    else:
        _nUnderliningStyle = 0
    _bMulticolor = bMulticolor


#### Parsing

def parse (sText, sCountry="${country_default}", bDebug=False, dOptions=None, bContext=False, bFullInfo=False):
    "init point to analyse <sText> and returns an iterable of errors or (with option <bFullInfo>) paragraphs errors and sentences with tokens and errors"
    oText = TextParser(sText)
    return oText.parse(sCountry, bDebug, dOptions, bContext, bFullInfo)

        self.dTokenPos = { dToken["nStart"]: dToken  for dToken in self.lToken  if dToken["sType"] != "INFO" }
        if bDebug:
            echo("UPDATE:")
            echo(self)

    def _getNextPointers (self, dToken, dGraph, dPointer, bDebug=False):
        "generator: return nodes where <dToken> “values” match <dNode> arcs"
        dNode = dGraph[dPointer["iNode"]]
        iToken1 = dPointer["iToken1"]
        bTokenFound = False
        # token value
        if dToken["sValue"] in dNode:
            if bDebug:
                echo("  MATCH: " + dToken["sValue"])
            yield { "iToken1": iToken1, "iNode": dNode[dToken["sValue"]] }
            bTokenFound = True
        if dToken["sValue"][0:2].istitle(): # we test only 2 first chars, to make valid words such as "Laissez-les", "Passe-partout".
            sValue = dToken["sValue"].lower()
            if sValue in dNode:
                if bDebug:
                    echo("  MATCH: " + sValue)
                yield { "iToken1": iToken1, "iNode": dNode[sValue] }
                bTokenFound = True
        elif dToken["sValue"].isupper():
            sValue = dToken["sValue"].lower()
            if sValue in dNode:
                if bDebug:
                    echo("  MATCH: " + sValue)
                yield { "iToken1": iToken1, "iNode": dNode[sValue] }
                bTokenFound = True
            sValue = dToken["sValue"].capitalize()
            if sValue in dNode:
                if bDebug:
                    echo("  MATCH: " + sValue)
                yield { "iToken1": iToken1, "iNode": dNode[sValue] }
                bTokenFound = True
        # regex value arcs
        if dToken["sType"] not in frozenset(["INFO", "PUNC", "SIGN"]):
            if "<re_value>" in dNode:
                for sRegex in dNode["<re_value>"]:
                    if "¬" not in sRegex:
                        # no anti-pattern
                        if re.search(sRegex, dToken["sValue"]):
                            if bDebug:
                                echo("  MATCH: ~" + sRegex)
                            yield { "iToken1": iToken1, "iNode": dNode["<re_value>"][sRegex] }
                            bTokenFound = True
                    else:
                        # there is an anti-pattern
                        sPattern, sNegPattern = sRegex.split("¬", 1)
                        if sNegPattern and re.search(sNegPattern, dToken["sValue"]):
                            continue
                        if not sPattern or re.search(sPattern, dToken["sValue"]):
                            if bDebug:
                                echo("  MATCH: ~" + sRegex)
                            yield { "iToken1": iToken1, "iNode": dNode["<re_value>"][sRegex] }
                            bTokenFound = True
        # analysable tokens
        if dToken["sType"][0:4] == "WORD":
            # token lemmas
            if "<lemmas>" in dNode:
                for sLemma in _oSpellChecker.getLemma(dToken["sValue"]):
                    if sLemma in dNode["<lemmas>"]:
                        if bDebug:
                            echo("  MATCH: >" + sLemma)
                        yield { "iToken1": iToken1, "iNode": dNode["<lemmas>"][sLemma] }
                        bTokenFound = True
            # morph arcs
            if "<morph>" in dNode:
                lMorph = dToken.get("lMorph", _oSpellChecker.getMorph(dToken["sValue"]))
                if lMorph:
                    for sSearch in dNode["<morph>"]:
                        if "¬" not in sSearch:
                            # no anti-pattern
                            if any(sSearch in sMorph  for sMorph in lMorph):
                                if bDebug:
                                    echo("  MATCH: $" + sSearch)
                                yield { "iToken1": iToken1, "iNode": dNode["<morph>"][sSearch] }
                                bTokenFound = True
                        else:
                            # there is an anti-pattern
                            sPattern, sNegPattern = sSearch.split("¬", 1)
                            if sNegPattern == "*":
                                # all morphologies must match with <sPattern>
                                if sPattern:
                                    if all(sPattern in sMorph  for sMorph in lMorph):
                                        if bDebug:
                                            echo("  MATCH: $" + sSearch)
                                        yield { "iToken1": iToken1, "iNode": dNode["<morph>"][sSearch] }
                                        bTokenFound = True
                            else:
                                if sNegPattern and any(sNegPattern in sMorph  for sMorph in lMorph):
                                    continue
                                if not sPattern or any(sPattern in sMorph  for sMorph in lMorph):
                                    if bDebug:
                                        echo("  MATCH: $" + sSearch)
                                    yield { "iToken1": iToken1, "iNode": dNode["<morph>"][sSearch] }
                                    bTokenFound = True
            # regex morph arcs
            if "<re_morph>" in dNode:
                lMorph = dToken.get("lMorph", _oSpellChecker.getMorph(dToken["sValue"]))
                if lMorph:
                    for sRegex in dNode["<re_morph>"]:
                        if "¬" not in sRegex:
                            # no anti-pattern
                            if any(re.search(sRegex, sMorph)  for sMorph in lMorph):
                                if bDebug:
                                    echo("  MATCH: @" + sRegex)
                                yield { "iToken1": iToken1, "iNode": dNode["<re_morph>"][sRegex] }
                                bTokenFound = True
                        else:
                            # there is an anti-pattern
                            sPattern, sNegPattern = sRegex.split("¬", 1)
                            if sNegPattern == "*":
                                # all morphologies must match with <sPattern>
                                if sPattern:
                                    if all(re.search(sPattern, sMorph)  for sMorph in lMorph):
                                        if bDebug:
                                            echo("  MATCH: @" + sRegex)
                                        yield { "iToken1": iToken1, "iNode": dNode["<re_morph>"][sRegex] }
                                        bTokenFound = True
                            else:
                                if sNegPattern and any(re.search(sNegPattern, sMorph)  for sMorph in lMorph):
                                    continue
                                if not sPattern or any(re.search(sPattern, sMorph)  for sMorph in lMorph):
                                    if bDebug:
                                        echo("  MATCH: @" + sRegex)
                                    yield { "iToken1": iToken1, "iNode": dNode["<re_morph>"][sRegex] }
                                    bTokenFound = True
        # token tags
        if "aTags" in dToken and "<tags>" in dNode:
            for sTag in dToken["aTags"]:
                if sTag in dNode["<tags>"]:
                    if bDebug:
                        echo("  MATCH: /" + sTag)
                    yield { "iToken1": iToken1, "iNode": dNode["<tags>"][sTag] }
                    bTokenFound = True
        # meta arc (for token type)
        if "<meta>" in dNode:
            for sMeta in dNode["<meta>"]:
                # no regex here, we just search if <dNode["sType"]> exists within <sMeta>
                if sMeta == "*" or dToken["sType"] == sMeta:
                    if bDebug:
                        echo("  MATCH: *" + sMeta)
                    yield { "iToken1": iToken1, "iNode": dNode["<meta>"][sMeta] }
                    bTokenFound = True
                elif "¬" in sMeta:
                    if dToken["sType"] not in sMeta:
                        if bDebug:
                            echo("  MATCH: *" + sMeta)
                        yield { "iToken1": iToken1, "iNode": dNode["<meta>"][sMeta] }
                        bTokenFound = True
        if not bTokenFound and "bKeep" in dPointer:
            yield dPointer
        # JUMP
        # Warning! Recurssion!
        if "<>" in dNode:
            dPointer2 = { "iToken1": iToken1, "iNode": dNode["<>"], "bKeep": True }
            yield from self._getNextPointers(dToken, dGraph, dPointer2, bDebug)

    def parseGraph (self, dGraph, sCountry="${country_default}", dOptions=None, bShowRuleId=False, bDebug=False, bContext=False):
        "parse graph with tokens from the text and execute actions encountered"
        lPointer = []
        bTagAndRewrite = False
        for iToken, dToken in enumerate(self.lToken):
            if bDebug:
                echo("TOKEN: " + dToken["sValue"])
            # check arcs for each existing pointer
            lNextPointer = []
            for dPointer in lPointer:
                lNextPointer.extend(self._getNextPointers(dToken, dGraph, dPointer, bDebug))
            lPointer = lNextPointer
            # check arcs of first nodes
            lPointer.extend(self._getNextPointers(dToken, dGraph, { "iToken1": iToken, "iNode": 0 }, bDebug))
            # check if there is rules to check for each pointer
            for dPointer in lPointer:
                #if bDebug:
                #    echo("+", dPointer)
                if "<rules>" in dGraph[dPointer["iNode"]]:
                    bChange = self._executeActions(dGraph, dGraph[dPointer["iNode"]]["<rules>"], dPointer["iToken1"]-1, iToken, dOptions, sCountry, bShowRuleId, bDebug, bContext)
                    if bChange:
                        bTagAndRewrite = True
        if bTagAndRewrite:
            self.rewriteFromTags(bDebug)
        if bDebug:
            echo(self)
        return self.sSentence

                                    self.dTags[sWhat] = [nTokenStart, nTokenStart]
                                else:
                                    self.dTags[sWhat][0] = min(nTokenStart, self.dTags[sWhat][0])
                                    self.dTags[sWhat][1] = max(nTokenEnd, self.dTags[sWhat][1])
                            elif cActionType == "!":
                                # immunity
                                if bDebug:
                                    echo("    IMMUNITY: " + sLineId + " / " + sRuleId)
                                nTokenStart = nTokenOffset + eAct[0]  if eAct[0] > 0  else nLastToken + eAct[0]
                                nTokenEnd = nTokenOffset + eAct[1]  if eAct[1] > 0  else nLastToken + eAct[1]
                                if nTokenEnd - nTokenStart == 0:
                                    self.lToken[nTokenStart]["bImmune"] = True
                                    nErrorStart = self.nOffsetWithinParagraph + self.lToken[nTokenStart]["nStart"]
                                    if nErrorStart in self.dError:
                                        del self.dError[nErrorStart]

        xErr.nErrorStart = nStart
        xErr.nErrorLength = nLen
        xErr.nErrorType = PROOFREADING
        xErr.aRuleIdentifier = sRuleId
        xErr.aShortComment = sMessage   # sMessage.split("|")[0]     # in context menu
        xErr.aFullComment = sMessage    # sMessage.split("|")[-1]    # in dialog
        xErr.aSuggestions = tuple(lSugg)
        # Properties
        lProperties = []
        if _nUnderliningStyle:
            lProperties.append(PropertyValue(Name="LineType", Value=_nUnderliningStyle))
        if _bMulticolor:
            lProperties.append(PropertyValue(Name="LineColor", Value=_dOptionsColors.get(sOption, 33023)))
        if sURL:
            lProperties.append(PropertyValue(Name="FullCommentURL", Value=sURL))


        xErr.aProperties = lProperties
        return xErr

    def _createErrorAsDict (self, nStart, nEnd, sLineId, sRuleId, sOption, sMessage, lSugg, sURL, bContext):
        dErr = {
            "nStart": nStart,
            "nEnd": nEnd,
            "sLineId": sLineId,

                if bUppercase:
                    sWhat = sWhat[0:1].upper() + sWhat[1:]
                self.lToken[nTokenRewriteStart]["sNewValue"] = sWhat
            else:
                # several tokens
                lTokenValue = sWhat.split("|")
                if len(lTokenValue) != (nTokenRewriteEnd - nTokenRewriteStart + 1):
                    if (bDebug):
                        echo("Error. Text processor: number of replacements != number of tokens.")
                    return
                for i, sValue in zip(range(nTokenRewriteStart, nTokenRewriteEnd+1), lTokenValue):
                    if not sValue or sValue == "*":
                        self.lToken[i]["bToRemove"] = True
                    else:
                        if bUppercase:
                            sValue = sValue[0:1].upper() + sValue[1:]

    return False


def g_tag (dToken, sTag):
    "returns True if <sTag> is present on token <dToken>"
    return "aTags" in dToken and sTag in dToken["aTags"]


def g_meta (dToken, sType):
    "returns True if <sType> is equal to the token type"
    return dToken["sType"] == sType


def g_space_between_tokens (dToken1, dToken2, nMin, nMax=None):
    "checks if spaces between tokens is >= <nMin> and <= <nMax>"
    nSpace = dToken2["nStart"] - dToken1["nEnd"]
    if nSpace < nMin:
        return False
    if nMax is not None and nSpace > nMax:

    dTokenPos[nPos]["lMorph"] = lMorph
    return True


#### Disambiguation for graph rules

def g_select (dToken, sPattern, lDefault=None):
    "Disambiguation: select morphologies for <dToken> according to <sPattern>, always return True"
    lMorph = dToken["lMorph"]  if "lMorph" in dToken  else _oSpellChecker.getMorph(dToken["sValue"])
    if not lMorph or len(lMorph) == 1:
        if lDefault:
            dToken["lMorph"] = lDefault
            #echo("DA:", dToken["sValue"], dToken["lMorph"])
        return True
    lSelect = [ sMorph  for sMorph in lMorph  if re.search(sPattern, sMorph) ]
    if lSelect:
        if len(lSelect) != len(lMorph):
            dToken["lMorph"] = lSelect
    elif lDefault:
        dToken["lMorph"] = lDefault
    #echo("DA:", dToken["sValue"], dToken["lMorph"])
    return True


def g_exclude (dToken, sPattern, lDefault=None):
    "Disambiguation: select morphologies for <dToken> according to <sPattern>, always return True"
    lMorph = dToken["lMorph"]  if "lMorph" in dToken  else _oSpellChecker.getMorph(dToken["sValue"])
    if not lMorph or len(lMorph) == 1:
        if lDefault:
            dToken["lMorph"] = lDefault
            #echo("DA:", dToken["sValue"], dToken["lMorph"])
        return True
    lSelect = [ sMorph  for sMorph in lMorph  if not re.search(sPattern, sMorph) ]
    if lSelect:
        if len(lSelect) != len(lMorph):
            dToken["lMorph"] = lSelect
    elif lDefault:
        dToken["lMorph"] = lDefault
    #echo("DA:", dToken["sValue"], dToken["lMorph"])
    return True


def g_add_morph (dToken, lNewMorph):
    "Disambiguation: add a morphology to a token"
    lMorph = dToken["lMorph"]  if "lMorph" in dToken  else _oSpellChecker.getMorph(dToken["sValue"])
    lMorph.extend(lNewMorph)
    dToken["lMorph"] = lMorph
    return True


def g_define (dToken, lMorph):
    "Disambiguation: set morphologies of <dToken>, always return True"
    dToken["lMorph"] = lMorph
    #echo("DA:", dToken["sValue"], lMorph)
    return True


def g_define_from (dToken, nLeft=None, nRight=None):
    "Disambiguation: set morphologies of <dToken> with slicing its value with <nLeft> and <nRight>"
    if nLeft is not None:
        dToken["lMorph"] = _oSpellChecker.getMorph(dToken["sValue"][slice(nLeft, nRight)])
    else:
        dToken["lMorph"] = _oSpellChecker.getMorph(dToken["sValue"])
    return True


def g_change_meta (dToken, sType):
    "Disambiguation: change type of token"
    dToken["sType"] = sType
    return True



#### GRAMMAR CHECKER PLUGINS

${plugins}

        self.ImplementationName = "org.openoffice.comp.pyuno.Lightproof." + gce.pkg
        self.SupportedServiceNames = (self.ServiceName, )
        self.locales = []
        for i in gce.locales:
            l = gce.locales[i]
            self.locales.append(Locale(l[0], l[1], l[2]))
        self.locales = tuple(self.locales)
        # debug
        #helpers.startConsole()
        # init
        gce.load("Writer", "nInt")
        # GC options
        #xContext = uno.getComponentContext()
        #opt_handler.load(xContext)
        dOpt = Options.loadOptions("${lang}")
        gce.setOptions(dOpt)
        # dictionaries options
        self.loadUserDictionaries()
        # underlining options
        self.setWriterUnderliningStyle()
        # store for results of big paragraphs
        self.dResult = {}
        self.nMaxRes = 1500
        self.lLastRes = deque(maxlen=self.nMaxRes)
        self.nRes = 0

                return self.dResult[nHashedVal]
        # WORKAROUND ->>>

        xRes.nBehindEndOfSentencePosition = xRes.nStartOfNextSentencePosition

        try:
            xRes.aErrors = tuple(gce.parse(rText, rLocale.Country))

            # ->>> WORKAROUND
            if xRes.nStartOfNextSentencePosition > 3000:
                self.dResult[nHashedVal] = xRes
                self.nRes += 1
                if self.nRes > self.nMaxRes:
                    del self.dResult[self.lLastRes.popleft()]
                    self.nRes = self.nMaxRes
                self.lLastRes.append(nHashedVal)
            # END OF WORKAROUND

        except:

            traceback.print_exc()

        return xRes

    def ignoreRule (self, rid, aLocale):
        gce.ignoreRule(rid)

    def resetIgnoreRules (self):
        gce.resetIgnoreRules()

    # XServiceDisplayName
    def getServiceDisplayName (self, aLocale):
        return gce.name

    # Grammalecte
    def getSpellChecker (self):
        return gce.getSpellChecker()

    def loadUserDictionaries (self):
        try:
            xSettingNode = helpers.getConfigSetting("/org.openoffice.Lightproof_${implname}/Other/", False)
            xChild = xSettingNode.getByName("o_${lang}")
            if xChild.getPropertyValue("use_personal_dic"):
                sJSON = xChild.getPropertyValue("personal_dic")
                if sJSON:
                    oSpellChecker = gce.getSpellChecker();
                    oSpellChecker.setPersonalDictionary(json.loads(sJSON))
        except:
            traceback.print_exc()

    def setWriterUnderliningStyle (self):
        try:
            xSettingNode = helpers.getConfigSetting("/org.openoffice.Lightproof_${implname}/Other/", False)
            xChild = xSettingNode.getByName("o_${lang}")
            sLineType = xChild.getPropertyValue("line_type")
            bMulticolor = bool(xChild.getPropertyValue("line_multicolor"))
            gce.setWriterUnderliningStyle(sLineType, bMulticolor)
        except:
            traceback.print_exc()


g_ImplementationHelper = unohelper.ImplementationHelper()
g_ImplementationHelper.addImplementation(Grammalecte, "org.openoffice.comp.pyuno.Lightproof."+gce.pkg, ("com.sun.star.linguistic2.Proofreader",),)

# g_ImplementationHelper.addImplementation( opt_handler.LightproofOptionsEventHandler, \
#     "org.openoffice.comp.pyuno.LightproofOptionsEventHandler." + gce.pkg, ("com.sun.star.awt.XContainerWindowEventHandler",),)

# Options Dialog
# by Olivier R.
# License: MPL 2

import unohelper
import uno
import traceback

from com.sun.star.awt import XActionListener
from com.sun.star.beans import PropertyValue

import helpers
import op_strings

try:
    import grammalecte.${lang} as gce
except:
    traceback.print_exc()


def loadOptions (sLang):
    "load options from Grammalecte and change them according to LibreOffice settings, returns a dictionary {option_name: boolean}"
    try:
        xNode = helpers.getConfigSetting("/org.openoffice.Lightproof_${implname}/Leaves", False)
        xChild = xNode.getByName(sLang)
        dOpt = gce.gc_options.getOptions("Writer")
        for sKey in dOpt:
            sValue = xChild.getPropertyValue(sKey)
            if sValue != '':
                dOpt[sKey] = bool(int(sValue))
        return dOpt
    except:
        print("# Error. Unable to load options of language:", sLang)
        traceback.print_exc()
        return gce.gc_options.getOptions("Writer")


def saveOptions (sLang, dOpt):
    "save options in LibreOffice profile"
    try:
        xNode = helpers.getConfigSetting("/org.openoffice.Lightproof_${implname}/Leaves", True)
        xChild = xNode.getByName(sLang)
        for sKey, value in dOpt.items():
            xChild.setPropertyValue(sKey, value)
        xNode.commitChanges()
    except:
        traceback.print_exc()



class GC_Options (unohelper.Base, XActionListener):

    def __init__ (self, ctx):
        self.ctx = ctx
        self.xSvMgr = self.ctx.ServiceManager
        self.xContainer = None




    def _addWidget (self, name, wtype, x, y, w, h, **kwargs):
        if wtype.startswith("com."):
            xWidget = self.xDialog.createInstance(wtype)
        else:
            xWidget = self.xDialog.createInstance('com.sun.star.awt.UnoControl%sModel' % wtype)
        xWidget.Name = name
        xWidget.PositionX = x
        xWidget.PositionY = y
        xWidget.Width = w
        xWidget.Height = h
        for k, w in kwargs.items():
            setattr(xWidget, k, w)
        self.xDialog.insertByName(name, xWidget)
        return xWidget

    def run (self, sUI):
        try:
            dUI = op_strings.getUI(sUI)
            dOptionUI = gce.gc_options.getUI(sUI)

            # fonts
            xFDTitle = uno.createUnoStruct("com.sun.star.awt.FontDescriptor")
            xFDTitle.Height = 9
            xFDTitle.Weight = uno.getConstantByName("com.sun.star.awt.FontWeight.BOLD")
            xFDTitle.Name = "Verdana"

            self.xDialog.Height = 400
            self.xDialog.Title = dUI.get('title', "#err")

            # build
            y = 0
            nWidth = self.xDialog.Width - 20
            nHeight = 10

            self.lOptionWidgets = []

            sProdName, sVersion = helpers.getProductNameAndVersion()
            if True:
                # no tab available (bug)
                for sOptionType, lOptions in gce.gc_options.lStructOpt:
                    x = 10
                    y += 10
                    self._addWidget(sOptionType, 'FixedLine', x, y, nWidth, nHeight, Label = dOptionUI.get(sOptionType, "#err")[0], FontDescriptor= xFDTitle)
                    y += 3
                    for lOptLine in lOptions:
                        x = 15
                        y += 10
                        n = len(lOptLine)
                        for sOpt in lOptLine:
                            sLabel, sHelpText = dOptionUI.get(sOpt, "#err")
                            xOpt = self._addWidget(sOpt, 'CheckBox', x, y, nWidth//n, nHeight, Label = sLabel, HelpText = sHelpText)

                            self.lOptionWidgets.append(xOpt)
                            x += nWidth // n
                self.xDialog.Height = y + 40
            else:
                # we can use tabs
                print("1")
                xTabPageContainer = self._addWidget("tabs", "com.sun.star.awt.tab.UnoControlTabPageContainerModel", 10, 10, nWidth, 100)
                xTabPage1 = self.xSvMgr.createInstanceWithContext('com.sun.star.awt.tab.UnoControlTabPageModel', self.ctx)
                xTabPage2 = self.xSvMgr.createInstanceWithContext('com.sun.star.awt.tab.UnoControlTabPageModel', self.ctx)
                #xTabPage1 = xTabPageContainer.createTabPage(1)
                #xTabPage2 = xTabPageContainer.createTabPage(2)
                xTabPage1.Title = "Page 1"
                xTabPage2.Title = "Page 2"
                xTabPageContainer.insertByIndex(0, xTabPage1)
                xTabPageContainer.insertByIndex(1, xTabPage2)
                self.xDialog.Height = 300

            xWindowSize = helpers.getWindowSize()
            self.xDialog.PositionX = int((xWindowSize.Width // 2) - (self.xDialog.Width // 2))
            self.xDialog.PositionY = int((xWindowSize.Height // 2) - (self.xDialog.Height // 2))

            self._addWidget('default', 'Button', 10, self.xDialog.Height-20, 50, 14, \
                            Label = dUI.get('default', "#err"), FontDescriptor = xFDBut, TextColor = 0x000044)
            self._addWidget('apply', 'Button', self.xDialog.Width-115, self.xDialog.Height-20, 50, 14, \
                            Label = dUI.get('apply', "#err"), FontDescriptor = xFDBut, TextColor = 0x004400)
            self._addWidget('cancel', 'Button', self.xDialog.Width-60, self.xDialog.Height-20, 50, 14,
                            Label = dUI.get('cancel', "#err"), FontDescriptor = xFDBut, TextColor = 0x440000)

            dOpt = loadOptions("${lang}")
            self._setWidgets(dOpt)

            # container
            self.xContainer = self.xSvMgr.createInstanceWithContext('com.sun.star.awt.UnoControlDialog', self.ctx)
            self.xContainer.setModel(self.xDialog)
            self.xContainer.getControl('default').addActionListener(self)
            self.xContainer.getControl('default').setActionCommand('Default')
            self.xContainer.getControl('apply').addActionListener(self)

        except:
            traceback.print_exc()

    # XActionListener
    def actionPerformed (self, xActionEvent):
        try:
            if xActionEvent.ActionCommand == 'Default':
                self._setWidgets(gce.gc_options.getOptions("Writer"))
            elif xActionEvent.ActionCommand == 'Apply':
                self._save("${lang}")
                self.xContainer.endExecute()
            elif xActionEvent.ActionCommand == 'Cancel':
                self.xContainer.endExecute()
            else:
                print("Wrong command: " + xActionEvent.ActionCommand)
        except:
            traceback.print_exc()

    # Other
    def _setWidgets (self, dOpt):

        for w in self.lOptionWidgets:
            w.State = dOpt.get(w.Name, False)
















    def _save (self, sLang):
        try:

            saveOptions(sLang, { w.Name: str(w.State)  for w in self.lOptionWidgets })




            gce.setOptions({ w.Name: bool(w.State)  for w in self.lOptionWidgets })

        except:
            traceback.print_exc()

    <info>
        <desc>Contains the options data used for the extension.</desc>
    </info>

    <templates>
        <group oor:name="${lang}">
            <info>
                <desc>Grammar options for language ${lang}.</desc>
            </info>
            ${xcs_options}
        </group>

        <group oor:name="o_${lang}">
            <info>
                <desc>Other options for language ${lang}.</desc>
            </info>
            <!-- spelling options -->
            <prop oor:name="use_graphspell" oor:type="xs:int"><value>1</value></prop>
            <prop oor:name="use_graphspell_sugg" oor:type="xs:int"><value>1</value></prop>

            <prop oor:name="use_community_dic" oor:type="xs:int"><value>0</value></prop>
            <prop oor:name="use_personal_dic" oor:type="xs:int"><value>1</value></prop>
            <prop oor:name="main_dic_name" oor:type="xs:string"><value>classic</value></prop>

            <prop oor:name="community_dic" oor:type="xs:string"><value></value></prop>
            <prop oor:name="personal_dic" oor:type="xs:string"><value></value></prop>
            <!-- graphic options -->
            <prop oor:name="line_multicolor" oor:type="xs:int"><value>1</value></prop>
            <prop oor:name="line_type" oor:type="xs:string"><value>BOLDWAVE</value></prop>
            <!-- misc options -->
            <prop oor:name="start_console" oor:type="xs:int"><value>0</value></prop>
        </group>
    </templates>

    <component>
        <group oor:name="Leaves">
            <node-ref oor:name="${lang}" oor:node-type="${lang}" />
        </group>

# Helpers for LibreOffice extension

import os
import traceback
import subprocess

import uno

from com.sun.star.beans import PropertyValue
from com.sun.star.uno import RuntimeException as _rtex


def startConsole ():
    "open console from APSO extension"
    try:
        xContext = uno.getComponentContext()
        xContext.ServiceManager.createInstance("apso.python.script.organizer.impl")
        # now we can import apso_utils library
        from apso_utils import console
        console()
    except:
        try:
            xContext = uno.getComponentContext()
            xSvMgr = xContext.getServiceManager()
            xPathSettings = xSvMgr.createInstanceWithContext("com.sun.star.util.PathSettings", xContext)
            spPyInstallion = uno.fileUrlToSystemPath(xPathSettings.Module)
            subprocess.Popen(spPyInstallion + os.sep + "python")  # Start Python interactive Shell
        except:
            traceback.print_exc()


def xray (xObject):
    "XRay - API explorer"
    try:
        xSvMgr = uno.getComponentContext().ServiceManager
        xMSPF = xSvMgr.createInstanceWithContext("com.sun.star.script.provider.MasterScriptProviderFactory", uno.getComponentContext())
        xScriptProvider = xMSPF.createScriptProvider("")
        xScript = xScriptProvider.getScript("vnd.sun.star.script:XrayTool._Main.Xray?language=Basic&location=application")
        xScript.invoke((xObject,), (), ())
        return
    except:
        raise _rtex("\nBasic library Xray is not installed", uno.getComponentContext())


def mri (xObject):
    "MRI - API Explorer"
    try:
        xContext = uno.getComponentContext()
        xMri = xContext.ServiceManager.createInstanceWithContext("mytools.Mri", xContext)
        xMri.inspect(xObject)
    except:
        raise _rtex("\nPython extension MRI is not installed", uno.getComponentContext())


def getConfigSetting (sNodeConfig, bUpdate=False):
    "get a configuration node"
    # example: xNode = getConfigSetting("/org.openoffice.Office.Common/Path/Current", False)

def printServices (o):
    for s in o.getAvailableServiceNames():
        print(' > '+s)


def getWindowSize ():
    "return main window size"
    xContext = uno.getComponentContext()
    xDesktop = xContext.getServiceManager().createInstanceWithContext('com.sun.star.frame.Desktop', xContext)
    xContainerWindow = xDesktop.getCurrentComponent().CurrentController.Frame.ContainerWindow
    xWindowSize = xContainerWindow.convertSizeToLogic(xContainerWindow.Size, uno.getConstantByName("com.sun.star.util.MeasureUnit.POINT"))
    #print(xContainerWindow.Size.Width, ">", xWindowSize.Width)
    #print(xContainerWindow.Size.Height, ">", xWindowSize.Height)
    xWindowSize.Width = xWindowSize.Width * 0.666
    xWindowSize.Height = xWindowSize.Height * 0.666
    return xWindowSize


def getAbsolutePathOf (sPath=""):
    xDefaultContext = uno.getComponentContext().ServiceManager.DefaultContext
    xPackageInfoProvider = xDefaultContext.getValueByName("/singletons/com.sun.star.deployment.PackageInformationProvider")
    sFullPath = xPackageInfoProvider.getPackageLocation("French.linguistic.resources.from.Dicollecte.by.OlivierR")
    if sPath and not sPath.startswith("/"):
        sPath = "/" + sPath
    sFullPath = sFullPath[8:] + sPath
    return os.path.abspath(sFullPath)


def getProductNameAndVersion ():
    "returns tuple of software name and version"
    xSettings = getConfigSetting("org.openoffice.Setup/Product", False)
    sProdName = xSettings.getByName("ooName")
    sVersion = xSettings.getByName("ooSetupVersion")
    return (sProdName, sVersion)

#!python3

"""
Text tools
"""

import re
import textwrap
from itertools import chain


_zEndOfSentence = re.compile(r'[.?!:;…]+[»”’)]?[   ]+[»”’]?(?=[«"“‘–—   ]*[A-ZÀÂÉÈÊÎÔÇ])')

def getSentenceBoundaries (sText):
    "generator: returns start and end of sentences found in <sText>"
    iStart = 0
    for m in _zEndOfSentence.finditer(sText):
        yield (iStart, m.end())
        iStart = m.end()

        te / t’     te / t’
        se / s’     lui
        nous        nous
        vous        nous
        se / s’     leur
                    y




    ADVERBE DE NÉGATION (avant)
        ne / n’

    COMBINAISONS VALIDES
        ?[ne|n’]¿   [me|te|se]      [le|la|l’|les]
        ?[ne|n’]¿   [m’|t’|s’]      [le|la|l’|les|en|y]
        ?[ne|n’]¿   [le|la]         [lui|leur]
        ?[ne|n’]¿   [l’|les]        [lui|leur|en|y]
        ?[ne|n’]¿   [lui|leur]      en
        ?[ne|n’]¿   [nous|vous]     [le|la|l’|les|en|y]
        ?[ne|n’]¿   ?[le|la|l’|les|me|m’|te|t’|se|s’|nous|vous|lui|leur]¿
        ?n’¿        [en|y]

    RÉSUMÉ & SIMPLIFICATION
        Toutes les combinaisons:
            ?[ne|n’]¿   ?[le|la|l’|les|en|me|m’|te|t’|se|s’|nous|vous|lui|leur|y]¿
            ?[ne|n’]¿   [me|m’|te|t’|se|s’|nous|vous]   [le|la|l’|les|en|y]
            ?[ne|n’]¿   [le|la|l’|les]                  [lui|leur|en|y]
            ?[ne|n’]¿   [lui|leur|y]                    en

        Détection des syntagmes verbaux:
            [ne|n’|me|m’|te|t’|se|s’]
            [le|la|l’|les|en|nous|vous|lui|leur|y]  @:(?:[123][sp]|P)
            [nous|vous]     [le|la|l’|les|en|y]     @:(?:[123][sp]|P)
            [le|la|l’|les]  [lui|leur|en|y]         @:(?:[123][sp]|P)
            [lui|leur|y]    en                      @:(?:[123][sp]|P)
            @:(?:[123][sp]|P)

    ADVERBE DE NÉGATION (après)
        guère
        jamais
        pas
        plus
        point

    GRAMMALECTE
    Correcteur grammatical pour le français
    version ${version}

    par Olivier R.
    Site web : https://grammalecte.net/
_______________________________________________________________________________

    Basé sur Lightproof
        de László Németh
        http://numbertext.org/lightproof/





    Certaines des règles grammaticales sont reprises du correcteur
    LanguageTool, notamment celles de Dominique Pellé.

    Licence :
        GPL : GNU General Public License
        version 3 ou supérieure -- http://www.gnu.org/licenses/gpl-3.0.html

    Ce correcteur emploie le dictionnaire Hunspell créé par Dicollecte :
    https://grammalecte.net/home.php?prj=fr

import traceback

import graphspell.ibdawg as ibdawg
from graphspell.echo import echo
from graphspell.str_transform import defineSuffixCode
import graphspell.tokenizer as tkz


oDict = None


class cd:
    """Context manager for changing the current working directory"""
    def __init__ (self, newPath):
        self.newPath = os.path.expanduser(newPath)

    def __enter__ (self):

                if sLine == "__END__":
                    break
                if sLine and not sLine.startswith("#"):
                    yield sLine
    else:
        raise OSError("# Error. File not found or not loadable: " + spf)


def loadDictionary ():
    global oDict
    if not oDict:
        try:
            oDict = ibdawg.IBDAWG("fr-allvars.bdic")
        except:
            traceback.print_exc()


def makeDictionaries (sp, sVersion):
    with cd(sp+"/dictionnaire"):
        os.system("genfrdic.py -s -gl -v "+sVersion)


def makeConj (sp, bJS=False):
    print("> Conjugaisons ", end="")
    print("(Python et JavaScript)"  if bJS  else "(Python seulement)")
    dVerb = {}
    lVinfo = []; dVinfo = {}; nVinfo = 0
    lTags = []; dTags = {}; nTags = 0
    dVerbNames = {}

    dPatternList = {
        ":PQ": [], ":Ip": [], ":Iq": [], ":Is": [], ":If": [], ":K": [], ":Sp": [], ":Sq": [], ":E": []
    }
    dTrad = {
        "infi": ":Y", "ppre": ":PQ", "ppas": ":PQ",
        "ipre": ":Ip", "iimp": ":Iq", "ipsi": ":Is", "ifut": ":If",
        "spre": ":Sp", "simp": ":Sq",
        "cond": ":K", "impe": ":E",
        "1sg": ":1s", "2sg": ":2s", "3sg": ":3s", "1pl": ":1p", "2pl": ":2p", "3pl": ":3p", "1isg": ":1ś",
        "mas sg": ":Q1", "mas pl": ":Q2", "mas inv": ":Q1", "fem sg": ":Q3", "fem pl": ":Q4", "epi inv": ":Q1"
    }

    loadDictionary()

    # read lexicon
    nStop = 0
    for n, sLine in enumerate(readFile(sp+"/data/dictConj.txt")):
        nTab = sLine.count("\t")
        if nTab == 1:
            # new entry
            sLemma, sVinfo = sLine.split("\t")
            dConj = {   ":PQ": { ":P": "", ":Q1": "", ":Q2": "", ":Q3": "", ":Q4": ""},
                        ":Ip": { ":1s": "", ":2s": "", ":3s": "", ":1p": "", ":2p": "", ":3p": "", ":1ś": "" },
                        ":Iq": { ":1s": "", ":2s": "", ":3s": "", ":1p": "", ":2p": "", ":3p": "" },
                        ":Is": { ":1s": "", ":2s": "", ":3s": "", ":1p": "", ":2p": "", ":3p": "" },
                        ":If": { ":1s": "", ":2s": "", ":3s": "", ":1p": "", ":2p": "", ":3p": "" },
                        ":K":  { ":1s": "", ":2s": "", ":3s": "", ":1p": "", ":2p": "", ":3p": "" },
                        ":Sp": { ":1s": "", ":2s": "", ":3s": "", ":1p": "", ":2p": "", ":3p": "", ":1ś": "" },
                        ":Sq": { ":1s": "", ":2s": "", ":3s": "", ":1p": "", ":2p": "", ":3p": "", ":1ś": "" },
                        ":E":  { ":2s": "", ":1p": "", ":2p": "" }
                    }
            if sVinfo not in lVinfo:
                dVinfo[sVinfo] = nVinfo
                lVinfo.append(sVinfo)
                nVinfo += 1
            # looking for names derivating from verb
            for sMorph in oDict.getMorph(sLemma):
                if ":N" in sMorph:
                    dVerbNames[sLemma] = { sLemma }
                    break
        elif nTab == 2:
            # flexion
            _, sTag, sFlex = sLine.split("\t")
            if sTag.count(" ") == 0:
                if sTag == "ppre":
                    dConj[":PQ"][":P"] = defineSuffixCode(sLemma, sFlex)
            else:
                try:
                    mode, g = sTag.split(maxsplit=1)
                    mode = dTrad[mode]
                    g = dTrad[g]
                    if dConj[mode][g] == "":
                        dConj[mode][g] = defineSuffixCode(sLemma, sFlex)
                    else:
                        # comment gérer les autres graphies ?
                        pass
                except:
                    echo(sLemma, " - ", sTag, " - non géré: ", mode, " / ", g)
            # looking for names derivating from verb
            for sMorph in oDict.getMorph(sFlex):
                if ":N" in sMorph:
                    if sLemma not in dVerbNames:
                        dVerbNames[sLemma] = { sFlex }
                    else:
                        dVerbNames[sLemma].add(sFlex)
                    break
        elif sLine == "$":
            # we store the dictionary of rules for this lemma
            if dConj[":Ip"][":1ś"] == "2è":
                dConj[":Ip"][":1ś"] = "2é"
            elif sLemma == "pouvoir":
                dConj[":Ip"][":1ś"] = "6uis"
            lConjTags = []
            for sTense in [":PQ", ":Ip", ":Iq", ":Is", ":If", ":K", ":Sp", ":Sq", ":E"]:
                bFound = False
                for i, d in enumerate(dPatternList[sTense]):
                    if dConj[sTense] == d:
                        bFound = True
                        lConjTags.append(i)
                        break
                if not bFound:
                    lConjTags.append(len(dPatternList[sTense]))
                    dPatternList[sTense].append(dConj[sTense])
            tConjTags = tuple(lConjTags)
            if tConjTags not in lTags:
                dTags[tConjTags] = nTags
                lTags.append(tConjTags)
                nTags += 1
            dVerb[sLemma] = (dVinfo[sVinfo], dTags[tConjTags])
        else:
            print("# Error - unknown line", n)













    for sLemma, aNames in dVerbNames.items():









        dVerbNames[sLemma] = tuple(aNames)  # convert set to tuple

    ## write file for Python
    sCode = "## generated data (do not edit)\n\n" + \
            "# Informations about verbs\n" + \
            "lVtyp = " + str(lVinfo) + "\n\n" + \
            "# indexes of tenses in _dPatternConj\n" + \
            "lTags = " + str(lTags) + "\n\n" + \
            "# lists of affix codes to generate inflected forms\n" + \
            "dPatternConj = " + str(dPatternList) + "\n\n" + \
            "# dictionary of verbs : (index of Vtyp, index of Tags)\n" + \
            "dVerb = " + str(dVerb) + "\n\n" + \
            "# names as derivatives from verbs\n" + \
            "dVerbNames = " + str(dVerbNames) + "\n"
    open(sp+"/modules/conj_data.py", "w", encoding="utf-8", newline="\n").write(sCode)

    if bJS:
        ## write file for JavaScript
        with open(sp+"/modules-js/conj_data.json", "w", encoding="utf-8", newline="\n") as hDst:
            hDst.write("{\n")
            hDst.write('    "lVtyp": ' + json.dumps(lVinfo, ensure_ascii=False) + ",\n")
            hDst.write('    "lTags": ' + json.dumps(lTags, ensure_ascii=False) + ",\n")
            hDst.write('    "dPatternConj": ' + json.dumps(dPatternList, ensure_ascii=False) + ",\n")
            hDst.write('    "dVerb": ' + json.dumps(dVerb, ensure_ascii=False) + ",\n")
            hDst.write('    "dVerbNames": ' + json.dumps(dVerbNames, ensure_ascii=False) + "\n")
            hDst.write("}\n")


def makeMfsp (sp, bJS=False):
    print("> Pluriel/singulier/masculin/féminin ", end="")
    print("(Python et JavaScript)"  if bJS  else "(Python seulement)")
    aPlurS = set()

                '    "dMasForm": ' +  json.dumps(dMasForm, ensure_ascii=False) + "\n}"
        open(sp+"/modules-js/mfsp_data.json", "w", encoding="utf-8", newline="\n").write(sCode)


def makePhonetTable (sp, bJS=False):
    print("> Correspondances phonétiques ", end="")
    print("(Python et JavaScript)"  if bJS  else "(Python seulement)")

    import gc_lang.fr.modules.conj as conj

    loadDictionary()





    # set of homophonic words
    lSet = []
    for sLine in readFile(sp+"/data/phonet_simil.txt"):
        lWord = sLine.split()
        aMore = set()
        for sWord in lWord:

[args]
lang = fr
lang_name = French
locales = fr_FR fr_BE fr_CA fr_CH fr_LU fr_BF fr_BJ fr_CD fr_CI fr_CM fr_MA fr_ML fr_MU fr_NE fr_RE fr_SN fr_TG
country_default = FR
name = Grammalecte
implname = grammalecte
# always use 3 numbers for version: x.y.z
version = 1.3.2
author = Olivier R.
provider = Grammalecte.net
link = https://grammalecte.net
description = Correcteur grammatical, orthographique et typographique pour le français.
extras = README_fr.txt
logo = logo.png

# Finite state automaton compression: 1, 2 (experimental) or 3 (experimental)
fsa_method = 1
# stemming method: S for suffixes only, A for prefixes and suffixes
stemming_method = S

# LibreOffice
unopkg = C:/Program Files/LibreOffice/program/unopkg.com
oxt_version = 6.4.2
oxt_identifier = French.linguistic.resources.from.Dicollecte.by.OlivierR
oxt_update_info_URL = https://grammalecte.net/grammalecte/oxt/grammalecte.update.xml

# Firefox
fx_identifier = French-GC@grammalecte.net
fx_name = Grammalecte [fr]

[oxt]
# the following files must be in your project folder, files will be copied into the zip archive
rules.grx = fr-rules.txt
oxt/addons.xcu = addons.xcu
oxt/package-description.txt = package-description.txt
# icons & images
oxt/_img = img





# AppLauncher
oxt/AppLauncher.py = AppLauncher.py
# Graphspell
oxt/Graphspell.py = Graphspell.py



# Dictionaries
oxt/Dictionnaires/dictionaries = dictionaries
oxt/Dictionnaires/dictionaries.xcu = dictionaries.xcu









# ContextMenu
oxt/ContextMenu/ContextMenu.py = ContextMenu.py
oxt/ContextMenu/jobs.xcu = config/jobs.xcu
# Dictionary Options
oxt/DictOptions = pythonpath
# Graphic options
oxt/GraphicOptions = pythonpath
# TextFormatter
oxt/TextFormatter = pythonpath
# Lexicographer
oxt/Lexicographer = pythonpath

# Conjugueur
oxt/Conjugueur = pythonpath
# Modify author
oxt/ChangeAuthor = pythonpath
# About
oxt/About = pythonpath

_	impe 1pl	barricadons
_	impe 2pl	barricadez
_	ppas mas sg	barricadé
_	ppas mas pl	barricadés
_	ppas fem sg	barricadée
_	ppas fem pl	barricadées
$
barriérer	1_it____a
_	infi	barriérer
_	ppre	barriérant
_	ipre 1sg	barrière
_	ipre 3sg	barrière
_	spre 1sg	barrière
_	spre 3sg	barrière
_	ipre 1isg	barriérè
_	ipre 2sg	barrières
_	spre 2sg	barrières
_	ipre 1pl	barriérons
_	ipre 2pl	barriérez
_	ipre 3pl	barrièrent
_	spre 3pl	barrièrent
_	iimp 1sg	barriérais
_	iimp 2sg	barriérais
_	iimp 3sg	barriérait
_	iimp 1pl	barriérions
_	spre 1pl	barriérions
_	iimp 2pl	barriériez
_	spre 2pl	barriériez
_	iimp 3pl	barriéraient
_	ipsi 1sg	barriérai
_	ipsi 2sg	barriéras
_	ipsi 3sg	barriéra
_	ipsi 1pl	barriérâmes
_	ipsi 2pl	barriérâtes
_	ipsi 3pl	barriérèrent
_	ifut 1sg	barriérerai
_	ifut 1sg	barrièrerai
_	ifut 2sg	barriéreras
_	ifut 2sg	barrièreras
_	ifut 3sg	barriérera
_	ifut 3sg	barrièrera
_	ifut 1pl	barriérerons
_	ifut 1pl	barrièrerons
_	ifut 2pl	barriérerez
_	ifut 2pl	barrièrerez
_	ifut 3pl	barriéreront
_	ifut 3pl	barrièreront
_	cond 1sg	barriérerais
_	cond 2sg	barriérerais
_	cond 1sg	barrièrerais
_	cond 2sg	barrièrerais
_	cond 3sg	barriérerait
_	cond 3sg	barrièrerait
_	cond 1pl	barriérerions
_	cond 1pl	barrièrerions
_	cond 2pl	barriéreriez
_	cond 2pl	barrièreriez
_	cond 3pl	barriéreraient
_	cond 3pl	barrièreraient
_	simp 1sg	barriérasse
_	simp 2sg	barriérasses
_	simp 3sg	barriérât
_	simp 1pl	barriérassions
_	simp 2pl	barriérassiez
_	simp 3pl	barriérassent
_	impe 2sg	barrière
_	impe 1pl	barriérons
_	impe 2pl	barriérez
_	ppas mas sg	barriéré
_	ppas mas pl	barriérés
_	ppas fem sg	barriérée
_	ppas fem pl	barriérées
$
barrir	2_i____zz
_	infi	barrir
_	ppre	barrissant
_	ipre 1sg	barris
_	ipre 2sg	barris
_	ipsi 1sg	barris
_	ipsi 2sg	barris

_	simp 1pl	fuissions
_	simp 2pl	fuissiez
_	simp 3pl	fuissent
_	impe 2sg	fuis
_	impe 1pl	fuyons
_	impe 2pl	fuyez
$
fuiter	1_it____a
_	infi	fuiter
_	ppre	fuitant
_	ipre 1sg	fuite
_	ipre 3sg	fuite
_	spre 1sg	fuite
_	spre 3sg	fuite
_	ipre 1isg	fuitè

_	impe 1pl	redistribuons
_	impe 2pl	redistribuez
_	ppas mas sg	redistribué
_	ppas mas pl	redistribués
_	ppas fem sg	redistribuée
_	ppas fem pl	redistribuées
$
rediviniser	1_it_q__a
_	infi	rediviniser
_	ppre	redivinisant
_	ipre 1sg	redivinise
_	ipre 3sg	redivinise
_	spre 1sg	redivinise
_	spre 3sg	redivinise
_	ipre 1isg	redivinisè
_	ipre 2sg	redivinises
_	spre 2sg	redivinises
_	ipre 1pl	redivinisons
_	ipre 2pl	redivinisez
_	ipre 3pl	redivinisent
_	spre 3pl	redivinisent
_	iimp 1sg	redivinisais
_	iimp 2sg	redivinisais
_	iimp 3sg	redivinisait
_	iimp 1pl	redivinisions
_	spre 1pl	redivinisions
_	iimp 2pl	redivinisiez
_	spre 2pl	redivinisiez
_	iimp 3pl	redivinisaient
_	ipsi 1sg	redivinisai
_	ipsi 2sg	redivinisas
_	ipsi 3sg	redivinisa
_	ipsi 1pl	redivinisâmes
_	ipsi 2pl	redivinisâtes
_	ipsi 3pl	redivinisèrent
_	ifut 1sg	rediviniserai
_	ifut 2sg	rediviniseras
_	ifut 3sg	redivinisera
_	ifut 1pl	rediviniserons
_	ifut 2pl	rediviniserez
_	ifut 3pl	rediviniseront
_	cond 1sg	rediviniserais
_	cond 2sg	rediviniserais
_	cond 3sg	rediviniserait
_	cond 1pl	rediviniserions
_	cond 2pl	rediviniseriez
_	cond 3pl	rediviniseraient
_	simp 1sg	redivinisasse
_	simp 2sg	redivinisasses
_	simp 3sg	redivinisât
_	simp 1pl	redivinisassions
_	simp 2pl	redivinisassiez
_	simp 3pl	redivinisassent
_	impe 2sg	redivinise
_	impe 1pl	redivinisons
_	impe 2pl	redivinisez
_	ppas mas sg	redivinisé
_	ppas mas pl	redivinisés
_	ppas fem sg	redivinisée
_	ppas fem pl	redivinisées
$
rediviser	1__t_q__a
_	infi	rediviser
_	ppre	redivisant
_	ipre 1sg	redivise
_	ipre 3sg	redivise
_	spre 1sg	redivise
_	spre 3sg	redivise

_	simp 1pl	refondissions
_	simp 2pl	refondissiez
_	simp 3pl	refondissent
_	impe 2sg	refonds
_	impe 1pl	refondons
_	impe 2pl	refondez
$
reforester	1_it____a
_	infi	reforester
_	ppre	reforestant
_	ipre 1sg	reforeste
_	ipre 3sg	reforeste
_	spre 1sg	reforeste
_	spre 3sg	reforeste
_	ipre 1isg	reforestè
_	ipre 2sg	reforestes
_	spre 2sg	reforestes
_	ipre 1pl	reforestons
_	ipre 2pl	reforestez
_	ipre 3pl	reforestent
_	spre 3pl	reforestent
_	iimp 1sg	reforestais
_	iimp 2sg	reforestais
_	iimp 3sg	reforestait
_	iimp 1pl	reforestions
_	spre 1pl	reforestions
_	iimp 2pl	reforestiez
_	spre 2pl	reforestiez
_	iimp 3pl	reforestaient
_	ipsi 1sg	reforestai
_	ipsi 2sg	reforestas
_	ipsi 3sg	reforesta
_	ipsi 1pl	reforestâmes
_	ipsi 2pl	reforestâtes
_	ipsi 3pl	reforestèrent
_	ifut 1sg	reforesterai
_	ifut 2sg	reforesteras
_	ifut 3sg	reforestera
_	ifut 1pl	reforesterons
_	ifut 2pl	reforesterez
_	ifut 3pl	reforesteront
_	cond 1sg	reforesterais
_	cond 2sg	reforesterais
_	cond 3sg	reforesterait
_	cond 1pl	reforesterions
_	cond 2pl	reforesteriez
_	cond 3pl	reforesteraient
_	simp 1sg	reforestasse
_	simp 2sg	reforestasses
_	simp 3sg	reforestât
_	simp 1pl	reforestassions
_	simp 2pl	reforestassiez
_	simp 3pl	reforestassent
_	impe 2sg	reforeste
_	impe 1pl	reforestons
_	impe 2pl	reforestez
_	ppas mas sg	reforesté
_	ppas mas pl	reforestés
_	ppas fem sg	reforestée
_	ppas fem pl	reforestées
$
reforger	1__t___zz
_	infi	reforger
_	ppre	reforgeant
_	ipre 1sg	reforge
_	ipre 3sg	reforge
_	spre 1sg	reforge
_	spre 3sg	reforge

_	impe 1pl	shootons
_	impe 2pl	shootez
_	ppas mas sg	shooté
_	ppas mas pl	shootés
_	ppas fem sg	shootée
_	ppas fem pl	shootées
$
shorter	1_it____a
_	infi	shorter
_	ppre	shortant
_	ipre 1sg	shorte
_	ipre 3sg	shorte
_	spre 1sg	shorte
_	spre 3sg	shorte
_	ipre 1isg	shortè
_	ipre 2sg	shortes
_	spre 2sg	shortes
_	ipre 1pl	shortons
_	ipre 2pl	shortez
_	ipre 3pl	shortent
_	spre 3pl	shortent
_	iimp 1sg	shortais
_	iimp 2sg	shortais
_	iimp 3sg	shortait
_	iimp 1pl	shortions
_	spre 1pl	shortions
_	iimp 2pl	shortiez
_	spre 2pl	shortiez
_	iimp 3pl	shortaient
_	ipsi 1sg	shortai
_	ipsi 2sg	shortas
_	ipsi 3sg	shorta
_	ipsi 1pl	shortâmes
_	ipsi 2pl	shortâtes
_	ipsi 3pl	shortèrent
_	ifut 1sg	shorterai
_	ifut 2sg	shorteras
_	ifut 3sg	shortera
_	ifut 1pl	shorterons
_	ifut 2pl	shorterez
_	ifut 3pl	shorteront
_	cond 1sg	shorterais
_	cond 2sg	shorterais
_	cond 3sg	shorterait
_	cond 1pl	shorterions
_	cond 2pl	shorteriez
_	cond 3pl	shorteraient
_	simp 1sg	shortasse
_	simp 2sg	shortasses
_	simp 3sg	shortât
_	simp 1pl	shortassions
_	simp 2pl	shortassiez
_	simp 3pl	shortassent
_	impe 2sg	shorte
_	impe 1pl	shortons
_	impe 2pl	shortez
_	ppas mas sg	shorté
_	ppas mas pl	shortés
_	ppas fem sg	shortée
_	ppas fem pl	shortées
$
shunter	1__t___zz
_	infi	shunter
_	ppre	shuntant
_	ipre 1sg	shunte
_	ipre 3sg	shunte
_	spre 1sg	shunte
_	spre 3sg	shunte

_	impe 1pl	solutionnons
_	impe 2pl	solutionnez
_	ppas mas sg	solutionné
_	ppas mas pl	solutionnés
_	ppas fem sg	solutionnée
_	ppas fem pl	solutionnées
$
solvabiliser	1_it____a
_	infi	solvabiliser
_	ppre	solvabilisant
_	ipre 1sg	solvabilise
_	ipre 3sg	solvabilise
_	spre 1sg	solvabilise
_	spre 3sg	solvabilise
_	ipre 1isg	solvabilisè
_	ipre 2sg	solvabilises
_	spre 2sg	solvabilises
_	ipre 1pl	solvabilisons
_	ipre 2pl	solvabilisez
_	ipre 3pl	solvabilisent
_	spre 3pl	solvabilisent
_	iimp 1sg	solvabilisais
_	iimp 2sg	solvabilisais
_	iimp 3sg	solvabilisait
_	iimp 1pl	solvabilisions
_	spre 1pl	solvabilisions
_	iimp 2pl	solvabilisiez
_	spre 2pl	solvabilisiez
_	iimp 3pl	solvabilisaient
_	ipsi 1sg	solvabilisai
_	ipsi 2sg	solvabilisas
_	ipsi 3sg	solvabilisa
_	ipsi 1pl	solvabilisâmes
_	ipsi 2pl	solvabilisâtes
_	ipsi 3pl	solvabilisèrent
_	ifut 1sg	solvabiliserai
_	ifut 2sg	solvabiliseras
_	ifut 3sg	solvabilisera
_	ifut 1pl	solvabiliserons
_	ifut 2pl	solvabiliserez
_	ifut 3pl	solvabiliseront
_	cond 1sg	solvabiliserais
_	cond 2sg	solvabiliserais
_	cond 3sg	solvabiliserait
_	cond 1pl	solvabiliserions
_	cond 2pl	solvabiliseriez
_	cond 3pl	solvabiliseraient
_	simp 1sg	solvabilisasse
_	simp 2sg	solvabilisasses
_	simp 3sg	solvabilisât
_	simp 1pl	solvabilisassions
_	simp 2pl	solvabilisassiez
_	simp 3pl	solvabilisassent
_	impe 2sg	solvabilise
_	impe 1pl	solvabilisons
_	impe 2pl	solvabilisez
_	ppas mas sg	solvabilisé
_	ppas mas pl	solvabilisés
_	ppas fem sg	solvabilisée
_	ppas fem pl	solvabilisées
$
solvater	1_it____a
_	infi	solvater
_	ppre	solvatant
_	ipre 1sg	solvate
_	ipre 3sg	solvate
_	spre 1sg	solvate
_	spre 3sg	solvate

_	nom mas sg	acquittement
_	nom mas pl	acquittements
$
acra	S*()
_	nom mas sg	acra
_	nom mas pl	acras
$
acratopège	S*()
_	adj epi sg	acratopège
_	adj epi pl	acratopèges
$
âcre	S*()
_	adj epi sg	âcre
_	adj epi pl	âcres
$
acre	S*()
_	nom fem sg	acre
_	nom fem pl	acres

_	nom adj epi sg	anarchocapitaliste
_	nom adj epi pl	anarchocapitalistes
$
anarcho-capitaliste	S*()
_	nom adj epi sg	anarcho-capitaliste
_	nom adj epi pl	anarcho-capitalistes
$
anarchocommunisme	S*()
_	nom mas sg	anarchocommunisme
_	nom mas pl	anarchocommunismes
$
anarcho-communisme	S*()
_	nom mas sg	anarcho-communisme
_	nom mas pl	anarcho-communismes
$
anarcho-primitivisme	S*()
_	nom mas sg	anarcho-primitivisme
_	nom mas pl	anarcho-primitivismes
$
anarchosyndicalisme	S*()
_	nom mas sg	anarchosyndicalisme
_	nom mas pl	anarchosyndicalismes

_	adj mas sg	antitussif
_	adj mas pl	antitussifs
$
antivaccin	S=
_	adj epi inv	antivaccin
_	adj epi inv	antivaccins
$
antivaccination	S*()
_	adj epi sg	antivaccination
_	adj epi pl	antivaccinations
$
antivariolique	S*()
_	adj epi sg	antivariolique
_	adj epi pl	antivarioliques
$
antivénéneuse	W*()
_	adj fem sg	antivénéneuse
_	adj fem pl	antivénéneuses

_	nom mas sg	barreur
_	nom mas pl	barreurs
$
barricade	S.()
_	nom fem sg	barricade
_	nom fem pl	barricades
$
barriérage	S.()
_	nom mas sg	barriérage
_	nom mas pl	barriérages
$
barrière	S.()
_	nom fem sg	barrière
_	nom fem pl	barrières
$
barrio	S.()
_	nom mas sg	barrio
_	nom mas pl	barrios

_	nom fem sg	bétaillère
_	nom fem pl	bétaillères
$
bétaïne	S.()
_	nom fem sg	bétaïne
_	nom fem pl	bétaïnes
$
bêtalactamase	S.()
_	nom fem sg	bêtalactamase
_	nom fem pl	bêtalactamases
$
bêta-lactamase	S.()
_	nom fem sg	bêta-lactamase
_	nom fem pl	bêta-lactamases
$
bêtalactamine	S.()
_	nom fem sg	bêtalactamine
_	nom fem pl	bêtalactamines
$
bêta-lactamine	S.()
_	nom fem sg	bêta-lactamine
_	nom fem pl	bêta-lactamines

_	nom mas sg	cocktail
_	nom mas pl	cocktails
$
coco	S.()
_	nom mas sg	coco
_	nom mas pl	cocos
$
cocommanditaire	S.()
_	nom epi sg	cocommanditaire
_	nom epi pl	cocommanditaires
$
cocompacte	F.()
_	adj fem sg	cocompacte
_	adj fem pl	cocompactes
_	adj mas sg	cocompact
_	adj mas pl	cocompacts
$
cocon	S.()

$
conséquente	F.()
_	adj fem sg	conséquente
_	adj fem pl	conséquentes
_	adj mas sg	conséquent
_	adj mas pl	conséquents
$
conséquentialisme	S.()
_	nom mas sg	conséquentialisme
_	nom mas pl	conséquentialismes
$
conséquentialiste	S.()
_	nom adj epi sg	conséquentialiste
_	nom adj epi pl	conséquentialistes
$
conservable	S.()
_	adj epi sg	conservable
_	adj epi pl	conservables
$
conservation	S.()
_	nom fem sg	conservation
_	nom fem pl	conservations

$
contributive	F.()
_	adj fem sg	contributive
_	adj fem pl	contributives
_	adj mas sg	contributif
_	adj mas pl	contributifs
$
contributivité	S.()
_	nom fem sg	contributivité
_	nom fem pl	contributivités
$
contributoire	S.()
_	adj epi sg	contributoire
_	adj epi pl	contributoires
$
contributrice	F.()
_	nom fem sg	contributrice
_	nom fem pl	contributrices

_	nom epi sg	controversiste
_	nom epi pl	controversistes
$
contumace	S.()
_	nom adj epi sg	contumace
_	nom adj epi pl	contumaces
$
contumélie	S.()
_	nom fem sg	contumélie
_	nom fem pl	contumélies
$
contuse	F.()
_	adj fem sg	contuse
_	adj fem pl	contuses
_	adj mas inv	contus
$
contusion	S.()
_	nom fem sg	contusion

_	nom fem sg	déambulation
_	nom fem pl	déambulations
$
déambulatoire	S.()
_	adj epi sg	déambulatoire
_	adj epi pl	déambulatoires
$
deauvillaise	F.()
_	nom adj fem sg	deauvillaise
_	nom adj fem pl	deauvillaises
_	nom adj mas inv	deauvillais
$
débâchage	S.()
_	nom mas sg	débâchage
_	nom mas pl	débâchages
$
débâcle	S.()
_	nom fem sg	débâcle
_	nom fem pl	débâcles

_	adj epi sg	débrayable
_	adj epi pl	débrayables
$
débrayage	S.()
_	nom mas sg	débrayage
_	nom mas pl	débrayages
$
débridage	S.()
_	nom mas sg	débridage
_	nom mas pl	débridages
$
débridement	S.()
_	nom mas sg	débridement
_	nom mas pl	débridements
$
debriefing	S.()
_	nom mas sg	debriefing
_	nom mas pl	debriefings

$
demi-morte	F.()
_	adj fem sg	demi-morte
_	adj fem pl	demi-mortes
_	adj mas sg	demi-mort
_	adj mas pl	demi-morts
$
demi-mot	S.()
_	nom mas sg	demi-mot
_	nom mas pl	demi-mots
$
déminage	S.()
_	nom mas sg	déminage
_	nom mas pl	déminages
$
déminéralisation	S.()
_	nom fem sg	déminéralisation
_	nom fem pl	déminéralisations

_	nom mas sg	désillusionnement
_	nom mas pl	désillusionnements
$
désimbrication	S.()
_	nom fem sg	désimbrication
_	nom fem pl	désimbrications
$
désimlockage	S.()
_	nom mas sg	désimlockage
_	nom mas pl	désimlockages
$
désincarcération	S.()
_	nom fem sg	désincarcération
_	nom fem pl	désincarcérations
$
désincarnation	S.()
_	nom fem sg	désincarnation
_	nom fem pl	désincarnations

$
désintégrative	F.()
_	adj fem sg	désintégrative
_	adj fem pl	désintégratives
_	adj mas sg	désintégratif
_	adj mas pl	désintégratifs
$
désintensification	S.()
_	nom fem sg	désintensification
_	nom fem pl	désintensifications
$
désintéressement	S.()
_	nom mas sg	désintéressement
_	nom mas pl	désintéressements
$
désintérêt	S.()
_	nom mas sg	désintérêt
_	nom mas pl	désintérêts

_	nom adj mas sg	disputeur
_	nom adj mas pl	disputeurs
$
disquaire	S.()
_	nom epi sg	disquaire
_	nom epi pl	disquaires
$
disqualifiante	F.()
_	adj fem sg	disqualifiante
_	adj fem pl	disqualifiantes
_	adj mas sg	disqualifiant
_	adj mas pl	disqualifiants
$
disqualification	S.()
_	nom fem sg	disqualification
_	nom fem pl	disqualifications
$
disqualifiée	F.()
_	nom adj fem sg	disqualifiée
_	nom adj fem pl	disqualifiées

$
distributionnelle	F.()
_	adj fem sg	distributionnelle
_	adj fem pl	distributionnelles
_	adj mas sg	distributionnel
_	adj mas pl	distributionnels
$
distributisme	S.()
_	nom mas sg	distributisme
_	nom mas pl	distributismes
$
distributive	F.()
_	adj fem sg	distributive
_	adj fem pl	distributives
_	adj mas sg	distributif
_	adj mas pl	distributifs
$
distributivité	S.()

$
durative	F.()
_	adj fem sg	durative
_	adj fem pl	duratives
_	adj mas sg	duratif
_	adj mas pl	duratifs
$
durcissante	F.()
_	adj fem sg	durcissante
_	adj fem pl	durcissantes
_	adj mas sg	durcissant
_	adj mas pl	durcissants
$
durcissement	S.()
_	nom mas sg	durcissement
_	nom mas pl	durcissements
$
durcisseur	S.()
_	nom mas sg	durcisseur
_	nom mas pl	durcisseurs

_	adj mas sg	efflorescent
_	adj mas pl	efflorescents
$
effluence	S*()
_	nom fem sg	effluence
_	nom fem pl	effluences
$
effluent	S*()
_	nom mas sg	effluent
_	nom mas pl	effluents
$
effluente	F*()
_	adj fem sg	effluente
_	adj fem pl	effluentes
_	adj mas sg	effluent
_	adj mas pl	effluents
$
effluve	S*()

$
émiratie	F*()
_	nom adj fem sg	émiratie
_	nom adj fem pl	émiraties
_	nom adj mas sg	émirati
_	nom adj mas pl	émiratis
$
émirienne	F*()
_	nom adj fem sg	émirienne
_	nom adj fem pl	émiriennes
_	nom adj mas sg	émirien
_	nom adj mas pl	émiriens
$
émissaire	S*()
_	nom epi sg	émissaire
_	nom epi pl	émissaires
$
émission	S*()
_	nom fem sg	émission
_	nom fem pl	émissions

_	adj epi sg	épileptiforme
_	adj epi pl	épileptiformes
$
épileptique	S*()
_	nom epi sg	épileptique
_	nom epi pl	épileptiques
$
épileptogène	S*()
_	adj epi sg	épileptogène
_	adj epi pl	épileptogènes
$
épileptologue	S*()
_	nom epi sg	épileptologue
_	nom epi pl	épileptologues
$
épileuse	F*()
_	nom fem sg	épileuse
_	nom fem pl	épileuses

_	adj epi sg	épiphane
_	adj epi pl	épiphanes
$
épiphanie	S*()
_	nom fem sg	épiphanie
_	nom fem pl	épiphanies
$
épiphanique	S*()
_	adj epi sg	épiphanique
_	adj epi pl	épiphaniques
$
épiphénoménale	W*()
_	adj fem sg	épiphénoménale
_	adj fem pl	épiphénoménales
_	adj mas sg	épiphénoménal
_	adj mas pl	épiphénoménaux
$
épiphénomène	S*()

$
extra-professionnelle	F*()
_	adj fem sg	extra-professionnelle
_	adj fem pl	extra-professionnelles
_	adj mas sg	extra-professionnel
_	adj mas pl	extra-professionnels
$
extrarégionale	W*()
_	adj fem sg	extrarégionale
_	adj fem pl	extrarégionales
_	adj mas sg	extrarégional
_	adj mas pl	extrarégionaux
$
extrarénale	W*()
_	adj fem sg	extrarénale
_	adj fem pl	extrarénales
_	adj mas sg	extrarénal
_	adj mas pl	extrarénaux
$
extrascolaire	S*()

$
fanatisante	F.()
_	adj fem sg	fanatisante
_	adj fem pl	fanatisantes
_	adj mas sg	fanatisant
_	adj mas pl	fanatisants
$
fanatisation	S.()
_	nom fem sg	fanatisation
_	nom fem pl	fanatisations
$
fanatiseuse	F.()
_	nom fem sg	fanatiseuse
_	nom fem pl	fanatiseuses
_	nom mas sg	fanatiseur
_	nom mas pl	fanatiseurs
$
fanatisme	S.()

_	nom fem sg	figuline
_	nom fem pl	figulines
$
figurable	S.()
_	adj epi sg	figurable
_	adj epi pl	figurables
$
figurale	W.()
_	adj fem sg	figurale
_	adj fem pl	figurales
_	adj mas sg	figural
_	adj mas pl	figuraux
$
figuralisme	S.()
_	nom mas sg	figuralisme
_	nom mas pl	figuralismes
$
figurante	F.()
_	nom fem sg	figurante
_	nom fem pl	figurantes

_	nom fem sg	gélivure
_	nom fem pl	gélivures
$
gélose	S.()
_	nom fem sg	gélose
_	nom fem pl	géloses
$
gélosée	F.()
_	adj fem sg	gélosée
_	adj fem pl	gélosées
_	adj mas sg	gélosé
_	adj mas pl	gélosés
$
gélule	S.()
_	nom fem sg	gélule
_	nom fem pl	gélules
$
gelure	S.()
_	nom fem sg	gelure
_	nom fem pl	gelures

_	nom mas sg	geôlage
_	nom mas pl	geôlages
$
geôle	S.()
_	nom fem sg	geôle
_	nom fem pl	geôles
$
géolecte	S.()
_	nom mas sg	géolecte
_	nom mas pl	géolectes
$
geôlière	F.()
_	nom fem sg	geôlière
_	nom fem pl	geôlières
_	nom mas sg	geôlier
_	nom mas pl	geôliers
$
géolocalisation	S.()

_	nom fem sg	granulie
_	nom fem pl	granulies
$
granulite	S.()
_	nom fem sg	granulite
_	nom fem pl	granulites
$
granulocytaire	S.()
_	adj epi sg	granulocytaire
_	adj epi pl	granulocytaires
$
granulocyte	S.()
_	nom mas sg	granulocyte
_	nom mas pl	granulocytes
$
granulomatose	S.()
_	nom fem sg	granulomatose
_	nom fem pl	granulomatoses

_	nom adj epi sg	grégaire
_	nom adj epi pl	grégaires
$
grégarisme	S.()
_	nom mas sg	grégarisme
_	nom mas pl	grégarismes
$
grégarité	S.()
_	nom fem sg	grégarité
_	nom fem pl	grégarités
$
grège	S.()
_	adj epi sg	grège
_	adj epi pl	grèges
$
grégorienne	F.()
_	adj fem sg	grégorienne
_	adj fem pl	grégoriennes

_	nom fem sg	hépatomégalie
_	nom fem pl	hépatomégalies
$
hépatonéphrite	S*()
_	nom fem sg	hépatonéphrite
_	nom fem pl	hépatonéphrites
$
hépatotoxicité	S*()
_	nom fem sg	hépatotoxicité
_	nom fem pl	hépatotoxicités
$
hépatotoxique	S*()
_	adj epi sg	hépatotoxique
_	adj epi pl	hépatotoxiques
$
hépiale	S*()
_	nom mas sg	hépiale
_	nom mas pl	hépiales

$
immersive	F*()
_	adj fem sg	immersive
_	adj fem pl	immersives
_	adj mas sg	immersif
_	adj mas pl	immersifs
$
immesurable	S*()
_	adj epi sg	immesurable
_	adj epi pl	immesurables
$
immettable	S*()
_	adj epi sg	immettable
_	adj epi pl	immettables
$
immeuble	S*()
_	adj epi sg	immeuble
_	adj epi pl	immeubles

_	nom fem sg	indestructibilité
_	nom fem pl	indestructibilités
$
indestructible	S*()
_	adj epi sg	indestructible
_	adj epi pl	indestructibles
$
indétachable	S*()
_	adj epi sg	indétachable
_	adj epi pl	indétachables
$
indétectable	S*()
_	adj epi sg	indétectable
_	adj epi pl	indétectables
$
indéterminable	S*()
_	adj epi sg	indéterminable
_	adj epi pl	indéterminables

_	nom fem sg	interdisciplinarité
_	nom fem pl	interdisciplinarités
$
interdit	S*()
_	nom mas sg	interdit
_	nom mas pl	interdits
$
interépidémique	S*()
_	adj epi sg	interépidémique
_	adj epi pl	interépidémiques
$
intéressante	F*()
_	adj fem sg	intéressante
_	adj fem pl	intéressantes
_	adj mas sg	intéressant
_	adj mas pl	intéressants
$
intéressée	F*()

_	adj mas pl	interreliés
$
interreligieuse	W*()
_	adj fem sg	interreligieuse
_	adj fem pl	interreligieuses
_	adj mas inv	interreligieux
$
interréticulaire	S*()
_	adj epi sg	interréticulaire
_	adj epi pl	interréticulaires
$
interro	S*()
_	nom fem sg	interro
_	nom fem pl	interros
$
interrogat	S*()
_	nom mas sg	interrogat
_	nom mas pl	interrogats

$
intrarachidienne	F*()
_	adj fem sg	intrarachidienne
_	adj fem pl	intrarachidiennes
_	adj mas sg	intrarachidien
_	adj mas pl	intrarachidiens
$
intrarégionale	W*()
_	adj fem sg	intrarégionale
_	adj fem pl	intrarégionales
_	adj mas sg	intrarégional
_	adj mas pl	intrarégionaux
$
intraspécifique	S*()
_	adj epi sg	intraspécifique
_	adj epi pl	intraspécifiques
$
intrathoracique	S*()
_	adj epi sg	intrathoracique
_	adj epi pl	intrathoraciques

_	nom adj fem pl	italo-néerlandaises
_	nom adj mas inv	italo-néerlandais
$
italophone	S*()
_	nom adj epi sg	italophone
_	nom adj epi pl	italophones
$
italo-turque	F*()
_	nom adj fem sg	italo-turque
_	nom adj fem pl	italo-turques
_	nom adj mas sg	italo-turc
_	nom adj mas pl	italo-turcs
$
item	S*()
_	nom mas sg	item
_	nom mas pl	items
$
itérabilité	S*()
_	nom fem sg	itérabilité
_	nom fem pl	itérabilités

_	nom fem sg	juridicisation
_	nom fem pl	juridicisations
$
juridicité	S.()
_	nom fem sg	juridicité
_	nom fem pl	juridicités
$
juridico-politique	S.()
_	adj epi sg	juridico-politique
_	adj epi pl	juridico-politiques
$
juridiction	S.()
_	nom fem sg	juridiction
_	nom fem pl	juridictions
$
juridictionnelle	F.()
_	adj fem sg	juridictionnelle
_	adj fem pl	juridictionnelles

_	nom adj mas sg	mélanésien
_	nom adj mas pl	mélanésiens
$
mélange	S.()
_	nom mas sg	mélange
_	nom mas pl	mélanges
$
mélangeable	S.()
_	adj epi sg	mélangeable
_	adj epi pl	mélangeables
$
mélangeage	S.()
_	nom mas sg	mélangeage
_	nom mas pl	mélangeages
$
mélangeante	F.()
_	adj fem sg	mélangeante
_	adj fem pl	mélangeantes

_	nom fem sg	microtransaction
_	nom fem pl	microtransactions
$
microtraumatisme	S.()
_	nom mas sg	microtraumatisme
_	nom mas pl	microtraumatismes
$
microtravail	X.()
_	nom mas sg	microtravail
_	nom mas pl	microtravaux
$
microtravailleuse	F.()
_	nom fem sg	microtravailleuse
_	nom fem pl	microtravailleuses
_	nom mas sg	microtravailleur
_	nom mas pl	microtravailleurs
$
microtubule	S.()
_	nom mas sg	microtubule
_	nom mas pl	microtubules
$
microvillosité	S.()
_	nom fem sg	microvillosité
_	nom fem pl	microvillosités

_	adj mas sg	multisectoriel
_	adj mas pl	multisectoriels
$
multiséculaire	S.()
_	adj epi sg	multiséculaire
_	adj epi pl	multiséculaires
$
multisensorielle	F.()
_	adj fem sg	multisensorielle
_	adj fem pl	multisensorielles
_	adj mas sg	multisensoriel
_	adj mas pl	multisensoriels
$
multisoc	S.()
_	adj epi sg	multisoc
_	adj epi pl	multisocs
$
multisommabilité	S.()
_	nom fem sg	multisommabilité
_	nom fem pl	multisommabilités

_	adj mas sg	pénicillé
_	adj mas pl	pénicillés
$
pénicillinase	S.()
_	nom fem sg	pénicillinase
_	nom fem pl	pénicillinases
$
pénicillinase	S.()
_	nom fem sg	pénicillinase
_	nom fem pl	pénicillinases
$
pénicilline	S.()
_	nom fem sg	pénicilline
_	nom fem pl	pénicillines
$
pénicillinorésistante	F.()
_	adj fem sg	pénicillinorésistante
_	adj fem pl	pénicillinorésistantes

_	nom mas sg	polyvinyle
_	nom mas pl	polyvinyles
$
polyvinylique	S.()
_	adj epi sg	polyvinylique
_	adj epi pl	polyvinyliques
$
polyvinylpyrrolidone	S.()
_	nom mas sg	polyvinylpyrrolidone
_	nom mas pl	polyvinylpyrrolidones
$
polyvitamine	S.()
_	nom fem sg	polyvitamine
_	nom fem pl	polyvitamines
$
polyxène	S.()
_	adj epi sg	polyxène
_	adj epi pl	polyxènes

_	nom fem sg	praxie
_	nom fem pl	praxies
$
praxinoscope	S.()
_	nom mas sg	praxinoscope
_	nom mas pl	praxinoscopes
$
praxique	S.()
_	adj epi sg	praxique
_	adj epi pl	praxiques
$
pré	S.()
_	nom mas sg	pré
_	nom mas pl	prés
$
préaccentuation	S.()
_	nom fem sg	préaccentuation
_	nom fem pl	préaccentuations

_	adj epi sg	projetable
_	adj epi pl	projetables
$
projeteur	S.()
_	nom mas sg	projeteur
_	nom mas pl	projeteurs
$
projo	S.()
_	nom epi sg	projo
_	nom epi pl	projos
$
prolactine	S.()
_	nom fem sg	prolactine
_	nom fem pl	prolactines
$
prolamine	S.()
_	nom fem sg	prolamine
_	nom fem pl	prolamines

_	nom fem sg	psychopolémologie
_	nom fem pl	psychopolémologies
$
psychopompe	S.()
_	adj epi sg	psychopompe
_	adj epi pl	psychopompes
$
psychoprophylaxie	S.()
_	nom fem sg	psychoprophylaxie
_	nom fem pl	psychoprophylaxies
$
psychorigide	S.()
_	nom adj epi sg	psychorigide
_	nom adj epi pl	psychorigides
$
psychorigidité	S.()
_	nom fem sg	psychorigidité
_	nom fem pl	psychorigidités

$
rebouteuse	F.()
_	nom fem sg	rebouteuse
_	nom fem pl	rebouteuses
_	nom mas sg	rebouteur
_	nom mas pl	rebouteurs
$
rebranchement	S.()
_	nom mas sg	rebranchement
_	nom mas pl	rebranchements
$
rebroussement	S.()
_	nom mas sg	rebroussement
_	nom mas pl	rebroussements
$
rebuffade	S.()
_	nom fem sg	rebuffade
_	nom fem pl	rebuffades

_	adj epi sg	régimentaire
_	adj epi pl	régimentaires
$
reginglard	S.()
_	nom mas sg	reginglard
_	nom mas pl	reginglards
$
régiolecte	S.()
_	nom mas sg	régiolecte
_	nom mas pl	régiolectes
$
région	S.()
_	nom fem sg	région
_	nom fem pl	régions
$
régionale	W.()
_	adj fem sg	régionale
_	adj fem pl	régionales

_	nom mas sg	rengrènement
_	nom mas pl	rengrènements
$
reniement	S.()
_	nom mas sg	reniement
_	nom mas pl	reniements
$
renieuse	F.()
_	nom fem sg	renieuse
_	nom fem pl	renieuses
_	nom mas sg	renieur
_	nom mas pl	renieurs
$
reniflage	S.()
_	nom mas sg	reniflage
_	nom mas pl	reniflages
$
reniflard	S.()
_	nom mas sg	reniflard
_	nom mas pl	reniflards

_	nom mas sg	scalpel
_	nom mas pl	scalpels
$
scampi	S.()
_	nom mas sg	scampi
_	nom mas pl	scampis
$
scan	S.()
_	nom mas sg	scan
_	nom mas pl	scans
$
scandale	S.()
_	nom mas sg	scandale
_	nom mas pl	scandales
$
scandaleuse	W.()
_	adj fem sg	scandaleuse
_	adj fem pl	scandaleuses

$
socio-professionnelle	F.()
_	nom adj fem sg	socio-professionnelle
_	nom adj fem pl	socio-professionnelles
_	nom adj mas sg	socio-professionnel
_	nom adj mas pl	socio-professionnels
$
socioreligieuse	W.()
_	adj fem sg	socioreligieuse
_	adj fem pl	socioreligieuses
_	adj mas inv	socioreligieux
$
socio-religieuse	W.()
_	adj fem sg	socio-religieuse
_	adj fem pl	socio-religieuses
_	adj mas inv	socio-religieux
$
sociotechnique	S.()
_	adj epi sg	sociotechnique
_	adj epi pl	sociotechniques
$
socio-technique	S.()
_	adj epi sg	socio-technique
_	adj epi pl	socio-techniques

_	adj epi sg	stylographique
_	adj epi pl	stylographiques
$
styloïde	S.()
_	adj epi sg	styloïde
_	adj epi pl	styloïdes
$
stylométrie	S.()
_	nom fem sg	stylométrie
_	nom fem pl	stylométries
$
stylomine	S.()
_	nom mas sg	stylomine
_	nom mas pl	stylomines
$
stylopode	S.()
_	nom mas sg	stylopode
_	nom mas pl	stylopodes

_	nom mas sg	surtitrage
_	nom mas pl	surtitrages
$
surtitre	S.()
_	nom mas sg	surtitre
_	nom mas pl	surtitres
$
surtoiture	S.()
_	nom fem sg	surtoiture
_	nom fem pl	surtoitures
$
surtonte	S.()
_	nom fem sg	surtonte
_	nom fem pl	surtontes
$
surtransposition	S.()
_	nom fem sg	surtransposition
_	nom fem pl	surtranspositions

_	adj epi sg	technoéconomique
_	adj epi pl	technoéconomiques
$
techno-économique	S.()
_	adj epi sg	techno-économique
_	adj epi pl	techno-économiques
$
technolecte	S.()
_	nom mas sg	technolecte
_	nom mas pl	technolectes
$
technologie	S.()
_	nom fem sg	technologie
_	nom fem pl	technologies
$
technologique	S.()
_	adj epi sg	technologique
_	adj epi pl	technologiques

_	nom mas sg	tétra
_	nom mas pl	tétras
$
tétraborate	S.()
_	nom mas sg	tétraborate
_	nom mas pl	tétraborates
$
tétrachloroaurique	S.()
_	adj epi sg	tétrachloroaurique
_	adj epi pl	tétrachloroauriques
$
tétrachlorure	S.()
_	nom mas sg	tétrachlorure
_	nom mas pl	tétrachlorures
$
tétracorde	S.()
_	nom mas sg	tétracorde
_	nom mas pl	tétracordes

_	adj epi sg	thermostable
_	adj epi pl	thermostables
$
thermostat	S.()
_	nom mas sg	thermostat
_	nom mas pl	thermostats
$
thermostatée	F.()
_	adj fem sg	thermostatée
_	adj fem pl	thermostatées
_	adj mas sg	thermostaté
_	adj mas pl	thermostatés
$
thermostatique	S.()
_	adj epi sg	thermostatique
_	adj epi pl	thermostatiques
$
thermothérapie	S.()
_	nom fem sg	thermothérapie
_	nom fem pl	thermothérapies

_	nom fem sg	topographie
_	nom fem pl	topographies
$
topographique	S.()
_	adj epi sg	topographique
_	adj epi pl	topographiques
$
topolecte	S.()
_	nom mas sg	topolecte
_	nom mas pl	topolectes
$
topologie	S.()
_	nom fem sg	topologie
_	nom fem pl	topologies
$
topologique	S.()
_	adj epi sg	topologique
_	adj epi pl	topologiques

_	nom mas sg	trimaran
_	nom mas pl	trimarans
$
trimard	S.()
_	nom mas sg	trimard
_	nom mas pl	trimards
$
trimardeuse	F.()
_	nom fem sg	trimardeuse
_	nom fem pl	trimardeuses
_	nom mas sg	trimardeur
_	nom mas pl	trimardeurs
$
trimbalage	S.()
_	nom mas sg	trimbalage
_	nom mas pl	trimbalages
$

_	nom adj epi sg	ultrariche
_	nom adj epi pl	ultrariches
$
ultra-riche	S*()
_	nom adj epi sg	ultra-riche
_	nom adj epi pl	ultra-riches
$
ultrarigoriste	S*()
_	nom adj epi sg	ultrarigoriste
_	nom adj epi pl	ultrarigoristes
$
ultraroyaliste	S*()
_	nom adj epi sg	ultraroyaliste
_	nom adj epi pl	ultraroyalistes
$
ultra-royaliste	S*()
_	nom adj epi sg	ultra-royaliste
_	nom adj epi pl	ultra-royalistes

saké sakés saquer
satire satires satyre satyres
satirique satiriques satyrique satyriques
saurez saurer
saut sauts sot sots sceau sceaux seau seaux
saute sautes sautent sotte sottes
savon savons
scan scans scanne scannes scannent
scier sied siéent seyait seyaient siée siéent
scieur scieurs sieur sieurs
script scripts scripte scriptes scriptent
sèche sèches sèchent seiche seiches
secours secourt secourent secoure secoures
secouerai secouerais secouerait secouraient secouerez secourais secourait secouraient secourez secourrai secourrais secourrait secourraient secourrez
secouerons secoueront secourons secourrons secourront

tendron tendrons tendront
terme termes thermes
test tests teste testes testent
tête têtes tète tètes tètent
tic tics tique tiques tiquent
tien tiens tient
tir tirs tire tires tirent
tiret tirets tirer
tirant tyran tyrans
toast toasts toaste toastes toastent
toc toque toques toquent
toi toit toits
tome tomme tomes tommes
ton tons thon thons tond tonds
tort torts tore tores taure taures tord tords tors

from distutils import dir_util
from distutils import file_util
from string import Template

import metagraphe
import metaphone2
import thes_build


# Dictionnaire des caractères pour le tri naturel.
# Ordre souhaitable, mais pose problème pour la recherche, car engendre des égalités de lemmes différents.
# Il faut donc travailler sur un dictionnaire trié *numériquement* et le sauvegarder selon le tri *naturel*
CHARMAP = str.maketrans({ 'à': 'a',  'À': 'A',  'â': 'a',  'Â': 'A',  'ä': 'a',  'Ä': 'A',  'å': 'a',  'Å': 'A',  'ā': 'a',  'Ā': 'A',
                          'ç': 'c',  'Ç': 'C',

        #file_util.copy_file('_templates/ooo/dictionaries.xcu.tpl.xml', spExt)
        copyTemplate('_templates/ooo', spExt, 'package-description.txt', dTplVars)
        for dVars in lDictVars:
            dicPath = spBuild + '/' + PREFIX_DICT_PATH + self.sVersion
            file_util.copy_file(dicPath+'/'+dVars['asciiName']+'.dic', spExt+'/dictionaries/'+dVars['asciiName']+'.dic')
            file_util.copy_file(dicPath+'/'+dVars['asciiName']+'.aff', spExt+'/dictionaries/'+dVars['asciiName']+'.aff')
        copyTemplate('orthographe', spExt+'/dictionaries', 'README_dict_fr.txt', dTplVars)




        # hyphenation
        file_util.copy_file('césures/hyph_fr.dic', spExt+'/dictionaries')
        file_util.copy_file('césures/hyph_fr.iso8859-1.dic', spExt+'/dictionaries')
        file_util.copy_file('césures/frhyph.tex', spExt+'/dictionaries')
        file_util.copy_file('césures/hyph-fr.tex', spExt+'/dictionaries')
        file_util.copy_file('césures/README_hyph_fr-3.0.txt', spExt+'/dictionaries')
        file_util.copy_file('césures/README_hyph_fr-2.9.txt', spExt+'/dictionaries')

        with open(sPathFile, 'w', encoding='utf-8', newline="\n") as hDst:
            for t in self.lLex:
                hDst.write(str(t)+"\n")
            for e in self.dFlexions.items():
                hDst.write("{} - {}\n".format(e[0], e[1]))


def createThesaurusPackage (spBuild, sVersion, spCopy=""):
    print(" * Création du thésaurus")
    spThesaurus = spBuild+"/thesaurus-v"+sVersion
    dir_util.mkpath(spThesaurus)
    thes_build.build("thesaurus/thes_fr.dat", "thesaurus/synsets_fr.dat", spThesaurus)
    file_util.copy_file('thesaurus/README_thes_fr.txt', spThesaurus)
    if spCopy:
        # copy in libreoffice extension package
        print("   Copie du thésaurus dans:", spCopy)
        file_util.copy_file(spThesaurus+'/thes_fr.dat', spCopy)
        file_util.copy_file(spThesaurus+'/thes_fr.idx', spCopy)
        file_util.copy_file(spThesaurus+'/README_thes_fr.txt', spCopy)


def main ():
    xParser = argparse.ArgumentParser()
    xParser.add_argument("-v", "--verdic", help="set dictionary version, i.e. 5.4", type=str, default="X.Y.z")
    xParser.add_argument("-m", "--mode", help="0: no tags,  1: Hunspell tags (default),  2: All tags", type=int, choices=[0, 1, 2], default=1)
    xParser.add_argument("-u", "--uncompress", help="do not use Hunspell compression", action="store_true")
    xParser.add_argument("-s", "--simplify", help="no virtual lemmas", action="store_true")

    oStatsLex.addLexFromFile('lexique/corpus_data/stats_google_ngram_1.txt', 'G', 'Google 1-grams')
    oStatsLex.addLexFromFile('lexique/corpus_data/stats_frwiki.txt', 'W', 'Wikipédia')
    oStatsLex.addLexFromFile('lexique/corpus_data/stats_frwikisource.txt', 'S', 'Wikisource')
    oStatsLex.addLexFromFile('lexique/corpus_data/stats_litterature.txt', 'L', 'Littérature')
    oStatsLex.write(spBuild+'/test_lex.txt')
    oFrenchDict.calculateStats(oStatsLex, spfStats)

    ### Écriture des paquets
    echo("Création des paquets...")

    spLexiconDestGL = "../../../lexicons"  if xArgs.grammalecte  else ""
    spLibreOfficeExtDestGL = "../oxt/Dictionnaires/dictionaries"  if xArgs.grammalecte  else ""
    spMozillaExtDestGL = ""  if xArgs.grammalecte  else "" # no more Hunspell dictionaries in Mozilla extensions for now
    spDataDestGL = "../data"  if xArgs.grammalecte  else ""

    ### dictionnaires
    if not xArgs.uncompress:
        oFrenchDict.defineAbreviatedTags(xArgs.mode, spfStats)
    oFrenchDict.createFiles(spBuild, [dTOUTESVAR, dCLASSIQUE, dREFORME1990], xArgs.mode, xArgs.simplify)
    oFrenchDict.createLexiconPackages(spBuild, xArgs.verdic, oStatsLex, spLexiconDestGL)
    oFrenchDict.createFileIfqForDB(spBuild)
    createThesaurusPackage(spBuild, "2.4", spLibreOfficeExtDestGL)
    oFrenchDict.createLibreOfficeExtension(spBuild, dMOZEXT, [dTOUTESVAR, dCLASSIQUE, dREFORME1990], spLibreOfficeExtDestGL)
    oFrenchDict.createMozillaExtensions(spBuild, dMOZEXT, [dTOUTESVAR, dCLASSIQUE, dREFORME1990], spMozillaExtDestGL)
    oFrenchDict.createDictConj(spBuild, spDataDestGL)
    oFrenchDict.createDictDecl(spBuild, spDataDestGL)



if __name__ == '__main__':
    main()

83829
×	po:sign	se:math	di:*	id:233045
Ω/U.||--	po:nom	is:mas	is:inv	lx:symb	se:élec	di:*	fq:0	id:201049
_	po:div	di:*	fq:0	id:231410
-	po:ponc	po:sign	se:@	di:*	id:233042
,	po:ponc	se:@	di:*	id:233025
;	po:ponc	se:@	di:*	id:233027
:	po:ponc	se:@	di:*	id:233028

1ʳᵉˢ/--	po:adj	is:fem	is:pl	lx:ord	se:@	di:*	fq:0	id:225848
1ᵉʳˢ/--	po:adj	is:mas	is:pl	lx:ord	se:@	di:*	fq:0	id:225846
1er/--	po:adj	is:mas	is:sg	lx:ord	se:@	di:*	fq:8	id:221488
1ers/--	po:adj	is:mas	is:pl	lx:ord	se:@	di:*	fq:5	id:221489
1re/--	po:adj	is:fem	is:sg	lx:ord	se:@	di:*	fq:6	id:221490
1res/--	po:adj	is:fem	is:pl	lx:ord	se:@	di:*	fq:6	id:221491
2ᵉ/--	po:adj	is:epi	is:sg	lx:ord	se:@	di:*	fq:1	id:225849
2ᵉˢ/--	po:adj	is:epi	is:pl	lx:ord	se:@	di:*	fq:0	id:225850
2CV	po:npr	is:fem	is:inv	lx:sig	se:prod	se:auto	di:X	fq:4	id:227087
2d/--	po:adj	is:mas	is:sg	lx:ord	se:@	di:*	id:233147
2D	po:adj	is:epi	is:inv	lx:sig	di:*	fq:5	id:220895
2D	po:nom	is:fem	is:inv	lx:sig	di:*	fq:5	id:215499
2de/--	po:adj	is:fem	is:sg	lx:ord	se:@	di:*	id:233149
2des/--	po:adj	is:fem	is:pl	lx:ord	se:@	di:*	id:233150
2ds/--	po:adj	is:mas	is:pl	lx:ord	se:@	di:*	id:233148
2e/--	po:adj	is:epi	is:sg	lx:ord	se:@	di:*	fq:7	id:221492
2es	po:adj	is:epi	is:pl	lx:ord	se:@	di:*	fq:4	id:223071
3ᵉ/--	po:adj	is:epi	is:sg	lx:ord	se:@	di:*	fq:1	id:225851
3ᵉˢ/--	po:adj	is:epi	is:pl	lx:ord	se:@	di:*	fq:0	id:225852
3D	po:nom	is:fem	is:inv	lx:sig	di:*	fq:5	id:215500
3D	po:adj	is:epi	is:inv	lx:sig	di:*	fq:5	id:220894
3e/--	po:adj	is:epi	is:sg	lx:ord	se:@	di:*	fq:7	id:221493
3es	po:adj	is:epi	is:pl	lx:ord	se:@	di:*	fq:5	id:223072
3RB	po:nom	is:mas	is:inv	lx:sig	di:X	fq:0	id:231961
4ᵉ/--	po:adj	is:epi	is:sg	lx:ord	se:@	di:*	fq:0	id:225853
4ᵉˢ/--	po:adj	is:epi	is:pl	lx:ord	se:@	di:*	fq:0	id:225854
4e/--	po:adj	is:epi	is:sg	lx:ord	se:@	di:*	fq:7	id:221494
4es	po:adj	is:epi	is:pl	lx:ord	se:@	di:*	fq:5	id:223073
5ᵉ/--	po:adj	is:epi	is:sg	lx:ord	se:@	di:*	fq:0	id:225855
5ᵉˢ/--	po:adj	is:epi	is:pl	lx:ord	se:@	di:*	fq:0	id:225856
5e/--	po:adj	is:epi	is:sg	lx:ord	se:@	di:*	fq:7	id:221495
5es	po:adj	is:epi	is:pl	lx:ord	se:@	di:*	fq:4	id:223074
6ᵉ/--	po:adj	is:epi	is:sg	lx:ord	se:@	di:*	fq:0	id:225857
6ᵉˢ/--	po:adj	is:epi	is:pl	lx:ord	se:@	di:*	fq:0	id:225858
6e/--	po:adj	is:epi	is:sg	lx:ord	se:@	di:*	fq:6	id:221496
6es	po:adj	is:epi	is:pl	lx:ord	se:@	di:*	fq:5	id:223075
7ᵉ/--	po:adj	is:epi	is:sg	lx:ord	se:@	di:*	fq:0	id:225859
7ᵉˢ/--	po:adj	is:epi	is:pl	lx:ord	se:@	di:*	fq:0	id:225860
7e/--	po:adj	is:epi	is:sg	lx:ord	se:@	di:*	fq:6	id:221497
7es	po:adj	is:epi	is:pl	lx:ord	se:@	di:*	fq:4	id:223076
8ᵉ/--	po:adj	is:epi	is:sg	lx:ord	se:@	di:*	fq:0	id:225861
8ᵉˢ/--	po:adj	is:epi	is:pl	lx:ord	se:@	di:*	fq:0	id:225862
8e/--	po:adj	is:epi	is:sg	lx:ord	se:@	di:*	fq:6	id:221498
8es	po:adj	is:epi	is:pl	lx:ord	se:@	di:*	fq:4	id:223077
9ᵉ/--	po:adj	is:epi	is:sg	lx:ord	se:@	di:*	fq:0	id:225863
9ᵉˢ/--	po:adj	is:epi	is:pl	lx:ord	se:@	di:*	fq:0	id:225864
9e/--	po:adj	is:epi	is:sg	lx:ord	se:@	di:*	fq:6	id:221499
9es	po:adj	is:epi	is:pl	lx:ord	se:@	di:*	fq:4	id:223078
a	po:nom	is:mas	is:inv	se:@	di:*	fq:9	id:125890
a/||--	po:nom	is:mas	is:inv	lx:symb	di:*	fq:9	id:201106
A/U.||--	po:nom	is:mas	is:inv	lx:symb	di:*	fq:9	id:201003
à/L'D'Q'Q*Qj	po:mg	po:prep	po:prepv	se:@	di:*	fq:9	id:180587
Å/||--	po:nom	is:mas	is:inv	lx:symb	di:*	fq:4	id:201001

abattée/S*()	po:nom	is:fem	di:*	fq:4	id:125942
abattement/S*()	po:nom	is:mas	di:*	fq:6	id:125937
abatteuse/F*()	po:nom	po:adj	di:*	fq:5	id:125938
abattis/L'D'Q'	po:nom	is:mas	is:inv	di:*	fq:5	id:214969
abattoir/S*()	po:nom	is:mas	di:*	fq:6	id:125939
abattre/uA()	po:v3_it_q__a	et:lat	di:*	fq:7	id:125940
abatture/S*()	po:nom	is:fem	di:*	fq:3	id:202022

abat-vent/L'D'Q'	po:nom	is:mas	is:inv	di:M	fq:2	id:125932
abat-vent/S*()	po:nom	is:mas	di:R	fq:1	id:125931
abat-voix/L'D'Q'	po:nom	is:mas	is:inv	di:*	fq:3	id:125933
ABB/L'D'Q'	po:npr	is:epi	is:inv	lx:sig	se:soc	se:indus	di:*	fq:5	id:229148
abbasside/S*()	po:nom	po:adj	is:epi	di:*	fq:5	id:210357
abbatiale/S*()	po:nom	is:fem	di:*	fq:5	id:125945
abbatiale/W*()	po:adj	di:*	fq:5	id:125944
abbatiat/S*()	po:nom	is:mas	di:*	fq:5	id:206353
abbaye/S*()	po:nom	is:fem	di:*	fq:7	id:125946

acquit-à-caution/L'D'Q'	po:nom	is:mas	is:sg	se:droit	di:*	fq:2	id:216250
acquits-à-caution/L'D'Q'	po:nom	is:mas	is:pl	se:droit	di:*	fq:2	id:216251
acquittable/S*()	po:adj	is:epi	di:*	fq:4	id:126509
acquittée/F*()	po:nom	di:*	fq:6	id:126512
acquittement/S*()	po:nom	is:mas	di:*	fq:6	id:126510
acquitter/a4p+()	po:v1__t_q_zz	di:*	fq:7	id:126511
acra/S*()	po:nom	is:mas	di:*	fq:4	id:203147
acratopège/S*()	po:adj	is:epi	lx:vx	et:grec	di:*	id:233162
acre/S*()	po:nom	is:fem	se:agri	et:angl	di:*	fq:6	id:126517
âcre/S*()	po:adj	is:epi	di:*	fq:6	id:180595
âcrement/D'Q'	po:adv	di:*	fq:3	id:182459
âcreté/S*()	po:nom	is:fem	di:*	fq:5	id:180596
acridien/S*()	po:nom	is:mas	di:*	fq:4	id:202088
acridienne/F*()	po:adj	di:*	fq:5	id:202089
acridine/S*()	po:nom	is:fem	di:*	fq:4	id:203094

afropéenne/F*()	po:nom	po:adj	se:gent	di:*	fq:1	id:232587
afrophobie/S*()	po:nom	is:fem	se:polit	di:*	id:232911
afrorock/S*()	po:nom	is:mas	se:mus	et:angl	di:*	fq:0	id:225001
after/S*()	po:nom	is:epi	et:angl	di:*	id:233013
aftershave/S*()	po:nom	is:mas	et:angl	di:*	fq:3	id:211722
after-shave/L'D'Q'	po:nom	is:mas	is:inv	et:angl	di:C	fq:1	id:211721
Aful/L'D'Q'	po:nom	is:fem	is:inv	lx:sig	di:X	fq:1	id:227480

AG/L'D'Q'	po:nom	is:fem	lx:sig	di:*	fq:0	id:232235
AG	po:nom	is:fem	is:inv	lx:sig	di:*	fq:6	id:232641
aga/S*()	po:nom	is:mas	di:R	fq:5	id:126990
agaçante/F*()	po:adj	di:*	fq:5	id:127011
agace/S*()	po:nom	is:fem	lx:vx	lx:rég	lx:québ	di:*	fq:5	id:215625
agacement/S*()	po:nom	is:mas	di:*	fq:5	id:126991
agace-pissette/S*()	po:nom	is:fem	lx:québ	lx:péj	di:*	fq:1	id:219947
agacer/a4p+()	po:v1__t_q_zz	di:*	fq:6	id:126992
agacerie/S*()	po:nom	is:fem	di:*	fq:5	id:126993

anarchisante/F*()	po:adj	se:polit	di:*	fq:5	id:128024
anarchisme/S*()	po:nom	is:mas	se:polit	di:*	fq:6	id:128025
anarchiste/S*()	po:nom	po:adj	is:epi	se:polit	di:*	fq:6	id:128026
anarchocapitalisme/S*()	po:nom	is:mas	se:polit	di:R	fq:2	id:216030
anarcho-capitalisme/S*()	po:nom	is:mas	se:polit	di:M	fq:2	id:216029
anarchocapitaliste/S*()	po:nom	po:adj	is:epi	se:polit	di:R	fq:0	id:225738
anarcho-capitaliste/S*()	po:nom	po:adj	is:epi	se:polit	di:M	fq:2	id:225737
anarchocommunisme/S*()	po:nom	is:mas	se:polit	di:R	id:233107
anarcho-communisme/S*()	po:nom	is:mas	se:polit	di:M	id:233106
anarcho-primitivisme/S*()	po:nom	is:mas	se:philo	se:polit	di:*	fq:2	id:229446
anarchosyndicalisme/S*()	po:nom	is:mas	se:polit	di:R	fq:4	id:128029
anarcho-syndicalisme/S*()	po:nom	is:mas	se:polit	di:M	fq:3	id:128027
anarchosyndicaliste/S*()	po:nom	is:epi	se:polit	di:R	fq:4	id:128030
anarcho-syndicaliste/S*()	po:nom	is:epi	se:polit	di:M	fq:3	id:128028
anarthrie/S*()	po:nom	is:fem	di:*	fq:4	id:128031
anasarque/S*()	po:nom	is:fem	di:*	fq:5	id:128032

Android/D'Q'--	po:npr	is:mas	is:inv	se:prod	se:info	di:*	fq:4	id:229527
androïde/S*()	po:nom	is:epi	se:hitech	di:*	fq:4	id:128085
androlâtre/S*()	po:nom	is:epi	lx:rare	se:reli	di:*	fq:0	id:128081
androlâtrie/S*()	po:nom	is:fem	lx:rare	se:reli	di:*	fq:1	id:128082
andrologie/S*()	po:nom	is:fem	di:*	fq:3	id:128079
andrologique/S*()	po:adj	is:epi	di:*	fq:2	id:210227
andrologue/S*()	po:nom	is:epi	di:*	fq:3	id:128080
Andromaque/L'D'Q'	po:prn	is:fem	is:inv	se:myth	et:grec	di:*	id:233142
andromède/S*()	po:nom	is:fem	di:*	fq:3	id:213202
Andromède/L'D'Q'	po:prn	is:fem	is:inv	di:*	fq:5	id:123312
andropause/S*()	po:nom	is:fem	di:*	fq:4	id:128083
androphobie/S*()	po:nom	is:fem	di:*	fq:3	id:220564
androsace/S*()	po:nom	is:mas	di:*	fq:4	id:212682
androstérone/S*()	po:nom	is:fem	lx:rare	di:*	fq:4	id:128084
Andrzej/L'D'Q'	po:prn	is:mas	is:inv	di:*	fq:5	id:222815

antioxydante/F*()	po:adj	di:*	fq:4	id:210691
anti-oxydante/F*()	po:adj	se:chim	di:*	fq:3	id:231730
antipaludéenne/F*()	po:adj	di:*	fq:4	id:128423
antipaludique/S*()	po:adj	is:epi	di:*	fq:5	id:128422
antipanique/L'D'Q'	po:adj	is:epi	is:inv	di:*	fq:3	id:210288
antipape/S*()	po:nom	is:mas	di:*	fq:5	id:128424
antiparallèle/S*()	po:adj	is:epi	di:*	fq:4	id:128425

antiparasitage/S*()	po:nom	is:mas	lx:néo	se:élec	di:*	fq:3	id:221631
antiparasitage/S*()	po:adj	is:epi	se:techni	di:*	fq:3	id:228375
antiparasitaire/S*()	po:nom	is:mas	di:*	fq:5	id:213461
antiparasitaire/S*()	po:adj	is:epi	di:*	fq:5	id:213416
antiparasite/S*()	po:nom	is:mas	se:électro	di:*	fq:4	id:128426
antiparasite/S*()	po:adj	is:epi	se:électro	di:*	fq:4	id:220318
antiparlementaire/S*()	po:adj	is:epi	di:*	fq:5	id:128427
antiparlementarisme/S*()	po:nom	is:mas	di:*	fq:5	id:128428
antiparticule/S*()	po:nom	is:fem	se:phys	di:*	fq:4	id:128429

antitrust/L'D'Q'	po:adj	is:epi	is:inv	lx:néo	et:angl	di:M	fq:5	id:209586
antitrypsine/S*()	po:nom	is:fem	se:bioch	se:pharma	di:*	fq:4	id:221073
antituberculeuse/W*()	po:adj	di:*	fq:5	id:128485
antitumorale/W*()	po:adj	se:méd	di:*	fq:4	id:225367
antitussive/F*()	po:adj	di:*	fq:4	id:182557
anti-UV/L'D'Q'	po:adj	is:epi	is:inv	di:*	fq:2	id:224025
antivaccin/S=	po:adj	is:epi	is:inv	se:polit	se:méd	di:*	fq:1	id:232313
antivaccination/S*()	po:adj	is:epi	se:polit	se:méd	di:*	id:233140
antivariolique/S*()	po:adj	is:epi	di:*	fq:5	id:128487
antivénéneuse/W*()	po:adj	se:pharma	di:*	fq:3	id:220218
antivénérienne/F*()	po:adj	di:*	fq:5	id:182558
antivenimeuse/W*()	po:adj	di:*	fq:4	id:128488
antivibratile/S*()	po:adj	is:epi	se:techni	di:*	fq:3	id:223371
anti-VIH/L'D'Q'	po:adj	is:epi	is:inv	se:méd	di:*	fq:2	id:224024
antiviral/X*()	po:nom	is:mas	di:*	fq:4	id:209181

appui/S*()	po:nom	is:mas	di:*	fq:7	id:128810
appui-bras/L'D'Q'	po:nom	is:mas	is:sg	lx:alt	lx:dic	di:A	fq:1	id:128811
appuie-bras/L'D'Q'	po:nom	is:mas	is:inv	di:*	fq:1	id:128814
appuie-livre/S*()	po:nom	is:mas	di:R	fq:0	id:128815
appuie-livres/L'D'Q'	po:nom	is:mas	is:inv	di:M	fq:0	id:128816
appuie-main/L'D'Q'	po:nom	is:mas	is:inv	di:M	fq:2	id:128818
appuie-main/S*()	po:nom	is:mas	di:R	fq:2	id:128817

appuie-nuque/L'D'Q'	po:nom	is:mas	is:inv	di:M	fq:1	id:128820
appuie-nuque/S*()	po:nom	is:mas	di:R	fq:0	id:128819
appuie-tête/S*()	po:nom	is:mas	di:R	fq:2	id:128821
appuie-tête/L'D'Q'	po:nom	is:mas	is:inv	di:M	fq:2	id:128822
appui-main/L'D'Q'	po:nom	is:mas	is:sg	lx:alt	di:A	fq:2	id:128812
appuis-bras/D'Q'	po:nom	is:mas	is:pl	lx:alt	lx:dic	di:A	fq:1	id:128823
appuis-main/D'Q'	po:nom	is:mas	is:pl	lx:alt	di:A	fq:1	id:128824
appuis-tête/D'Q'	po:nom	is:mas	is:pl	lx:alt	lx:dic	di:A	fq:2	id:128825
appui-tête/L'D'Q'	po:nom	is:mas	is:sg	lx:alt	lx:dic	di:A	fq:2	id:128813
appuyer/a4p+()	po:v1_itnq__a	di:*	fq:8	id:128826
apragmatisme/S*()	po:nom	is:mas	se:psycho	se:méd	di:*	fq:4	id:128836
apraxie/S*()	po:nom	is:fem	di:*	fq:5	id:128837
apraxique/S*()	po:nom	po:adj	is:epi	di:*	fq:4	id:210327
âpre/S*()	po:adj	is:epi	di:*	fq:6	id:180607
âprement	po:adv	di:*	fq:6	id:180608
après/L'D'Q'Qj	po:mg	po:prep	se:@	di:*	fq:9	id:128842
après-demain/D'Q'	po:adv	di:*	fq:4	id:128843
après-diner/S*()	po:nom	is:mas	di:R	fq:2	id:128844

après-dîner/L'D'Q'	po:nom	is:mas	is:inv	di:C	fq:3	id:128846
après-dîner/S*()	po:nom	is:mas	di:M	fq:2	id:209206
après-guerre/S*()	po:nom	is:epi	di:*	fq:4	id:128847
après-midi/L'D'Q'	po:nom	is:epi	is:inv	di:M	fq:4	id:128849
après-midi/S*()	po:nom	is:epi	di:R	fq:3	id:128848
après-rasage/L'D'Q'	po:nom	is:mas	is:inv	di:C	fq:1	id:128851
après-rasage/S*()	po:nom	is:mas	di:*	fq:1	id:128850
après-rasage/L'D'Q'	po:adj	is:epi	is:inv	di:M	fq:1	id:210057
après-rasage/S*()	po:adj	is:epi	di:R	fq:1	id:210058

autotomiser/a3p+()	po:v1____p_e_	se:zool	di:*	fq:4	id:130113
autotour/S*()	po:nom	is:mas	di:*	fq:1	id:210031
autotractée/F*()	po:adj	se:techni	di:*	fq:4	id:218075
autotransformateur/S*()	po:nom	is:mas	se:élec	di:*	fq:4	id:220124
autotransfusion/S*()	po:nom	is:fem	se:méd	di:*	fq:4	id:217675
autotrophe/S*()	po:adj	is:epi	di:*	fq:5	id:130114
autotrophie/S*()	po:nom	is:fem	di:*	fq:4	id:201430

autour/S*()	po:nom	is:mas	lx:fxa	se:zool	et:lat	di:*	fq:5	id:130116
autour/D'Q'	po:loc.prep	po:adv	di:*	fq:7	id:130117
autovaccin/S*()	po:nom	is:mas	di:*	fq:4	id:130118
auto-vaccin/S*()	po:nom	is:mas	di:C	fq:1	id:129980
autovaccination/S*()	po:nom	is:fem	di:*	fq:3	id:130119
autre/S*()	po:nom	po:adj	is:epi	se:@	di:*	fq:9	id:130126
autre	po:mg	po:proind	se:@	di:*	fq:8	id:217628
autrefois/D'Q'	po:adv	se:temps	di:*	fq:7	id:130127
autrement/D'Q'	po:adv	di:*	fq:7	id:130128

avant-gardisme/S*()	po:nom	is:mas	di:*	fq:2	id:130172
avant-gardiste/S*()	po:nom	po:adj	is:epi	di:*	fq:4	id:130173
avant-gout/S*()	po:nom	is:mas	di:R	fq:1	id:130174
avant-goût/S*()	po:nom	is:mas	di:M	fq:3	id:130175
avant-guerre/S*()	po:nom	is:epi	di:*	fq:4	id:130176
avant-hier/D'Q'	po:adv	di:*	fq:4	id:130177
avant-main/S*()	po:nom	is:fem	di:*	fq:3	id:130178

avant-midi/L'D'Q'	po:nom	is:epi	is:inv	di:M	fq:2	id:130180
avant-midi/S*()	po:nom	is:epi	di:R	fq:1	id:130179
avant-mont/S*()	po:nom	is:mas	di:*	fq:2	id:215157
avant-pays/L'D'Q'	po:nom	is:mas	is:inv	di:*	fq:3	id:215336
avant-plan/S*()	po:nom	is:mas	lx:belg	di:*	fq:3	id:215158
avant-port/S*()	po:nom	is:mas	di:*	fq:3	id:130181
avant-poste/S*()	po:nom	is:mas	di:*	fq:4	id:130182
avant-première/S*()	po:nom	is:fem	di:*	fq:4	id:130183
avant-projet/S*()	po:nom	is:mas	di:*	fq:3	id:130184

avouée/F*()	po:nom	di:*	fq:6	id:130295
avouer/a4p+()	po:v1__t_q_zz	di:*	fq:7	id:130294
avoyer/S*()	po:nom	is:mas	lx:helv	se:droit	di:*	fq:5	id:224556
avoyer/a2p+()	po:v1__t___zz	di:*	fq:7	id:130296
avr	po:nom	is:mas	is:inv	lx:abty	di:*	fq:6	id:203617
avril/S*()	po:nom	is:mas	di:*	fq:8	id:130297
Avrillé/L'D'Q'	po:npr	is:epi	is:inv	se:cité	di:*	fq:4	id:229764
avulsion/S*()	po:nom	is:fem	se:sc	di:*	fq:5	id:130298
avunculaire/S*()	po:adj	is:epi	di:M	fq:4	id:130299
avunculat/S*()	po:nom	is:mas	lx:rare	di:M	fq:4	id:211426
awalé/S*()	po:nom	is:mas	se:jeu	et:étr	di:*	fq:3	id:220767
AXA/L'D'Q'	po:npr	is:epi	is:inv	se:soc	di:*	fq:4	id:222322
axe/S*()	po:nom	is:mas	di:*	fq:7	id:130303
Axel/L'D'Q'	po:prn	is:mas	is:inv	di:*	fq:5	id:123440
Axelle/L'D'Q'	po:prn	is:fem	is:inv	di:*	fq:4	id:123441

barrement/S.()	po:nom	is:mas	di:*	fq:4	id:130859
barrémienne/F.()	po:adj	se:géol	di:*	fq:4	id:225750
barrer/a0p+()	po:v1_it_q_zz	di:*	fq:6	id:130860
barrette/S.()	po:nom	is:fem	di:*	fq:5	id:130861
barreuse/F.()	po:nom	di:*	fq:5	id:130862
barricade/S.()	po:nom	is:fem	di:*	fq:6	id:130863
barricader/a0p+()	po:v1__t_q_zz	di:*	fq:6	id:130864
barriérage/S.()	po:nom	is:mas	se:sécu	di:*	id:233164
barrière/S.()	po:nom	is:fem	di:*	fq:7	id:130869
barriérer/c0p+()	po:v1_it____a	se:sécu	di:*	id:233165
barrio/S.()	po:nom	is:mas	se:urba	et:port	et:ara	di:*	fq:5	id:232787
barrique/S.()	po:nom	is:fem	et:occ	di:*	fq:6	id:130866
barrir/f0p.()	po:v2_i____zz	di:*	fq:5	id:130867
barrissement/S.()	po:nom	is:mas	di:*	fq:4	id:130868
barrot/S.()	po:nom	is:mas	di:*	fq:5	id:130870
Barry	po:prn	is:mas	is:inv	di:*	fq:6	id:221224
Barsac	po:npr	is:epi	is:inv	se:cité	di:X	fq:5	id:231977

bêtabloquante/F.()	po:adj	se:méd	di:*	fq:0	id:213410
bêta-bloquante/F.()	po:adj	se:méd	di:C	fq:1	id:214215
bêtacarotène/S.()	po:nom	is:mas	se:bioch	di:*	fq:3	id:213834
bêta-carotène/S.()	po:nom	is:mas	se:bioch	di:C	fq:2	id:213929
bétail/S.()	po:nom	is:mas	se:élev	et:lat	di:*	fq:7	id:133204
bétaillère/S.()	po:nom	is:fem	se:élev	di:*	fq:4	id:133205
bétaïne/S.()	po:nom	is:fem	se:bioch	di:*	fq:4	id:218276
bêtalactamase/S.()	po:nom	is:fem	se:bact	di:*	id:233098
bêta-lactamase/S.()	po:nom	is:fem	se:bact	di:C	id:233100
bêtalactamine/S.()	po:nom	is:fem	se:méd	se:pharma	di:*	fq:4	id:223231
bêta-lactamine/S.()	po:nom	is:fem	se:méd	se:pharma	di:C	fq:3	id:223232
bêtalectrice/F.()	po:nom	se:litt	di:*	id:232934
bêta-lectrice/F.()	po:nom	se:litt	di:C	id:232935
bêtasse/S.()	po:nom	po:adj	is:fem	lx:fam	di:*	fq:4	id:133230
bêtastimulante/F.()	po:adj	di:*	id:232993
bêtatest/S.()	po:nom	is:mas	lx:néo	se:info	di:R	fq:1	id:219949

bitord/S.()	po:nom	is:mas	di:*	fq:4	id:131664
bitos	po:nom	is:mas	is:inv	lx:fam	di:*	fq:3	id:131665
bittacus	po:nom	is:mas	is:inv	lx:rare	di:*	fq:0	id:206644
bitte/S.()	po:nom	is:fem	se:marin	di:*	fq:5	id:131666
bitter/a0p+()	po:v1__t___zz	di:*	fq:5	id:131667
bitture/S.()	po:nom	is:fem	di:*	fq:3	id:131668
bitturer/a0p+()	po:v1____p_e_	di:*	fq:0	id:131669

bitube/S.()	po:adj	is:epi	di:X	fq:3	id:228097
bitube/S.()	po:nom	is:mas	di:X	fq:3	id:228098
bitubulaire/S.()	po:adj	is:epi	di:X	fq:0	id:227672
bitumage/S.()	po:nom	is:mas	di:*	fq:5	id:131670
bitume/S.()	po:nom	is:mas	di:*	fq:6	id:131671
bitumer/a0p+()	po:v1__t___zz	di:*	fq:5	id:131672
bitumeuse/W.()	po:adj	di:*	fq:5	id:131673
bituminer/a0p+()	po:v1__t___zz	di:*	fq:4	id:131674
bitumineuse/W.()	po:adj	di:*	fq:6	id:131675

blasonner/a0p+()	po:v1__t___zz	di:*	fq:5	id:131751
blasonneuse/F.()	po:nom	di:*	fq:3	id:206304
blasphématoire/S.()	po:adj	is:epi	di:*	fq:5	id:131754
blasphématrice/F.()	po:nom	po:adj	di:*	fq:5	id:131755
blasphème/S.()	po:nom	is:mas	di:*	fq:6	id:131753
blasphémer/c0p+()	po:v1_it___zz	di:*	fq:6	id:131756
blastème/S.()	po:nom	is:mas	di:*	fq:5	id:204252

blaster/a0p+()	po:v1_it____a	lx:fam	di:X	fq:4	id:228123
blaster/S.()	po:nom	is:mas	se:sf	di:X	fq:3	id:228124
blastocèle/S.()	po:nom	is:mas	di:*	fq:4	id:131758
blastocyste/S.()	po:nom	is:mas	di:*	fq:4	id:131757
blastoderme/S.()	po:nom	is:mas	di:*	fq:5	id:131759
blastodermique/S.()	po:adj	is:epi	se:anat	di:*	fq:5	id:231514
blastogenèse/S.()	po:nom	is:fem	di:*	fq:4	id:131760
blastoïde/S.()	po:nom	is:mas	se:zool	di:*	fq:3	id:216583
blastomère/S.()	po:nom	is:mas	se:bio	et:grec	di:*	fq:5	id:220553

Brad	po:prn	is:mas	is:inv	di:*	fq:5	id:221774
bradage/S.()	po:nom	is:mas	di:*	fq:4	id:132476
bradel/S.()	po:nom	is:mas	di:*	fq:3	id:132477
brader/a0p+()	po:v1__t___zz	di:*	fq:5	id:132478
braderie/S.()	po:nom	is:fem	di:*	fq:4	id:132479
bradeuse/F.()	po:nom	po:adj	di:*	fq:4	id:132480
Bradford	po:npr	is:epi	is:inv	se:cité	di:*	fq:5	id:214297

Bradley	po:prn	is:mas	is:inv	di:*	fq:5	id:221773
Bradley	po:patr	is:epi	is:inv	di:X	fq:5	id:227124
bradycardie/S.()	po:nom	is:fem	di:*	fq:5	id:132481
bradykinésie/S.()	po:nom	is:fem	se:méd	di:*	fq:3	id:223004
bradykinine/S.()	po:nom	is:fem	se:bio	se:bioch	di:*	fq:4	id:221170
bradype/S.()	po:nom	is:mas	lx:rare	di:*	fq:3	id:132482
bradypnée/S.()	po:nom	is:fem	se:méd	di:*	fq:4	id:220024
bradypsychie/S.()	po:nom	is:fem	se:méd	di:*	fq:4	id:220351
Brafman	po:patr	is:epi	is:inv	di:X	fq:3	id:227280

cache-misère/S.()	po:nom	is:mas	di:R	fq:1	id:133323
cache-misère	po:nom	is:mas	is:inv	di:M	fq:1	id:133324
cache-museau/X.()	po:nom	is:mas	di:R	fq:1	id:133325
cache-museau	po:nom	is:mas	is:inv	di:M	fq:0	id:133326
cache-nez	po:nom	is:mas	is:inv	di:*	fq:3	id:133327
cache-pot	po:nom	is:mas	is:inv	di:M	fq:2	id:133329
cache-pot/S.()	po:nom	is:mas	di:R	fq:2	id:133328

cache-poussière	po:nom	is:mas	is:inv	di:M	fq:2	id:133331
cache-poussière/S.()	po:nom	is:mas	di:R	fq:1	id:133330
cache-prise/S.()	po:nom	is:mas	di:R	fq:0	id:133332
cache-prise	po:nom	is:mas	is:inv	di:M	fq:1	id:133333
cacher/a0p+()	po:v1__t_q_zz	di:*	fq:7	id:133343
cache-radiateur/S.()	po:nom	is:mas	di:R	fq:1	id:133334
cache-radiateur	po:nom	is:mas	is:inv	di:M	fq:0	id:133335
cachère/S.()	po:adj	is:epi	di:*	fq:4	id:133358
cacherout/S.()	po:nom	is:fem	se:jud	et:héb	di:*	fq:4	id:226553

cadre/S.()	po:nom	is:epi	di:*	fq:7	id:133404
cadrer/a0p+()	po:v1_it___zz	di:*	fq:6	id:133405
cadreuse/F.()	po:nom	di:*	fq:4	id:133406
cadriciel/S.()	po:nom	is:mas	se:info	di:*	fq:2	id:227698
caducée/S.()	po:nom	is:mas	di:*	fq:5	id:133409
caducifoliée/F.()	po:adj	se:bot	di:*	fq:4	id:228493
caducité/S.()	po:nom	is:fem	di:*	fq:6	id:133408

caduque/F.()	po:adj	et:lat	di:*	fq:6	id:133410
caduque/S.()	po:nom	is:fem	et:lat	di:*	fq:6	id:231654
cæcale/W.()	po:adj	di:*	fq:2	id:139153
cæcotrophie/S.()	po:nom	is:fem	se:bio	di:*	fq:2	id:228255
cæcum/S.()	po:nom	is:mas	di:*	fq:3	id:139154
Caelius	po:nom	is:mas	is:inv	se:cité	di:*	fq:5	id:214571
Caen	po:npr	is:epi	is:inv	se:cité	di:*	fq:7	id:123663
caennaise/F.()	po:nom	po:adj	se:gent	di:*	fq:5	id:231347
cænogenèse/S.()	po:nom	is:fem	di:*	fq:1	id:139155

carmeline/S.()	po:adj	is:epi	di:*	fq:2	id:134152
carmélitaine/F.()	po:adj	di:*	fq:4	id:209383
carmélite/S.()	po:adj	is:epi	di:*	fq:5	id:134158
carmélite/S.()	po:nom	is:fem	di:*	fq:5	id:211869
Carmella	po:prn	is:fem	is:inv	di:*	fq:3	id:223948
Carmen	po:prn	is:fem	is:inv	di:*	fq:6	id:201715
carmer/a0p+()	po:v1__t___zz	di:*	fq:3	id:134153

carmin/S.()	po:nom	is:mas	di:*	fq:4	id:134154
carmin	po:adj	is:epi	is:inv	lx:col	di:*	fq:5	id:214504
carminative/F.()	po:adj	di:*	fq:4	id:134155
carminer/a0p+()	po:v1__t___zz	di:*	fq:5	id:134156
carnage/S.()	po:nom	is:mas	di:*	fq:6	id:134159
carnassière/F.()	po:nom	po:adj	di:*	fq:6	id:134160
carnation/S.()	po:nom	is:fem	di:*	fq:5	id:134161
carnaval/S.()	po:nom	is:mas	di:*	fq:6	id:134162
carnavalesque/S.()	po:adj	is:epi	di:*	fq:5	id:134163

Cassandre	po:prn	is:fem	is:inv	di:*	fq:6	id:123706
cassante/F.()	po:adj	di:*	fq:6	id:134309
cassate/S.()	po:nom	is:fem	et:ita	di:*	fq:3	id:134310
cassation/S.()	po:nom	is:fem	di:*	fq:7	id:134311
cassave/S.()	po:nom	is:fem	se:cuis	di:*	fq:5	id:217266
casse/S.()	po:nom	is:epi	di:*	fq:6	id:134312
casseau/X.()	po:nom	is:mas	di:*	fq:4	id:134341

casse-cou	po:nom	po:adj	is:epi	is:inv	di:M	fq:3	id:134314
casse-cou/S.()	po:nom	po:adj	is:epi	di:R	fq:2	id:134313
casse-couille/S.()	po:nom	po:adj	is:epi	lx:fam	di:R	fq:1	id:213766
casse-couilles	po:nom	po:adj	is:epi	is:inv	lx:fam	di:M	fq:2	id:213765
casse-croute/S.()	po:nom	is:mas	di:R	fq:2	id:134315
casse-croûte	po:nom	is:mas	is:inv	di:M	fq:2	id:134317
casse-crouter/a0p.()	po:v1_i____zz	di:R	fq:0	id:134316
casse-croûter/a0p.()	po:v1_i____zz	di:M	fq:1	id:134318

casse-cul	po:nom	po:adj	is:epi	is:inv	di:M	fq:1	id:134320
casse-cul/S.()	po:nom	po:adj	is:epi	di:R	fq:0	id:134319
casse-dalle/S.()	po:nom	is:mas	di:R	fq:0	id:134321
casse-dalle	po:nom	is:mas	is:inv	di:M	fq:1	id:134322
casse-fil/S.()	po:nom	is:mas	se:techni	di:*	fq:0	id:219953
casse-graine/S.()	po:nom	is:mas	di:R	fq:0	id:134323
casse-graine	po:nom	is:mas	is:inv	di:M	fq:1	id:134324

casse-gueule	po:nom	po:adj	is:epi	is:inv	di:M	fq:2	id:134326
casse-gueule/S.()	po:nom	po:adj	is:epi	di:R	fq:1	id:134325
casseille/S.()	po:nom	is:fem	se:bot	di:*	fq:1	id:231238
casseillier/S.()	po:nom	is:mas	se:bot	di:*	fq:1	id:231239
cassement/S.()	po:nom	is:mas	di:*	fq:4	id:134342
casse-noisette/S.()	po:nom	is:mas	di:R	fq:3	id:134327
casse-noisettes	po:nom	is:mas	is:inv	di:M	fq:2	id:134328
casse-noix	po:nom	is:mas	is:inv	di:*	fq:2	id:134329
casse-patte/S.()	po:nom	is:mas	di:R	fq:1	id:134330

CCTR	po:nom	is:epi	is:inv	lx:sig	di:X	fq:2	id:231993
cd/U.||--	po:nom	is:fem	is:inv	lx:symb	di:*	fq:6	id:201008
CD	po:nom	is:mas	is:inv	lx:sig	et:angl	di:*	fq:6	id:123656
CDD	po:nom	is:mas	is:inv	lx:sig	di:*	fq:5	id:210975
CDI	po:nom	is:mas	is:inv	lx:sig	di:*	fq:5	id:210976
cDNA	po:nom	is:mas	is:inv	lx:sig	se:bio	et:angl	di:*	fq:4	id:228090
CD-ROM	po:nom	is:mas	is:inv	lx:sig	et:angl	di:*	fq:4	id:200091
ce	po:mg	po:prodem	is:mas	is:sg	se:@	di:*	fq:9	id:134531
ce	po:mg	po:detdem	is:mas	is:sg	se:@	di:*	fq:9	id:232454
CE	po:nom	is:epi	is:inv	lx:sig	se:édu	se:polit	di:*	fq:7	id:226897
CE1	po:nom	is:mas	is:inv	lx:fra	di:*	fq:4	id:206377
CE2	po:nom	is:mas	is:inv	lx:fra	di:*	fq:5	id:206376
CEA	po:nom	is:mas	is:inv	lx:sig	di:X	fq:6	id:227365
céans	po:adv	di:*	fq:5	id:139164
Ceausescu	po:patr	is:epi	is:inv	se:polit	se:hist	di:*	fq:5	id:231303
cébette/S.()	po:nom	is:fem	di:*	fq:2	id:206634

chasse-goupille/S.()	po:nom	is:mas	se:techni	di:*	fq:1	id:228593
chasselas	po:nom	is:mas	is:inv	di:*	fq:5	id:135004
chasse-marée/S.()	po:nom	is:mas	di:R	fq:2	id:134990
chasse-marée	po:nom	is:mas	is:inv	di:M	fq:2	id:134991
chasse-mouche/S.()	po:nom	is:mas	di:R	fq:3	id:134992
chasse-mouches	po:nom	is:mas	is:inv	di:M	fq:2	id:134993
chasse-moustique/S.()	po:nom	is:mas	se:techni	di:*	fq:1	id:228592

chasse-neige	po:nom	is:mas	is:inv	di:M	fq:3	id:134995
chasse-neige/S.()	po:nom	is:mas	di:R	fq:2	id:134994
chasse-pierre/S.()	po:nom	is:mas	di:R	fq:1	id:134996
chasse-pierres	po:nom	is:mas	is:inv	di:M	fq:2	id:134997
chasse-pointe/S.()	po:nom	is:mas	se:techni	di:*	fq:1	id:228591
chassepot/S.()	po:nom	is:mas	se:hist	se:arm	di:*	fq:5	id:135005
chasser/a0p+()	po:v1_it____a	di:*	fq:7	id:135006
chasseresse/S.()	po:nom	is:fem	di:*	fq:5	id:135007
chasse-rivet/S.()	po:nom	is:mas	di:*	fq:1	id:134998
chasse-rivets	po:nom	is:mas	is:inv	di:C	fq:0	id:134999
chasse-roue/S.()	po:nom	is:mas	di:*	fq:2	id:135000
chasse-roues	po:nom	is:mas	is:inv	di:C	fq:1	id:135001
chassés-croisés	po:nom	is:mas	is:pl	di:*	fq:2	id:135013
chasseuse/F.()	po:nom	di:*	fq:7	id:135008

chasse-vase	po:nom	is:mas	is:inv	di:M	fq:1	id:135003
chasse-vase/S.()	po:nom	is:mas	di:R	fq:0	id:135002
chassie/S.()	po:nom	is:fem	di:*	fq:4	id:135009
chassieuse/W.()	po:adj	di:*	fq:5	id:135010
châssis	po:nom	is:mas	is:inv	di:*	fq:6	id:135535
chassoir/S.()	po:nom	is:mas	se:techni	di:*	fq:3	id:222947
chaste/S.()	po:adj	is:epi	di:*	fq:6	id:135014
Chastel-Arnaud	po:npr	is:epi	is:inv	se:cité	di:X	fq:2	id:231996
chastement	po:adv	di:*	fq:5	id:135015

chauffe-assiette/S.()	po:nom	is:mas	di:*	fq:1	id:135053
chauffe-assiettes	po:nom	is:mas	is:inv	di:C	fq:1	id:135054
chauffe-bain	po:nom	is:mas	is:inv	di:C	fq:1	id:135056
chauffe-bain/S.()	po:nom	is:mas	di:*	fq:2	id:135055
chauffe-ballon/S.()	po:nom	is:mas	se:techni	se:chim	di:*	fq:1	id:226723
chauffe-biberon/S.()	po:nom	is:mas	di:*	fq:1	id:135057
chauffe-biberons	po:nom	is:mas	is:inv	di:C	fq:1	id:135058
chauffe-cire	po:nom	is:mas	is:inv	se:@	se:hist	di:C	fq:2	id:219985
chauffe-cire/S.()	po:nom	is:mas	se:@	se:hist	di:*	fq:1	id:219984
chauffe-eau	po:nom	is:mas	is:inv	di:M	fq:3	id:135060
chauffe-eau/X.()	po:nom	is:mas	di:R	fq:2	id:135059

chauffe-lit/S.()	po:nom	is:mas	di:*	fq:0	id:135061
chauffe-lit	po:nom	is:mas	is:inv	di:C	fq:1	id:135062
chauffe-main/S.()	po:nom	is:mas	se:techni	di:*	fq:1	id:226724
chauffe-mout/S.()	po:nom	is:mas	di:R	fq:0	id:135063
chauffe-moût/S.()	po:nom	is:mas	di:M	fq:0	id:209443
chauffe-moût	po:nom	is:mas	is:inv	di:C	fq:0	id:135064
chauffe-pain/S.()	po:nom	is:mas	se:techni	se:cuis	di:*	fq:0	id:226725

cochonnet/S.()	po:nom	is:mas	di:*	fq:4	id:136182
cochylis	po:nom	is:epi	is:inv	se:zool	di:*	fq:5	id:136183
cocker/S.()	po:nom	is:mas	se:zool	et:angl	di:*	fq:4	id:136186
cockney/S.()	po:nom	po:adj	is:epi	et:angl	di:*	fq:4	id:136187
cockpit/S.()	po:nom	is:mas	di:*	fq:5	id:136188
cocktail/S.()	po:nom	is:mas	di:*	fq:6	id:136189
coco/S.()	po:nom	is:mas	di:*	fq:6	id:136190
cocommanditaire/S.()	po:nom	is:epi	di:*	id:233115
cocompacte/F.()	po:adj	lx:rare	di:*	fq:1	id:136191
cocon/S.()	po:nom	is:mas	di:*	fq:6	id:136192
coconstruction/S.()	po:nom	is:fem	se:constr	di:*	fq:4	id:232661
coconstruire/yM()	po:v3_it_q__a	di:*	fq:4	id:226654
cocontractante/F.()	po:adj	di:*	fq:5	id:136193
cocooner/a0p+()	po:v1_it____a	lx:néo	et:angl	di:*	fq:3	id:229188
cocooning/S.()	po:nom	is:mas	et:angl	di:*	fq:4	id:219762

consensus	po:nom	is:mas	is:inv	et:lat	di:*	fq:6	id:137193
consentante/F.()	po:adj	di:*	fq:5	id:137194
consentement/S.()	po:nom	is:mas	di:*	fq:7	id:137195
consentir/i5q+()	po:v3_itn___a	di:*	fq:7	id:137197
conséquemment	po:adv	di:*	fq:6	id:137312
conséquence/S.()	po:nom	is:fem	se:log	di:*	fq:8	id:137313
conséquente/F.()	po:adj	se:log	di:*	fq:8	id:137314
conséquentialisme/S.()	po:nom	is:mas	se:philo	di:*	id:233146
conséquentialiste/S.()	po:nom	po:adj	is:epi	se:philo	di:*	id:233145
conservable/S.()	po:adj	is:epi	di:*	fq:4	id:209652
conservation/S.()	po:nom	is:fem	di:*	fq:7	id:137198
conservationniste/S.()	po:nom	po:adj	is:epi	lx:néo	di:*	fq:4	id:214856
conservatisme/S.()	po:nom	is:mas	di:*	fq:6	id:137199
conservative/F.()	po:adj	di:*	fq:5	id:206258
conservatoire/S.()	po:nom	is:mas	di:*	fq:6	id:211903
conservatoire/S.()	po:adj	is:epi	di:*	fq:6	id:137200

constrictive/F.()	po:adj	se:lingu	se:méd	di:*	fq:5	id:218140
constrictor/S.()	po:nom	po:adj	is:mas	se:zool	di:*	fq:4	id:219234
constringente/F.()	po:adj	lx:vx	et:lat	di:*	fq:3	id:220349
constructibilité/S.()	po:nom	is:fem	di:*	fq:4	id:137285
constructible/S.()	po:adj	is:epi	di:*	fq:5	id:137286
construction/S.()	po:nom	is:fem	di:*	fq:8	id:137287
constructive/F.()	po:adj	di:*	fq:6	id:137288
constructivement	po:adv	di:*	id:233126
constructivisme/S.()	po:nom	is:mas	di:*	fq:5	id:201473
constructiviste/S.()	po:nom	po:adj	is:epi	di:*	fq:5	id:201474
constructivité/S.()	po:nom	is:fem	di:*	fq:4	id:201497
constructrice/F.()	po:nom	po:adj	di:*	fq:7	id:137289
construire/yM()	po:v3_it_q__a	di:*	fq:8	id:137290
consubstantialité/S.()	po:nom	is:fem	di:*	fq:5	id:137292
consubstantiation/S.()	po:nom	is:fem	se:chris	di:*	fq:4	id:137293

contrexpertise/S.()	po:nom	is:fem	di:R	fq:0	id:137723
contrextension/S.()	po:nom	is:fem	di:R	fq:3	id:137724
contribuable/S.()	po:nom	is:epi	di:*	fq:7	id:137725
contribuer/a0p.()	po:v1_i_n___a	di:*	fq:8	id:137726
contributaire/S.()	po:nom	po:adj	is:epi	et:lat	di:*	fq:4	id:231464
contribution/S.()	po:nom	is:fem	di:*	fq:7	id:137727
contributive/F.()	po:adj	di:*	fq:6	id:137728
contributivité/S.()	po:nom	is:fem	di:*	id:233154
contributoire/S.()	po:adj	is:epi	lx:vx	di:*	fq:5	id:231268
contributrice/F.()	po:nom	di:*	fq:6	id:137729
contrindication/S.()	po:nom	is:fem	di:R	fq:3	id:137730
contrindiquer/a0p+()	po:v1__t___zz	di:R	fq:3	id:137731
contrinterrogatoire/S.()	po:nom	is:mas	di:R	fq:0	id:137733
contrintuitive/F.()	po:adj	lx:rare	se:log	di:R	fq:1	id:220368
contrinvestissement/S.()	po:nom	is:mas	lx:rare	di:R	fq:0	id:213219

controversable/S.()	po:adj	is:epi	di:*	fq:4	id:137742
controverse/S.()	po:nom	is:fem	di:*	fq:6	id:137743
controverser/a0p+()	po:v1_it___zz	di:*	fq:6	id:137744
controversiste/S.()	po:nom	is:epi	di:*	fq:5	id:137745
contrut	po:nom	is:mas	is:inv	se:mus	di:R	fq:3	id:204190
contumace/S.()	po:nom	po:adj	is:epi	di:*	fq:6	id:137758
contumax	po:nom	po:adj	is:epi	is:inv	et:lat	di:*	fq:5	id:137759
contumélie/S.()	po:nom	is:fem	lx:vx	et:lat	di:*	id:233118
contuse/F.()	po:adj	lx:vx	lx:fxa	se:méd	et:lat	di:*	fq:5	id:224439
contusion/S.()	po:nom	is:fem	di:*	fq:6	id:137760
contusionner/a0p+()	po:v1__t___zz	di:*	fq:5	id:137761
conurbation/S.()	po:nom	is:fem	di:*	fq:5	id:137764
convaincable/S.()	po:adj	is:epi	lx:rare	di:*	fq:0	id:231902
convaincante/F.()	po:adj	di:*	fq:6	id:137765
convaincre/wP()	po:v3_it_q__a	di:*	fq:7	id:137766

coquillette/S.()	po:nom	is:fem	di:*	fq:3	id:137911
coquilleuse/F.()	po:nom	di:*	fq:4	id:201016
coquillière/F.()	po:adj	di:M	fq:5	id:137912
coquine/F.()	po:nom	po:adj	di:*	fq:6	id:137915
coquinement	po:adv	di:*	fq:3	id:209814
coquinerie/S.()	po:nom	is:fem	di:*	fq:4	id:137916
cor/S.()	po:nom	is:mas	di:*	fq:6	id:137918
Cora	po:npr	is:epi	is:inv	se:soc	se:biz	di:*	id:233114
coracle/S.()	po:nom	is:mas	di:*	fq:3	id:137919
coracobrachiale/W.()	po:adj	se:anat	di:R	fq:4	id:225776
coraco-brachiale/W.()	po:adj	se:anat	di:M	fq:2	id:225775
coracoïde/S.()	po:nom	po:adj	is:epi	se:anat	di:*	fq:5	id:216870
coracoïdienne/F.()	po:adj	di:*	fq:5	id:215846
corail/X.()	po:nom	is:mas	di:*	fq:6	id:137920
corail	po:adj	is:epi	is:inv	lx:col	di:*	fq:6	id:212713

coupée/F.()	po:nom	di:*	fq:7	id:138265
coupe-faim	po:nom	is:mas	is:inv	lx:fam	di:M	fq:2	id:209664
coupe-faim/S.()	po:nom	is:mas	lx:fam	di:R	fq:1	id:209665
coupe-feu	po:nom	is:mas	is:inv	di:M	fq:2	id:138221
coupe-feu/X.()	po:nom	is:mas	di:R	fq:2	id:138220
coupe-file	po:nom	is:mas	is:inv	di:M	fq:1	id:138223
coupe-file/S.()	po:nom	is:mas	di:R	fq:1	id:138222

coupe-gorge	po:nom	is:mas	is:inv	di:M	fq:3	id:138225
coupe-gorge/S.()	po:nom	is:mas	di:R	fq:2	id:138224
coupe-herbe/S.()	po:nom	is:mas	se:jard	di:*	fq:1	id:228664
coupe-jambon/S.()	po:nom	is:mas	di:R	fq:0	id:138226
coupe-jambon	po:nom	is:mas	is:inv	di:M	fq:1	id:138227
coupe-jarret/S.()	po:nom	is:mas	di:R	fq:2	id:138228
coupe-jarrets	po:nom	is:mas	is:inv	di:M	fq:2	id:138229
coupe-légume/S.()	po:nom	is:mas	di:R	fq:0	id:138230
coupe-légumes	po:nom	is:mas	is:inv	di:M	fq:1	id:138231

crevé/S.()	po:nom	is:mas	di:*	fq:5	id:214452
crève-chien/S.()	po:nom	is:mas	se:bot	di:*	fq:1	id:228395
crève-cœur/S.()	po:nom	is:mas	di:R	fq:0	id:138744
crève-cœur	po:nom	is:mas	is:inv	di:M	fq:3	id:138745
crevée/S.()	po:nom	is:fem	lx:fam	lx:helv	di:*	fq:5	id:214453
crève-la-faim	po:nom	is:epi	is:inv	lx:fam	di:*	fq:1	id:210255
crever/b0p+()	po:v1_it_q_zz	di:*	fq:6	id:138537

crève-tonneau	po:nom	is:mas	is:inv	di:M	fq:1	id:138747
crève-tonneau/X.()	po:nom	is:mas	di:R	fq:0	id:138746
crevette/S.()	po:nom	is:fem	di:*	fq:6	id:138538
crevetticultrice/F.()	po:nom	lx:rare	se:élev	di:*	fq:0	id:225207
crevetticulture/S.()	po:nom	is:fem	se:élev	di:*	fq:3	id:225206
crevettier/S.()	po:nom	is:mas	se:marin	se:pêche	di:*	fq:4	id:218318
crève-vessie	po:nom	is:mas	is:inv	di:M	fq:0	id:138749
crève-vessie/S.()	po:nom	is:mas	di:R	fq:0	id:138748
crevure/S.()	po:nom	is:fem	di:*	fq:3	id:206084

cristallographe/S.()	po:nom	is:epi	di:*	fq:4	id:201847
cristallographie/S.()	po:nom	is:fem	di:*	fq:5	id:138586
cristallographique/S.()	po:adj	is:epi	di:*	fq:5	id:138587
cristalloïde/S.()	po:nom	po:adj	is:epi	di:*	fq:5	id:215711
cristallophyllienne/F.()	po:adj	se:géol	se:minér	di:*	fq:5	id:219269
criste-marine	po:nom	is:fem	is:sg	se:bot	di:*	fq:1	id:218319
cristes-marines	po:nom	is:fem	is:pl	st:criste-marine	se:bot	di:*	fq:1	id:218320
Cristinacce	po:npr	is:epi	is:inv	se:cité	di:*	id:233132
cristobalite/S.()	po:nom	is:fem	se:chim	di:*	fq:4	id:225172
critère/S.()	po:nom	is:mas	di:*	fq:7	id:138598
critériologie/S.()	po:nom	is:fem	di:*	fq:4	id:216164
critériologique/S.()	po:adj	is:epi	lx:rare	di:*	fq:4	id:216163
criterium/I.()	po:nom	is:mas	et:lat	di:C	fq:6	id:138590
critérium/S.()	po:nom	is:mas	et:lat	di:*	fq:6	id:138599
crithme/S.()	po:nom	is:mas	se:bot	di:*	fq:1	id:218321

cytotoxique/S.()	po:adj	is:epi	di:*	fq:5	id:216028
czar/S.()	po:nom	is:mas	lx:vx	lx:dic	et:pol	di:C	fq:6	id:139135
czardas	po:nom	is:fem	is:inv	se:danse	et:étr	di:*	fq:4	id:221088
Czestochowa	po:npr	is:epi	is:inv	se:cité	di:*	fq:4	id:213711
czimbalum/S.()	po:nom	is:mas	di:*	fq:1	id:139136
d/||--	po:nom	is:mas	is:inv	lx:symb	di:*	fq:9	id:201094
d	po:nom	is:mas	is:inv	se:@	di:*	fq:9	id:139281

d’	po:mg	po:prep	po:prepv	st:de	se:@	di:*	fq:0	id:232452
d’	po:mg	po:det	is:epi	is:inv	st:de	se:@	di:*	fq:0	id:232451
Dʳ	po:titr	is:mas	is:sg	lx:abty	di:*	fq:1	id:232283
Dʳˢ	po:titr	is:mas	is:pl	lx:abty	di:*	fq:0	id:232284
Dʳᵉ	po:titr	is:fem	is:sg	lx:abty	di:*	fq:0	id:232285
Dʳᵉˢ	po:titr	is:fem	is:pl	lx:abty	di:*	fq:0	id:232286
Dᴏꜱꜱᴍᴀɴɴ	po:patr	is:epi	is:inv	di:X	fq:0	id:232023
Da/U.||--	po:nom	is:mas	is:inv	lx:symb	di:*	fq:6	id:201068
DAB	po:nom	is:mas	is:inv	lx:sig	di:*	fq:5	id:225716

dahoméenne/F.()	po:nom	po:adj	di:*	fq:5	id:139305
Dahomey	po:nom	is:mas	is:inv	se:pays	se:hist	di:*	fq:6	id:123889
dahu/S.()	po:nom	is:mas	di:*	fq:3	id:214749
daigner/a0p+()	po:v1__t___zz	di:*	fq:6	id:139306
daim/S.()	po:nom	is:mas	di:*	fq:6	id:139307
daïmio/S.()	po:nom	is:mas	se:hist	et:jap	di:*	fq:5	id:139423
Daimler	po:npr	is:epi	is:inv	se:soc	di:*	fq:5	id:222341
daine/S.()	po:nom	is:fem	se:zool	di:*	fq:5	id:139308
dais	po:nom	is:mas	is:inv	di:*	fq:6	id:139309
Daisy	po:prn	is:fem	is:inv	di:*	fq:5	id:221822
Dakar	po:npr	is:epi	is:inv	se:cité	di:*	fq:7	id:123890
Dakota	po:nom	is:mas	is:inv	se:pays	di:*	fq:5	id:123891
dalaïlama/S.()	po:nom	is:mas	di:R	fq:3	id:207098
dalaï-lama/S.()	po:nom	is:mas	di:M	fq:4	id:139310
Dale	po:prn	is:mas	is:inv	di:*	fq:5	id:221231

Davis	po:patr	is:epi	is:inv	di:*	fq:6	id:221827
Davos	po:npr	is:epi	is:inv	se:cité	di:*	fq:5	id:224542
Davy	po:prn	is:mas	is:inv	di:*	fq:6	id:202152
Dawn	po:prn	is:fem	is:inv	di:*	fq:5	id:222121
Dax	po:npr	is:epi	is:inv	se:cité	di:*	fq:6	id:123909
dazibao/S.()	po:nom	is:mas	et:chin	di:*	fq:4	id:139422
dB/||--	po:nom	is:mas	is:inv	lx:symb	di:*	fq:5	id:201072

de	po:mg	po:det	is:epi	is:inv	se:@	di:*	fq:9	id:139424
de	po:mg	po:prep	po:prepv	se:@	di:*	fq:9	id:232453
dé/S.()	po:nom	is:mas	di:*	fq:7	id:140961
DEA	po:nom	is:mas	is:inv	lx:sig	se:édu	di:*	fq:6	id:229004
déactiver/a0p+()	po:v1__t___zz	lx:rare	lx:fxa	di:*	fq:2	id:140962
deal/S.()	po:nom	is:mas	lx:fam	et:angl	di:*	fq:6	id:206789
dealer/S.()	po:nom	is:epi	lx:fam	et:angl	di:M	fq:5	id:139426
dealer/a0p+()	po:v1_it___zz	lx:fam	et:angl	di:*	fq:4	id:139425
dealeuse/F.()	po:nom	lx:fam	lx:dic	et:angl	di:R	fq:2	id:139428
déambulateur/S.()	po:nom	is:mas	di:*	fq:4	id:203433
déambulation/S.()	po:nom	is:fem	di:*	fq:5	id:140963
déambulatoire/S.()	po:adj	is:epi	di:*	fq:5	id:140964
déambuler/a0p+()	po:v1_i__q_zz	di:*	fq:5	id:140965
Dean	po:prn	is:mas	is:inv	di:*	fq:6	id:222659
deauvillaise/F.()	po:nom	po:adj	se:gent	di:*	id:233167
Deauville	po:npr	is:epi	is:inv	se:cité	di:*	fq:5	id:206292
débâchage/S.()	po:nom	is:mas	di:*	fq:3	id:141136
débâcher/a0p+()	po:v1_it___zz	di:*	fq:3	id:141137
débâcle/S.()	po:nom	is:fem	di:*	fq:6	id:141139
débâclement/S.()	po:nom	is:mas	di:*	fq:1	id:141140
débâcler/a0p+()	po:v1_it___zz	di:*	fq:3	id:141141
débagouler/a0p+()	po:v1_it___zz	di:*	fq:3	id:140966

débranchement/S.()	po:nom	is:mas	di:*	fq:4	id:141102
débrancher/a0p+()	po:v1__t_q_zz	di:*	fq:5	id:141103
débrasage/S.()	po:nom	is:mas	se:techni	di:*	fq:0	id:221714
débrayable/S.()	po:adj	is:epi	se:méca	di:*	fq:4	id:228826
débrayage/S.()	po:nom	is:mas	di:*	fq:5	id:141105
débrayer/a0p+()	po:v1_it___zz	di:*	fq:5	id:141106
Debrecen	po:npr	is:epi	is:inv	se:cité	di:*	fq:5	id:214089
débridage/S.()	po:nom	is:mas	di:*	id:233127
débridement/S.()	po:nom	is:mas	di:*	fq:5	id:141107
débrider/a0p+()	po:v1_it___zz	di:*	fq:6	id:141108
débriefer/a0p+()	po:v1__t___zz	di:*	fq:3	id:141110
debriefing/S.()	po:nom	is:mas	et:angl	di:C	fq:4	id:183246
débriefing/S.()	po:nom	is:mas	et:angl	di:*	fq:4	id:141111
débris	po:nom	is:mas	is:inv	di:*	fq:7	id:141112
débrochable/S.()	po:adj	is:epi	di:*	fq:4	id:215173

dégueulasser/a0p+()	po:v1__t___zz	lx:fam	di:*	fq:3	id:141954
dégueulasserie/S.()	po:nom	is:fem	lx:fam	di:*	fq:3	id:209927
dégueulatoire/S.()	po:adj	is:epi	lx:fam	lx:péj	lx:rare	di:*	fq:0	id:216927
dégueuler/a0p+()	po:v1_it___zz	lx:fam	di:*	fq:5	id:141956
dégueulis	po:nom	is:mas	is:inv	lx:fam	di:*	fq:4	id:206991
déguisement/S.()	po:nom	is:mas	di:*	fq:6	id:141957
déguiser/a0p+()	po:v1__t_q__a	di:*	fq:7	id:141958

dégun	po:mg	po:proneg	is:mas	is:sg	se:@	et:lat	et:occ	di:X	fq:2	id:227606
dégun/S.()	po:nom	is:mas	et:lat	et:occ	di:X	fq:1	id:227607
dégurgitation/S.()	po:nom	is:fem	lx:rare	di:*	fq:3	id:217550
dégurgiter/a0p+()	po:v1__t___zz	di:*	fq:3	id:141960
dégustation/S.()	po:nom	is:fem	di:*	fq:6	id:141962
dégustative/F.()	po:adj	di:*	fq:4	id:231915
dégustatrice/F.()	po:nom	po:adj	di:*	fq:5	id:141963
déguster/a0p+()	po:v1__t___zz	di:*	fq:6	id:141964
dégyration/S.()	po:nom	is:fem	lx:néo	se:astronaut	di:*	fq:0	id:216945

demi-longueur/S.()	po:nom	is:fem	di:*	fq:2	id:139483
demi-lune/S.()	po:nom	is:fem	di:*	fq:4	id:139484
demi-mal/X.()	po:nom	is:mas	di:*	fq:3	id:139485
demi-mesure/S.()	po:nom	is:fem	di:*	fq:3	id:139486
demi-mondaine/S.()	po:nom	is:fem	di:*	fq:3	id:139487
demi-monde/S.()	po:nom	is:mas	di:*	fq:3	id:139488
demi-morte/F.()	po:adj	di:*	fq:3	id:139489
demi-mot/S.()	po:nom	is:mas	di:*	fq:3	id:139490
déminage/S.()	po:nom	is:mas	di:*	fq:5	id:142197
déminer/a0p+()	po:v1__t___zz	di:*	fq:5	id:142198
déminéralisation/S.()	po:nom	is:fem	di:*	fq:5	id:142201
déminéraliser/a0p+()	po:v1__t___zz	di:*	fq:5	id:142202
démineuse/F.()	po:nom	di:*	fq:4	id:142199
demi-pause/S.()	po:nom	is:fem	di:*	fq:2	id:139491
demi-pension/S.()	po:nom	is:fem	di:*	fq:2	id:139492

demi-reliure/S.()	po:nom	is:fem	di:*	fq:3	id:139500
demi-ronde/S.()	po:nom	is:fem	di:*	fq:2	id:139501
demi-saison/S.()	po:nom	is:fem	di:*	fq:3	id:139502
demi-sang	po:nom	is:mas	is:inv	di:*	fq:3	id:139503
demi-sel	po:nom	is:mas	is:inv	di:*	fq:2	id:139504
demi-siècle/S.()	po:nom	is:mas	se:temps	di:*	fq:4	id:230674
demi-sœur/S.()	po:nom	is:fem	di:*	fq:4	id:139508

demi-solde	po:nom	is:mas	is:inv	di:*	fq:3	id:213125
demi-solde/S.()	po:nom	is:fem	di:*	fq:2	id:139505
demi-sommeil/S.()	po:nom	is:mas	di:*	fq:3	id:139506
demi-soupir/S.()	po:nom	is:mas	di:*	fq:2	id:139507
démission/S.()	po:nom	is:fem	di:*	fq:7	id:142205
démissionnaire/S.()	po:nom	po:adj	is:epi	di:*	fq:6	id:142206
démissionner/a0p.()	po:v1_i_n__zz	di:*	fq:6	id:142207
demi-succès	po:nom	is:mas	is:inv	di:*	fq:3	id:230683
demi-tarif/S.()	po:nom	is:mas	di:*	fq:2	id:139509

désilage/S.()	po:nom	is:mas	se:agri	di:*	fq:4	id:225998
désiliciage/S.()	po:nom	is:mas	di:*	fq:0	id:142964
désillusion/S.()	po:nom	is:fem	di:*	fq:6	id:142965
désillusionnement/S.()	po:nom	is:mas	di:*	fq:4	id:223302
désillusionner/a0p+()	po:v1__t___zz	di:*	fq:5	id:142966
désimbrication/S.()	po:nom	is:fem	di:*	fq:3	id:226490
désimbriquer/a0p+()	po:v1__t_q__a	di:*	fq:3	id:226252
désimlockage/S.()	po:nom	is:mas	lx:néo	se:info	et:angl	di:*	id:233093
désimlocker/a0p+()	po:v1_it____a	lx:néo	se:info	et:angl	di:*	id:233023
désincarcération/S.()	po:nom	is:fem	se:techni	di:*	fq:3	id:223301
désincarcérer/c0p+()	po:v1__t___zz	di:*	fq:3	id:142968
désincarnation/S.()	po:nom	is:fem	di:*	fq:5	id:209658
désincarner/a0p+()	po:v1__t_q_zz	di:*	fq:5	id:142970
désincitation/S.()	po:nom	is:fem	di:*	fq:4	id:229284
désincitative/F.()	po:adj	di:*	fq:4	id:229534

désinstaller/a0p+()	po:v1__t___zz	di:*	fq:4	id:142998
désinstitutionnalisation/S.()	po:nom	is:fem	lx:néo	se:admin	se:polit	di:*	fq:4	id:219909
désinstitutionnaliser/a0p+()	po:v1__t_q_zz	lx:néo	di:*	fq:4	id:224205
désintégrateur/S.()	po:nom	is:mas	lx:néo	di:*	fq:4	id:213870
désintégration/S.()	po:nom	is:fem	di:*	fq:6	id:143003
désintégrative/F.()	po:adj	se:psycho	di:*	fq:4	id:225397
désintégrer/c0p+()	po:v1__t_q_zz	di:*	fq:5	id:143004
désintensification/S.()	po:nom	is:fem	di:*	id:233143
désintéressement/S.()	po:nom	is:mas	di:*	fq:6	id:143006
désintéresser/a0p+()	po:v1__t_q_zz	di:*	fq:7	id:143007
désintérêt/S.()	po:nom	is:mas	di:*	fq:6	id:143009
désintermédiation/S.()	po:nom	is:fem	lx:néo	se:écono	di:*	fq:4	id:217580
désintermédier/a0p+()	po:v1_it_q__a	lx:néo	se:écono	di:*	fq:4	id:222376
désintox	po:nom	is:fem	is:inv	lx:abr	lx:fam	se:méd	di:*	fq:3	id:224435
désintoxication/S.()	po:nom	is:fem	di:*	fq:5	id:143000

dévitaliser/a0p+()	po:v1__t___zz	di:*	fq:5	id:143282
dévitaminer/a0p+()	po:v1__t____a	se:méd	di:*	fq:3	id:225576
dévitrification/S.()	po:nom	is:fem	di:*	fq:4	id:143284
dévitrifier/a0p+()	po:v1__t___zz	di:*	fq:4	id:143285
dévoiement/S.()	po:nom	is:mas	di:*	fq:5	id:143287
dévoilement/S.()	po:nom	is:mas	di:*	fq:6	id:143288
dévoiler/a0p+()	po:v1__t_q_zz	di:*	fq:7	id:143289

devoir/S.()	po:nom	is:mas	di:*	fq:7	id:139706
devoir/pCpD()	po:v3__tnq__a	di:*	fq:9	id:139707
dévoisement/S.()	po:nom	is:mas	se:lingu	et:lat	di:*	fq:4	id:222978
dévoiser/a0p+()	po:v1__t_q_zz	se:lingu	et:lat	di:*	fq:3	id:222979
dévoltage/S.()	po:nom	is:mas	di:*	fq:3	id:143291
dévolter/a0p+()	po:v1__t___zz	di:*	fq:1	id:143292
dévolteur/S.()	po:nom	is:mas	di:*	fq:4	id:143293
dévolu/S.()	po:nom	is:mas	di:*	fq:6	id:224756
dévolue/F.()	po:adj	di:*	fq:6	id:143294

disproportionnément	po:adv	di:*	fq:3	id:224615
disproportionner/a0p+()	po:v1__t___zz	di:*	fq:6	id:140208
disputailler/a0p.()	po:v1_i____zz	di:*	fq:3	id:140210
dispute/S.()	po:nom	is:fem	di:*	fq:6	id:140211
disputer/a0p+()	po:v1__tnq_zz	di:*	fq:7	id:140212
disputeuse/F.()	po:nom	po:adj	di:*	fq:5	id:214808
disquaire/S.()	po:nom	is:epi	di:*	fq:4	id:140214
disqualifiante/F.()	po:adj	di:*	id:233139
disqualification/S.()	po:nom	is:fem	di:*	fq:5	id:140215
disqualifiée/F.()	po:nom	po:adj	di:*	fq:5	id:140217
disqualifier/a0p+()	po:v1__t_q_zz	di:*	fq:6	id:140216
disque/S.()	po:nom	is:mas	di:*	fq:7	id:140218
disque-jockey	po:nom	is:epi	is:sg	et:angl	di:R	fq:1	id:210878
disques-jockeys	po:nom	is:epi	is:pl	et:angl	di:R	fq:0	id:210879
disquette/S.()	po:nom	is:fem	di:*	fq:5	id:140219

distributif/S.()	po:nom	is:mas	se:lingu	di:*	fq:5	id:216868
distribution/S.()	po:nom	is:fem	di:*	fq:7	id:140310
distributionalisme/S.()	po:nom	is:mas	lx:rare	di:R	fq:3	id:209459
distributionaliste/S.()	po:nom	po:adj	is:epi	lx:rare	di:R	fq:3	id:209461
distributionnalisme/S.()	po:nom	is:mas	di:M	fq:4	id:209458
distributionnaliste/S.()	po:nom	po:adj	is:epi	di:M	fq:4	id:209460
distributionnelle/F.()	po:adj	di:*	fq:5	id:140311
distributisme/S.()	po:nom	is:mas	se:polit	se:écono	di:*	id:233152
distributive/F.()	po:adj	di:*	fq:6	id:140312
distributivement	po:adv	di:*	fq:4	id:210601
distributivité/S.()	po:nom	is:fem	di:*	fq:4	id:140313
distributrice/F.()	po:nom	po:adj	di:*	fq:6	id:140314
district/S.()	po:nom	is:mas	di:*	fq:7	id:140316
distyle/S.()	po:adj	is:epi	di:*	fq:3	id:140317
disubstituée/F.()	po:adj	se:chim	di:*	fq:4	id:224931

Durand	po:patr	is:epi	is:inv	di:*	fq:6	id:224559
durant	po:mg	po:prep	se:@	di:*	fq:7	id:209855
duratif/S.()	po:nom	is:mas	di:*	fq:4	id:214807
durative/F.()	po:adj	di:*	fq:4	id:140874
Durban	po:npr	is:epi	is:inv	se:cité	di:*	fq:5	id:213889
Durbuy	po:npr	is:epi	is:inv	se:cité	di:*	fq:5	id:123982
durcir/f0p+()	po:v2_it_q_zz	di:*	fq:6	id:140876
durcissante/F.()	po:adj	di:*	id:233122
durcissement/S.()	po:nom	is:mas	di:*	fq:6	id:140877
durcisseur/S.()	po:nom	is:mas	di:*	fq:4	id:140878
dure/F.()	po:nom	po:adj	di:*	fq:7	id:140879
durée/S.()	po:nom	is:fem	se:temps	di:*	fq:8	id:140889
durement	po:adv	di:*	fq:6	id:140881
dure-mère	po:nom	is:fem	is:sg	di:*	fq:3	id:140880
durer/a0p.()	po:v1_i_____a	se:temps	di:*	fq:7	id:140882

effleurer/a2p+()	po:v1__t___zz	di:*	fq:6	id:143405
effleurie/F*()	po:adj	di:*	fq:4	id:143406
effleurir/f1p.()	po:v2_i____zz	di:*	fq:5	id:143407
effloraison/S*()	po:nom	is:fem	di:*	fq:4	id:143409
efflorescence/S*()	po:nom	is:fem	di:*	fq:5	id:143410
efflorescente/F*()	po:adj	di:*	fq:4	id:143411
effluence/S*()	po:nom	is:fem	di:*	fq:4	id:143412
effluent/S*()	po:nom	is:mas	di:*	id:233128
effluente/F*()	po:adj	di:*	fq:6	id:143413
effluve/S*()	po:nom	is:epi	et:lat	di:*	fq:5	id:143414
effluver/a1p.()	po:v1_i____zz	di:*	fq:3	id:143415
efflux/L'D'Q'	po:nom	is:mas	is:inv	di:*	fq:4	id:224859
effondrement/S*()	po:nom	is:mas	di:*	fq:6	id:143416
effondrer/a4p+()	po:v1__t_q_zz	di:*	fq:6	id:143417
effondrilles/D'Q'	po:nom	is:fem	is:pl	lx:vx	di:*	fq:3	id:220350

éminemment/D'Q'	po:adv	di:*	fq:7	id:181437
éminence/S*()	po:nom	is:fem	di:*	fq:6	id:181438
éminente/F*()	po:adj	di:*	fq:7	id:181439
éminentissime/S*()	po:adj	is:epi	et:ita	di:*	fq:4	id:181440
émir/S*()	po:nom	is:mas	di:*	fq:6	id:181441
émirat/S*()	po:nom	is:mas	di:*	fq:5	id:181442
émiratie/F*()	po:nom	po:adj	se:gent	di:*	fq:4	id:225320
émirienne/F*()	po:nom	po:adj	se:gent	di:*	id:233097
émissaire/S*()	po:nom	is:epi	di:*	fq:6	id:181444
émission/S*()	po:nom	is:fem	di:*	fq:7	id:181445
émissive/F*()	po:adj	di:*	fq:5	id:181446
émissivité/S*()	po:nom	is:fem	di:*	fq:4	id:210754
émissole/S*()	po:nom	is:fem	se:zool	di:*	fq:3	id:181447
émittance/S*()	po:nom	is:fem	se:phys	di:*	fq:4	id:224977
Emma/L'D'Q'	po:prn	is:fem	is:inv	di:*	fq:6	id:124002

empoisonneuse/F*()	po:nom	po:adj	di:*	fq:5	id:143819
empoisser/a2p+()	po:v1__t___zz	di:*	fq:4	id:143821
empoissonnement/S*()	po:nom	is:mas	di:*	fq:4	id:143822
empoissonner/a2p+()	po:v1__t___zz	di:*	fq:4	id:143823
emporium/I*()	po:nom	is:mas	et:lat	di:*	fq:5	id:143828
emport/S*()	po:nom	is:mas	di:*	fq:5	id:143829
emportement/S*()	po:nom	is:mas	di:*	fq:6	id:143832

emporte-pièce/L'D'Q'	po:nom	is:mas	is:inv	di:M	fq:3	id:143831
emporte-pièce/S*()	po:nom	is:mas	di:R	fq:2	id:143830
emporter/a4p+()	po:v1__t_q_zz	di:*	fq:7	id:143833
empotage/S*()	po:nom	is:mas	di:*	fq:4	id:216207
empotée/F*()	po:nom	po:adj	di:*	fq:4	id:143836
empotement/S*()	po:nom	is:mas	lx:alt	di:*	fq:4	id:216208
empoter/a2p+()	po:v1__t___zz	di:*	fq:4	id:143835
empourprer/a4p+()	po:v1__t_q_zz	di:*	fq:5	id:143837
empoussiérage/S*()	po:nom	is:mas	di:*	fq:4	id:226384

émulsifiante/F*()	po:nom	po:adj	di:*	fq:4	id:181496
émulsifier/a2p+()	po:v1__t___zz	di:*	fq:4	id:181497
émulsine/S*()	po:nom	is:fem	di:*	fq:5	id:181499
émulsion/S*()	po:nom	is:fem	di:*	fq:6	id:181500
émulsionnable/S*()	po:adj	is:epi	se:chim	di:*	fq:4	id:226911
émulsionner/a2p+()	po:v1__t___zz	di:*	fq:5	id:181501
émulsive/F*()	po:adj	di:*	fq:4	id:181503

en/Q'Q*Qjn'd'j'l'm't's'c'	po:mg	po:properobj	po:preverb	po:proadv	se:@	et:lat	di:*	fq:9	id:183228
en/Q'Q*Qjd'	po:mg	po:prep	se:@	et:lat	di:*	fq:9	id:231711
ENA/L'D'Q'	po:nom	is:fem	is:inv	lx:sig	se:soc	se:édu	di:*	fq:5	id:229240
enamourer/a3p+()	po:v1____p_e_	se:affect	di:C	fq:4	id:219541
énamourer/a3p+()	po:v1____p_e_	di:*	fq:4	id:181510
énanthème/S*()	po:nom	is:mas	di:*	fq:4	id:181512
énantiomère/S*()	po:nom	is:mas	di:*	fq:4	id:214581
énantiomérie/S*()	po:nom	is:fem	di:*	fq:2	id:216323
énantiomorphe/S*()	po:adj	is:epi	di:*	fq:4	id:181513

entraînante/F*()	po:adj	di:M	fq:6	id:144676
entrainement/S*()	po:nom	is:mas	di:R	fq:5	id:144665
entraînement/S*()	po:nom	is:mas	di:M	fq:7	id:144677
entrainer/a4p+()	po:v1__t_q__a	di:R	fq:6	id:144666
entraîner/a4p+()	po:v1__t_q__a	di:M	fq:8	id:144678
entraineuse/F*()	po:nom	di:R	fq:5	id:144667
entraîneuse/F*()	po:nom	di:M	fq:6	id:144679
entrait/S*()	po:nom	is:mas	se:bât	di:*	fq:5	id:211147
entrante/F*()	po:nom	po:adj	di:*	fq:6	id:144669
entrapercevoir/pK()	po:v3__t_q__a	di:*	fq:4	id:144670
entr’apercevoir/pK()	po:v3__t_q__a	lx:dic	di:C	fq:0	id:144648
entrave/S*()	po:nom	is:fem	di:*	fq:6	id:144672
entraver/a2p+()	po:v1__t___zz	di:*	fq:7	id:144673
entravon/S*()	po:nom	is:mas	di:*	fq:3	id:216840
entraxe/S*()	po:nom	is:mas	se:techni	di:*	fq:4	id:218486

épilatoire/S*()	po:nom	is:mas	di:*	fq:4	id:212552
épilatoire/S*()	po:adj	is:epi	di:*	fq:4	id:181706
épilatrice/F*()	po:nom	di:*	fq:3	id:205811
épilepsie/S*()	po:nom	is:fem	di:*	fq:6	id:181707
épileptiforme/S*()	po:adj	is:epi	di:*	fq:5	id:181708
épileptique/S*()	po:nom	is:epi	di:*	fq:6	id:181709
épileptiquement/L'D'Q'	po:adv	lx:rare	di:*	fq:3	id:224612
épileptogène/S*()	po:adj	is:epi	se:méd	di:*	id:233113
épileptologue/S*()	po:nom	is:epi	se:méd	di:*	fq:3	id:223326
épiler/a4p+()	po:v1__t_q_zz	di:*	fq:5	id:181710
épileuse/F*()	po:nom	di:*	fq:3	id:218497
épillet/S*()	po:nom	is:mas	di:*	fq:5	id:181711
épilobe/S*()	po:nom	is:mas	se:bot	di:*	fq:4	id:181712
épilogue/S*()	po:nom	is:mas	di:*	fq:5	id:181713
épiloguer/a4p+()	po:v1__tn__zz	di:*	fq:5	id:181714

épinier/S*()	po:nom	is:mas	lx:rare	di:*	fq:3	id:206299
épinière/S*()	po:adj	is:fem	di:*	fq:6	id:181737
épinoche/S*()	po:nom	is:fem	di:*	fq:4	id:181738
épinochette/S*()	po:nom	is:fem	di:*	fq:3	id:181739
épipélagique/S*()	po:adj	is:epi	se:océan	et:grec	et:lat	di:*	fq:3	id:225974
épiphane/S*()	po:adj	is:epi	lx:vx	di:*	fq:3	id:181741
épiphanie/S*()	po:nom	is:fem	di:*	fq:5	id:181742
épiphanique/S*()	po:adj	is:epi	et:grec	di:*	id:233112
épiphénoménale/W*()	po:adj	lx:rare	se:philo	di:*	fq:4	id:229267
épiphénomène/S*()	po:nom	is:mas	di:*	fq:5	id:181746
épiphénoménisme/S*()	po:nom	is:mas	di:*	fq:4	id:181747
épiphénoméniste/S*()	po:nom	is:epi	di:*	fq:4	id:181748
épiphonème/S*()	po:nom	is:mas	se:lingu	et:grec	di:*	fq:4	id:226570
épiphylle/S*()	po:adj	is:epi	se:bot	di:*	fq:4	id:219322
épiphysaire/S*()	po:adj	is:epi	di:*	fq:5	id:215717

extraparlementaire/S*()	po:adj	is:epi	di:*	fq:5	id:145766
extra-parlementaire/S*()	po:adj	is:epi	di:C	fq:3	id:145733
extrapolable/S*()	po:adj	is:epi	di:*	fq:4	id:215935
extrapolation/S*()	po:nom	is:fem	di:*	fq:6	id:145767
extrapoler/a2p+()	po:v1_it___zz	di:*	fq:6	id:145768
extraprofessionnelle/F*()	po:adj	lx:néo	di:*	fq:4	id:215932
extra-professionnelle/F*()	po:adj	lx:néo	di:C	fq:2	id:215933
extrarégionale/W*()	po:adj	di:*	id:233101
extrarénale/W*()	po:adj	di:*	fq:4	id:211611
extrascolaire/S*()	po:adj	is:epi	di:*	fq:5	id:205917
extra-scolaire/S*()	po:adj	is:epi	di:C	fq:3	id:205916
extrasensible/S*()	po:adj	is:epi	di:*	fq:3	id:145770
extra-sensible/S*()	po:adj	is:epi	di:C	fq:1	id:145734
extrasensorielle/F*()	po:adj	di:*	fq:4	id:145771
extra-sensorielle/F*()	po:adj	di:C	fq:2	id:145735

extremis	po:loc.adv	di:M	fq:6	id:145783
extrémis	po:loc.adv	di:R	fq:4	id:145794
extrémiser/a4p+()	po:v1__t_q_zz	di:*	fq:3	id:223975
extrémisme/S*()	po:nom	is:mas	di:*	fq:5	id:145795
extrémiste/S*()	po:nom	po:adj	is:epi	di:*	fq:6	id:145796
extrémité/S*()	po:nom	is:fem	di:*	fq:7	id:145797
extrémophile/S*()	po:nom	po:adj	is:epi	lx:néo	se:bio	di:*	fq:2	id:228806

extremum/L'D'Q'	po:nom	is:mas	is:inv	et:lat	di:C	fq:4	id:145785
extremum/I*()	po:nom	is:mas	et:lat	di:M	fq:5	id:145784
extrémum/S*()	po:nom	is:mas	et:lat	di:R	fq:4	id:145798
extrinsécisme/S*()	po:nom	is:mas	se:philo	di:*	fq:4	id:221023
extrinsèque/S*()	po:adj	is:epi	di:*	fq:6	id:145786
extrinsèquement/D'Q'	po:adv	di:*	fq:4	id:145787
extrorse/S*()	po:adj	is:epi	di:*	fq:4	id:145788
extroversion/S*()	po:nom	is:fem	lx:alt	lx:fxa	se:psycho	se:anat	se:méd	di:*	fq:4	id:217712
extrovertie/F*()	po:nom	po:adj	di:*	fq:4	id:145789

fana/S.()	po:nom	po:adj	is:epi	lx:abr	di:*	fq:5	id:232638
fanage/S.()	po:nom	is:mas	di:*	fq:5	id:146021
fanaison/S.()	po:nom	is:fem	di:*	fq:4	id:209108
fanal/X.()	po:nom	is:mas	di:*	fq:6	id:146022
fanatique/S.()	po:nom	po:adj	is:epi	se:reli	di:*	fq:6	id:146023
fanatiquement	po:adv	se:reli	di:*	fq:5	id:146024
fanatisante/F.()	po:adj	di:*	fq:3	id:146025
fanatisation/S.()	po:nom	is:fem	se:reli	se:polit	di:*	id:233104
fanatiser/a0p+()	po:v1__t_q_zz	di:*	fq:5	id:146026
fanatiseuse/F.()	po:nom	lx:rare	lx:vx	di:A	fq:3	id:146027
fanatisme/S.()	po:nom	is:mas	se:reli	di:*	fq:6	id:146028
fanchon/S.()	po:nom	is:fem	lx:vx	lx:rég	di:*	fq:4	id:223895
fanclub/S.()	po:nom	is:mas	et:angl	di:R	fq:3	id:210710
fan-club/S.()	po:nom	is:mas	et:angl	di:M	fq:3	id:210709
fancyfair/S.()	po:nom	is:fem	lx:belg	et:angl	di:R	fq:0	id:207064

fignoleuse/F.()	po:nom	po:adj	lx:fam	di:*	fq:3	id:146532
figue/S.()	po:nom	is:fem	di:*	fq:6	id:146534
figueraie/S.()	po:nom	is:fem	se:sylvi	di:*	fq:3	id:218381
figuerie/S.()	po:nom	is:fem	di:*	fq:3	id:146535
figuier/S.()	po:nom	is:mas	di:*	fq:6	id:146536
figuline/S.()	po:nom	is:fem	di:*	fq:4	id:146537
figurable/S.()	po:adj	is:epi	se:philo	di:*	fq:4	id:220669
figurale/W.()	po:adj	di:*	id:233125
figuralisme/S.()	po:nom	is:mas	se:mus	di:*	fq:4	id:227727
figurante/F.()	po:nom	di:*	fq:6	id:146538
figuration/S.()	po:nom	is:fem	di:*	fq:6	id:146539
figurative/F.()	po:nom	po:adj	di:*	fq:6	id:146540
figurativement	po:adv	di:*	fq:4	id:146541
figure/S.()	po:nom	is:fem	di:*	fq:8	id:146542
figurément	po:adv	di:*	fq:5	id:146548

floréal/S.()	po:nom	is:mas	di:*	fq:6	id:146874
florence/S.()	po:nom	is:epi	di:*	fq:4	id:146865
Florence	po:prn	is:fem	is:inv	di:*	fq:7	id:124068
Florence	po:npr	is:epi	is:inv	se:cité	di:*	fq:7	id:213462
florencée/F.()	po:adj	lx:rare	di:*	fq:3	id:206319
Florennes	po:npr	is:epi	is:inv	se:cité	di:*	fq:5	id:230862
Florent	po:prn	is:mas	is:inv	di:*	fq:6	id:124069
Florentin	po:prn	is:mas	is:inv	di:*	fq:5	id:124070
Florentin	po:npr	is:epi	is:inv	se:cité	di:X	fq:5	id:227758
Florentin	po:patr	is:epi	is:inv	di:X	fq:5	id:227759
florentine/F.()	po:nom	po:adj	se:gent	di:*	fq:6	id:146866
Florentine	po:prn	is:fem	is:inv	di:*	fq:5	id:224882
florès	po:loc.verb	lx:vx	di:*	fq:5	id:146873
Florestan	po:prn	is:mas	is:inv	di:X	fq:5	id:226952
Florian	po:prn	is:mas	is:inv	di:*	fq:6	id:201627
Floriane	po:prn	is:fem	is:inv	di:*	fq:4	id:201699
floribondité/S.()	po:nom	is:fem	se:biz	se:bot	di:*	fq:4	id:218061

foutage/S.()	po:nom	is:mas	lx:fam	lx:néo	di:*	fq:3	id:217483
foutaise/S.()	po:nom	is:fem	lx:fam	di:*	fq:4	id:147332
fouteuse/F.()	po:nom	lx:fam	di:*	fq:4	id:209660
foutoir/S.()	po:nom	is:mas	di:*	fq:4	id:147335
foutou/S.()	po:nom	is:mas	se:cuis	di:*	fq:4	id:230234
foutrale/F.()	po:adj	lx:fam	di:*	fq:1	id:147336
foutraque/S.()	po:nom	po:adj	is:epi	lx:fam	lx:rég	di:*	fq:3	id:147337

foutre/S.()	po:nom	is:mas	lx:fam	se:sexe	di:*	fq:4	id:147338
foutre/tM()	po:v3_it_q__a	lx:fam	di:*	fq:6	id:147339
foutredieu	po:interj	lx:fam	se:@	di:*	fq:2	id:213974
foutrement	po:adv	lx:fam	di:*	fq:4	id:147340
foutrerie/S.()	po:nom	is:fem	lx:fam	se:sexe	di:*	fq:3	id:231684
foutriquet/S.()	po:nom	is:mas	di:*	fq:4	id:147341
foutue/F.()	po:adj	lx:fam	di:*	fq:5	id:142573
fovéa/S.()	po:nom	is:fem	di:*	fq:4	id:147344
fovéale/W.()	po:adj	di:*	fq:4	id:213115

fuguer/a0p.()	po:v1_i____zz	di:*	fq:5	id:147771
fugueuse/F.()	po:nom	po:adj	di:*	fq:5	id:147772
führer/S.()	po:nom	is:mas	et:all	di:*	fq:3	id:148013
fuie/S.()	po:nom	is:fem	di:*	fq:5	id:223586
fuir/f0p+()	po:v2_it_x__a	di:*	fq:2	id:147774
fuir/iN()	po:v3_it_x__a	di:*	fq:7	id:147775
fuite/S.()	po:nom	is:fem	di:*	fq:7	id:147776
fuiter/a0p+()	po:v1_it____a	di:*	fq:3	id:147777
Fujian	po:nom	is:mas	is:inv	se:rég	di:*	fq:5	id:229405
Fujitsu	po:npr	is:epi	is:inv	se:soc	di:*	fq:4	id:222334
Fukuoka	po:npr	is:epi	is:inv	se:cité	di:*	fq:5	id:124113
Fukushima	po:npr	is:epi	is:inv	se:cité	di:*	fq:4	id:215403
Fulcanelli	po:prn	is:mas	is:inv	se:alch	se:hist	di:*	fq:4	id:213504
fulgurance/S.()	po:nom	is:fem	di:*	fq:5	id:147778
fulgurante/F.()	po:adj	di:*	fq:6	id:147779

garçonnet/S.()	po:nom	is:mas	di:*	fq:5	id:148392
garçonnière/F.()	po:nom	po:adj	di:*	fq:5	id:148393
Gard	po:nom	is:mas	is:inv	se:riv	se:rég	di:*	fq:6	id:124141
Gardanne	po:npr	is:epi	is:inv	se:cité	di:*	fq:5	id:229889
garde/S.()	po:nom	is:epi	di:*	fq:7	id:148270
Garde	po:nom	is:fem	is:sg	se:cité	di:*	fq:7	id:124142
garde-à-vous	po:nom	is:mas	is:inv	di:*	fq:0	id:148325

garde-barrière	po:nom	is:epi	is:sg	di:M	fq:3	id:148272
garde-barrière/S.()	po:nom	is:epi	di:R	fq:2	id:148271
garde-bœuf/S.()	po:nom	is:mas	di:R	fq:2	id:148277
garde-bœufs	po:nom	is:mas	is:inv	di:M	fq:3	id:148278
garde-boue	po:nom	is:mas	is:inv	di:M	fq:2	id:148274
garde-boue/S.()	po:nom	is:mas	di:R	fq:2	id:148273
garde-but	po:nom	is:epi	is:sg	di:M	fq:1	id:148276
garde-but/S.()	po:nom	is:epi	di:R	fq:0	id:148275
garde-cendre	po:nom	is:mas	is:inv	di:M	fq:1	id:148280

garde-frontière	po:nom	is:epi	is:sg	se:milit	di:*	fq:2	id:219209
garde-magasin	po:nom	is:epi	is:sg	di:M	fq:2	id:148297
garde-magasin/S.()	po:nom	is:epi	di:R	fq:2	id:148296
garde-malade/S.()	po:nom	is:epi	di:R	fq:3	id:148300
garde-malade	po:nom	is:epi	is:sg	di:M	fq:3	id:148301
garde-manège/S.()	po:nom	is:mas	di:R	fq:0	id:148304
garde-manège	po:nom	is:mas	is:sg	di:M	fq:0	id:148305

garde-manger	po:nom	is:mas	is:inv	di:M	fq:3	id:148303
garde-manger/S.()	po:nom	is:mas	di:R	fq:2	id:148302
garde-meuble/S.()	po:nom	is:mas	di:R	fq:3	id:148306
garde-meubles	po:nom	is:mas	is:inv	di:M	fq:2	id:148307
garde-mite/S.()	po:nom	is:mas	di:R	fq:0	id:148308
garde-mites	po:nom	is:mas	is:inv	di:M	fq:1	id:148309
gardénal/S.()	po:nom	is:mas	lx:dép	di:*	fq:4	id:148354
garde-nappe/S.()	po:nom	is:mas	di:R	fq:0	id:148310
garde-nappe	po:nom	is:mas	is:inv	di:M	fq:1	id:148311

gélinotte/S.()	po:nom	is:fem	di:*	fq:4	id:149904
gélisol/S.()	po:nom	is:mas	di:*	fq:3	id:206827
géliturbation/S.()	po:nom	is:fem	lx:rare	di:*	fq:3	id:215227
gélive/F.()	po:adj	di:*	fq:5	id:149905
gélivité/S.()	po:nom	is:fem	di:*	fq:4	id:216117
gélivure/S.()	po:nom	is:fem	di:*	fq:4	id:149906
gélose/S.()	po:nom	is:fem	di:*	fq:6	id:149907
gélosée/F.()	po:adj	se:bio	di:*	id:233096
Gelsenkirchen	po:npr	is:epi	is:inv	se:cité	di:*	fq:5	id:213739
gélule/S.()	po:nom	is:fem	se:pharma	di:*	fq:5	id:149908
gelure/S.()	po:nom	is:fem	di:*	fq:5	id:148525
Gembloux	po:npr	is:epi	is:inv	se:cité	di:*	fq:6	id:200681
gémeau/X.()	po:nom	is:mas	di:*	fq:4	id:149909
gémellaire/S.()	po:adj	is:epi	di:*	fq:5	id:149910
gémelle/S.()	po:nom	is:fem	di:*	fq:1	id:149911

géographiquement	po:adv	di:*	fq:6	id:149983
géohistoire/S.()	po:nom	is:fem	lx:néo	se:hist	se:géogr	et:grec	di:*	fq:4	id:226491
géohistorienne/F.()	po:nom	lx:néo	se:hist	se:géogr	et:grec	di:*	fq:1	id:226492
géoïde/S.()	po:nom	is:mas	di:*	fq:5	id:150015
géo-ingénierie/S.()	po:nom	is:fem	lx:néo	di:*	fq:2	id:217785
geôlage/S.()	po:nom	is:mas	lx:vx	di:*	fq:4	id:201502
geôle/S.()	po:nom	is:fem	di:*	fq:6	id:148629
géolecte/S.()	po:nom	is:mas	se:lingu	di:*	id:233135
geôlière/F.()	po:nom	di:*	fq:6	id:148630
géolocalisation/S.()	po:nom	is:fem	se:géol	di:*	fq:5	id:201632
géolocaliser/a0p+()	po:v1__t_q_zz	se:géol	di:*	fq:4	id:202146
géologie/S.()	po:nom	is:fem	se:géol	di:*	fq:6	id:149984
géologique/S.()	po:adj	is:epi	se:géol	di:*	fq:7	id:149985
géologiquement	po:adv	se:géol	di:*	fq:5	id:149986
géologue/S.()	po:nom	is:epi	se:géol	di:*	fq:6	id:149987

gesticulée/F.()	po:adj	di:*	fq:4	id:148623
gesticuler/a0p.()	po:v1_i____zz	di:*	fq:6	id:148622
gestion/S.()	po:nom	is:fem	se:admin	di:*	fq:7	id:148624
gestionnaire/S.()	po:nom	po:adj	is:epi	di:*	fq:6	id:148625
gestique/S.()	po:nom	is:fem	lx:néo	di:*	fq:4	id:218630
gestuaire/S.()	po:nom	is:epi	di:*	fq:3	id:222627
gestualité/S.()	po:nom	is:fem	di:*	fq:5	id:218062

gestuelle/F.()	po:adj	di:*	fq:5	id:148626
gestuelle/S.()	po:nom	is:fem	di:*	fq:5	id:232799
getter/S.()	po:nom	is:mas	di:*	fq:4	id:148627
Gévaudan	po:nom	is:mas	is:inv	se:rég	se:hist	di:*	fq:5	id:212648
GEVES	po:npr	is:mas	is:inv	lx:sig	se:soc	se:agri	di:X	fq:3	id:228033
Gevrey-Chambertin	po:npr	is:epi	is:inv	se:cité	di:*	fq:3	id:124174
gewurztraminer/S.()	po:nom	is:mas	et:all	di:*	fq:4	id:213016
Gex	po:npr	is:epi	is:inv	se:cité	di:X	fq:6	id:227525
geyser/S.()	po:nom	is:mas	di:*	fq:5	id:148628

gousset/S.()	po:nom	is:mas	di:*	fq:5	id:149130
gout/S.()	po:nom	is:mas	di:R	fq:5	id:149131
goût/S.()	po:nom	is:mas	di:M	fq:7	id:149169
gouter/S.()	po:nom	is:mas	di:R	fq:1	id:149133
gouter/a0p+()	po:v1_itn__zz	di:R	fq:5	id:149134
goûter/a0p+()	po:v1_itn__zz	di:M	fq:7	id:149172
goûter/S.()	po:nom	is:mas	di:M	fq:5	id:149171

gouteuse/W.()	po:adj	di:R	fq:4	id:149135
gouteuse/F.()	po:nom	di:R	fq:2	id:149136
goûteuse/F.()	po:nom	di:M	fq:4	id:149174
goûteuse/W.()	po:adj	di:M	fq:4	id:149173
goute-vin/S.()	po:nom	is:mas	di:R	fq:0	id:149132
goûte-vin	po:nom	is:mas	is:inv	di:M	fq:0	id:149170
goutte/S.()	po:nom	is:fem	di:*	fq:7	id:149137
goutte-à-goutte	po:nom	is:mas	is:inv	di:*	fq:2	id:149138
gouttelette/S.()	po:nom	is:fem	di:*	fq:6	id:149139

gouzis-gouzis	po:nom	is:mas	is:pl	di:M	fq:0	id:149158
goy/S.()	po:nom	po:adj	is:epi	et:héb	di:*	fq:4	id:149159
Goya	po:patr	is:epi	is:inv	di:*	fq:6	id:205263
goyave/S.()	po:nom	is:fem	et:esp	di:*	fq:5	id:149161
goyavier/S.()	po:nom	is:mas	et:esp	di:*	fq:5	id:149162
goyim	po:nom	po:adj	is:epi	is:pl	lx:dic	et:héb	di:C	fq:4	id:149163
GPA	po:nom	is:fem	is:inv	lx:sig	se:bio	se:biz	di:*	fq:4	id:229330

GPL	po:nom	is:mas	is:inv	lx:sig	di:*	fq:5	id:210984
GPL	po:nom	is:fem	is:inv	lx:sig	di:X	fq:5	id:227339
GPS	po:nom	is:mas	is:inv	lx:sig	et:angl	di:*	fq:5	id:124121
gr/||--	po:nom	is:mas	is:inv	lx:symb	di:*	fq:7	id:201149
Graal	po:nom	is:mas	is:sg	di:*	fq:6	id:124209
grabat/S.()	po:nom	is:mas	di:*	fq:5	id:149176
grabataire/S.()	po:nom	po:adj	is:epi	di:*	fq:5	id:149177
grabatisation/S.()	po:nom	is:fem	di:*	fq:3	id:205633
graben/S.()	po:nom	is:mas	et:all	di:*	fq:5	id:149178

granulation/S.()	po:nom	is:fem	di:*	fq:6	id:149296
granule/S.()	po:nom	is:mas	di:*	fq:6	id:149297
granulé/S.()	po:nom	is:mas	di:*	fq:5	id:214345
granuler/a0p+()	po:v1__t___zz	di:*	fq:5	id:149298
granuleuse/W.()	po:adj	di:*	fq:6	id:149299
granulie/S.()	po:nom	is:fem	di:*	fq:5	id:149300
granulite/S.()	po:nom	is:fem	di:*	fq:5	id:149301
granulocytaire/S.()	po:adj	is:epi	se:bio	di:*	id:233163
granulocyte/S.()	po:nom	is:mas	di:*	fq:5	id:149302
granulomatose/S.()	po:nom	is:fem	di:*	fq:4	id:149303
granulome/S.()	po:nom	is:mas	di:*	fq:5	id:149304
granulométrie/S.()	po:nom	is:fem	di:*	fq:5	id:149305
granulométrique/S.()	po:adj	is:epi	di:*	fq:5	id:210885
Granville	po:npr	is:epi	is:inv	se:cité	di:*	fq:6	id:229896
grapefruit/S.()	po:nom	is:mas	et:angl	di:*	fq:4	id:149308

greffeuse/F.()	po:nom	di:*	fq:4	id:149411
greffière/F.()	po:nom	di:*	fq:7	id:149412
greffoir/S.()	po:nom	is:mas	di:*	fq:4	id:149413
greffon/S.()	po:nom	is:mas	di:*	fq:6	id:149414
Greg	po:prn	is:mas	is:inv	di:*	fq:5	id:221681
grégaire/S.()	po:nom	po:adj	is:epi	di:*	fq:5	id:149672
grégarisme/S.()	po:nom	is:mas	di:*	fq:4	id:149673
grégarité/S.()	po:nom	is:fem	se:socio	di:*	id:233116
grège/S.()	po:adj	is:epi	di:*	fq:5	id:149658
grégeois	po:adj	is:mas	is:inv	di:*	fq:5	id:149674
Grégoire	po:prn	is:mas	is:inv	di:*	fq:7	id:124230
Gregor	po:prn	is:mas	is:inv	di:*	fq:5	id:222420
grégorienne/F.()	po:adj	di:*	fq:6	id:149675
Gregory	po:prn	is:mas	is:inv	di:*	fq:6	id:221682
Grégory	po:prn	is:mas	is:inv	di:*	fq:5	id:201831

hâblerie/S.()	po:nom	is:fem	lx:pel	di:*	fq:5	id:151320
hâbleuse/F.()	po:nom	po:adj	lx:pel	di:*	fq:5	id:151321
Habsbourg	po:patr	is:epi	is:inv	di:*	fq:6	id:212568
habsbourgeoise/F*()	po:adj	se:hist	di:*	fq:5	id:230754
hach/S.()	po:nom	is:mas	lx:abr	lx:fam	lx:pel	et:ara	di:R	fq:3	id:150078
hachage/S.()	po:nom	is:mas	lx:pel	di:*	fq:5	id:150079
hache/S.()	po:nom	is:fem	lx:pel	di:*	fq:6	id:150080

hache-fourrage	po:nom	is:mas	is:inv	di:M	fq:1	id:150082
hache-fourrage/S.()	po:nom	is:mas	lx:pel	di:R	fq:0	id:150081
hache-légume/S.()	po:nom	is:mas	lx:pel	di:R	fq:0	id:150083
hache-légumes	po:nom	is:mas	is:inv	di:M	fq:1	id:150084
hachement/S.()	po:nom	is:mas	lx:pel	di:*	fq:3	id:150089
hachémite/S.()	po:nom	po:adj	is:epi	lx:pel	di:*	fq:5	id:150104

hache-paille	po:nom	is:mas	is:inv	se:agri	di:M	fq:2	id:150086
hache-paille/S.()	po:nom	is:mas	lx:pel	se:agri	di:R	fq:1	id:150085
hacher/a0p+()	po:v1__t___zz	di:*	fq:6	id:150090
hachereau/X.()	po:nom	is:mas	lx:pel	di:*	fq:4	id:150091
hachette/S.()	po:nom	is:fem	lx:pel	di:*	fq:5	id:150092
Hachette/L'D'Q'	po:patr	is:epi	is:inv	se:soc	se:litt	di:*	fq:6	id:230419
hacheuse/F.()	po:nom	lx:pel	di:*	fq:4	id:150093
hache-viande	po:nom	is:mas	is:inv	di:M	fq:1	id:150088
hache-viande/S.()	po:nom	is:mas	lx:pel	di:R	fq:0	id:150087

haptonomique/S*()	po:adj	is:epi	lx:néo	se:psycho	di:*	fq:3	id:222391
haquebute/S.()	po:nom	is:fem	lx:pel	di:*	fq:3	id:150225
haquenée/S.()	po:nom	is:fem	lx:pel	di:*	fq:5	id:150226
haquet/S.()	po:nom	is:mas	lx:pel	di:*	fq:4	id:150227
harakiri/S.()	po:nom	is:mas	lx:pel	et:jap	di:R	fq:4	id:150229
hara-kiri/S.()	po:nom	is:mas	lx:pel	et:jap	di:M	fq:2	id:150228
Harald/L'D'Q'	po:prn	is:mas	is:inv	di:*	fq:5	id:231470

haram	po:adj	is:epi	is:inv	et:ara	di:M	fq:4	id:231679
haram/S.()	po:adj	is:epi	et:ara	di:R	fq:3	id:231680
harangue/S.()	po:nom	is:fem	lx:pel	di:*	fq:6	id:211649
haranguer/a0p+()	po:v1__t___zz	di:*	fq:6	id:150230
harangueuse/F.()	po:nom	lx:pel	di:*	fq:5	id:150231
Harare	po:npr	is:epi	is:inv	se:cité	di:*	fq:5	id:183406
haras	po:nom	is:mas	is:inv	di:*	fq:6	id:150233
harassante/F.()	po:adj	lx:pel	di:*	fq:5	id:150234
harassement/S.()	po:nom	is:mas	lx:pel	di:*	fq:4	id:150235

hépatocyte/S*()	po:nom	is:mas	di:*	fq:5	id:213521
hépatographie/S*()	po:nom	is:fem	di:*	fq:3	id:183336
hépatologie/S*()	po:nom	is:fem	di:*	fq:4	id:151470
hépatologue/S*()	po:nom	is:epi	di:*	fq:3	id:201998
hépatome/S*()	po:nom	is:mas	se:méd	et:grec	di:*	fq:4	id:226271
hépatomégalie/S*()	po:nom	is:fem	di:*	fq:5	id:151471
hépatonéphrite/S*()	po:nom	is:fem	se:méd	di:*	fq:3	id:226268
hépatotoxicité/S*()	po:nom	is:fem	se:méd	di:*	id:233121
hépatotoxique/S*()	po:adj	is:epi	se:méd	di:*	fq:4	id:226014
Héphaïstos/L'D'Q'	po:prn	is:mas	is:inv	se:myth	di:*	fq:4	id:124366
hépiale/S*()	po:nom	is:mas	se:zool	di:*	fq:3	id:226816
heptacorde/S*()	po:adj	is:epi	se:mus	et:grec	di:*	fq:4	id:220829
heptaèdre/S*()	po:nom	is:mas	se:math	et:grec	di:*	fq:3	id:150442
heptagonale/W*()	po:adj	di:*	fq:4	id:150439
heptagone/S*()	po:nom	is:mas	di:*	fq:4	id:150440

herbage/S*()	po:nom	is:mas	di:*	fq:6	id:150444
herbagement/S*()	po:nom	is:mas	se:agri	di:*	fq:0	id:220493
herbager/a2p+()	po:v1__t___zz	di:*	fq:3	id:150445
herbagère/F*()	po:nom	po:adj	se:agri	di:*	fq:5	id:150446
herbe/S*()	po:nom	is:fem	di:*	fq:7	id:150448
herber/a2p+()	po:v1__t___zz	di:*	fq:5	id:150449
herberie/S*()	po:nom	is:fem	di:*	fq:3	id:150450

Herbert/L'D'Q'	po:prn	is:mas	is:inv	di:*	fq:6	id:124310
Herbert	po:patr	is:epi	is:inv	se:litt	di:X	fq:6	id:227120
herbette/S*()	po:nom	is:fem	di:*	fq:4	id:150451
herbeuse/W*()	po:adj	di:*	fq:5	id:150452
herbicide/S*()	po:nom	is:mas	di:*	fq:6	id:150453
herbier/S*()	po:nom	is:mas	di:*	fq:6	id:150454
herbivore/S*()	po:nom	is:mas	se:zool	di:*	fq:6	id:150455
Herblay/L'D'Q'	po:npr	is:epi	is:inv	se:cité	di:*	fq:5	id:124311
herborisation/S*()	po:nom	is:fem	di:*	fq:5	id:150456

Hespéride/S*()	po:nom	is:fem	di:*	fq:5	id:124319
Hess	po:patr	is:epi	is:inv	di:X	fq:6	id:226989
Hesse	po:nom	is:fem	is:inv	se:rég	di:*	fq:6	id:124320
Hessel	po:patr	is:epi	is:inv	di:X	fq:5	id:226990
Hessenberg	po:patr	is:epi	is:inv	di:*	fq:3	id:124321
hessienne/F.()	po:nom	po:adj	lx:pel	di:*	fq:4	id:150499
Hestia/L'D'Q'	po:prn	is:fem	is:inv	se:myth	di:*	fq:5	id:201405
hétaïre/S*()	po:nom	is:fem	se:sexe	et:grec	di:*	fq:5	id:151508
hétairie/S*()	po:nom	is:fem	et:grec	di:*	fq:4	id:151507
hétéro/S*()	po:nom	po:adj	is:epi	lx:abr	lx:fam	di:*	fq:5	id:206054
hétérocentrique/S*()	po:adj	is:epi	di:*	fq:3	id:151509
hétérocère/S*()	po:nom	is:mas	se:zool	et:grec	di:*	fq:3	id:228258
hétérocerque/S*()	po:adj	is:epi	di:*	fq:4	id:151510
hétérochromatine/S*()	po:nom	is:fem	se:bioch	di:*	fq:4	id:219067
hétérochrome/S*()	po:adj	is:epi	se:méd	et:grec	di:*	fq:4	id:226091

holdup/S.()	po:nom	is:mas	lx:pel	et:angl	di:R	fq:4	id:150664
hold-up	po:nom	is:mas	is:inv	et:angl	di:M	fq:3	id:150662
holisme/S*()	po:nom	is:mas	di:*	fq:5	id:183347
holiste/S*()	po:nom	po:adj	is:epi	di:*	fq:5	id:183345
holistique/S*()	po:adj	is:epi	di:*	fq:5	id:183346
hollandaise/F.()	po:nom	po:adj	lx:pel	se:gent	di:*	fq:7	id:150665
hollande/S.()	po:nom	is:epi	lx:pel	di:*	fq:5	id:150666

Hollande	po:nom	is:fem	is:inv	se:pays	di:*	fq:7	id:124334
Hollande/L'D'Q'	po:patr	is:epi	is:inv	se:polit	di:*	fq:7	id:226955
Holly/L'D'Q'	po:prn	is:fem	is:inv	di:*	fq:5	id:222700
Hollywood	po:npr	is:epi	is:inv	se:cité	di:*	fq:6	id:205213
hollywoodienne/F.()	po:adj	lx:pel	di:*	fq:5	id:150667
Holmes	po:patr	is:epi	is:inv	se:crime	se:myth	di:*	fq:6	id:222957
holmium/S*()	po:nom	is:mas	di:*	fq:4	id:150668
holocauste/S*()	po:nom	is:mas	di:*	fq:6	id:150669
holocène/S*()	po:adj	is:epi	di:*	fq:5	id:150670

horripilation/S*()	po:nom	is:fem	di:*	fq:5	id:150830
horripiler/a2p+()	po:v1__t___zz	di:*	fq:5	id:150831
hors	po:mg	po:prep	se:@	di:*	fq:7	id:150833
hors	po:adv	lx:vx	di:*	fq:7	id:214656
horsaine/F.()	po:nom	po:adj	lx:rég	lx:pel	di:*	fq:4	id:203596
hors-bilan/S.()	po:nom	is:mas	lx:pel	di:R	fq:0	id:150834
hors-bilan	po:nom	is:mas	is:inv	di:M	fq:1	id:150835

hors-bord	po:nom	is:mas	is:inv	di:M	fq:2	id:150837
hors-bord/S.()	po:nom	is:mas	lx:pel	di:R	fq:2	id:150836
hors-champ	po:nom	is:mas	is:inv	di:M	fq:2	id:150839
hors-champ/S.()	po:nom	is:mas	lx:pel	di:R	fq:2	id:150838
hors-concours	po:adj	is:epi	is:inv	di:*	fq:3	id:150840
hors-cote	po:adj	is:epi	is:inv	di:M	fq:1	id:150842
hors-cote/S.()	po:nom	is:mas	lx:pel	di:R	fq:1	id:212077
hors-cote	po:nom	is:mas	is:inv	di:M	fq:1	id:212076
hors-cote/S.()	po:adj	is:epi	lx:pel	di:R	fq:1	id:150841
hors-d’œuvre	po:nom	is:mas	is:inv	di:*	fq:0	id:150843
horseball/S.()	po:nom	is:mas	lx:pel	se:sport	et:angl	di:*	fq:1	id:208965
horse-ball/S.()	po:nom	is:mas	lx:pel	se:sport	et:angl	di:C	fq:2	id:208964
horseguard/S.()	po:nom	is:mas	lx:pel	et:angl	di:R	fq:3	id:207106
horse-guard/S.()	po:nom	is:mas	lx:pel	et:angl	di:M	fq:2	id:150862
horsepower/S.()	po:nom	is:mas	lx:pel	et:angl	di:R	fq:3	id:222406
horse-power	po:nom	is:mas	is:inv	et:angl	di:M	fq:1	id:150863
horsepox	po:nom	is:mas	is:inv	et:angl	di:R	fq:4	id:207107
horse-pox	po:nom	is:mas	is:inv	et:angl	di:M	fq:1	id:150864

hors-jeu	po:nom	is:mas	is:inv	di:M	fq:3	id:150845
hors-jeu/X.()	po:nom	is:mas	lx:pel	di:R	fq:2	id:150844
hors-la-loi	po:nom	is:epi	is:inv	di:*	fq:1	id:150846
hors-ligne	po:nom	is:mas	is:inv	di:M	fq:3	id:150848
hors-ligne/S.()	po:nom	is:mas	lx:pel	di:R	fq:1	id:150847

hors-média	po:nom	is:mas	is:inv	di:M	fq:1	id:150850
hors-média/S.()	po:nom	is:mas	lx:pel	di:R	fq:1	id:150849
hors-piste	po:nom	is:mas	is:inv	di:M	fq:2	id:150852
hors-piste/S.()	po:nom	is:mas	lx:pel	di:R	fq:2	id:150851
hors-série/S.()	po:adj	is:epi	lx:pel	di:R	fq:3	id:150857

hors-série/S.()	po:nom	is:mas	lx:pel	di:*	fq:3	id:212078
hors-série	po:nom	is:mas	is:inv	lx:pel	di:*	fq:3	id:212079
hors-série	po:adj	is:epi	is:inv	lx:pel	di:M	fq:3	id:206623
hors-sol/S.()	po:adj	is:epi	lx:pel	se:agri	di:R	fq:2	id:228336
hors-sol	po:nom	is:mas	is:inv	lx:pel	di:M	fq:2	id:150854
hors-sol/S.()	po:nom	is:mas	lx:pel	di:R	fq:2	id:150853
hors-sol	po:adj	is:epi	is:inv	lx:pel	se:agri	di:M	fq:2	id:228335

hors-statut	po:nom	is:mas	is:inv	di:M	fq:1	id:150856
hors-statut/S.()	po:nom	is:mas	lx:pel	di:R	fq:0	id:150855
horst/S.()	po:nom	is:mas	lx:pel	et:all	di:*	fq:5	id:150865
hors-taxe	po:nom	is:mas	is:inv	di:M	fq:1	id:201179
hors-taxe/S.()	po:nom	is:mas	lx:pel	di:R	fq:2	id:150859

hors-texte	po:nom	is:mas	is:inv	di:M	fq:3	id:150861
hors-texte/S.()	po:nom	is:mas	lx:pel	di:R	fq:2	id:150860
Hortense/L'D'Q'	po:prn	is:fem	is:inv	di:*	fq:6	id:201933
hortensia/S*()	po:nom	is:mas	di:*	fq:5	id:150866
horticole/S*()	po:adj	is:epi	di:*	fq:6	id:150867
horticultrice/F*()	po:nom	di:*	fq:6	id:150868
horticulture/S*()	po:nom	is:fem	di:*	fq:6	id:150869
hortillonnage/S*()	po:nom	is:mas	di:*	fq:4	id:150870
Horton	po:patr	is:epi	is:inv	di:*	fq:5	id:222647

hypermétrope/S*()	po:nom	po:adj	is:epi	di:*	fq:5	id:151211
hypermétropie/S*()	po:nom	is:fem	di:*	fq:5	id:151212
hypermnésie/S*()	po:nom	is:fem	di:*	fq:4	id:151209
hypermnésique/S*()	po:nom	po:adj	is:epi	se:psycho	di:*	id:232945
hypermonde/S*()	po:nom	is:mas	lx:néo	di:*	fq:3	id:213602
hypernatrémie/S*()	po:nom	is:fem	di:*	fq:4	id:215995
hypernerveuse/W*()	po:adj	di:*	fq:4	id:151213

hypernova/L'D'Q'	po:nom	is:mas	is:sg	di:M	fq:2	id:211446
hypernova/S*()	po:nom	is:fem	di:R	fq:1	id:211448
hypernovæ/D'Q'	po:nom	is:fem	is:pl	di:M	fq:1	id:211447
hyperœstrogénie/S*()	po:nom	is:fem	se:méd	di:M	id:232998
hyper-œstrogénie/S*()	po:nom	is:fem	se:méd	di:C	id:232995
hypéron/S*()	po:nom	is:mas	se:phys	di:*	fq:4	id:151312
hyperonyme/S*()	po:nom	is:mas	di:*	fq:4	id:200268
hyperonymie/S*()	po:nom	is:fem	di:*	fq:4	id:200279
hyperonymique/S*()	po:adj	is:epi	lx:rare	di:*	fq:4	id:213111

iguane/S*()	po:nom	is:mas	se:zool	et:esp	di:*	fq:5	id:151684
iguanodon/S*()	po:nom	is:mas	di:*	fq:4	id:151685
igue/S*()	po:nom	is:fem	lx:rég	di:*	fq:4	id:151686
IHM/L'D'Q'	po:nom	is:fem	is:inv	lx:sig	se:ingé	di:*	fq:4	id:230297
II/--	po:nb	is:epi	is:pl	se:@	et:lat	di:*	fq:8	id:204052
IIᵈ	po:adj	is:mas	is:sg	lx:ord	et:lat	di:*	fq:0	id:232679
IIᵉ/--	po:adj	is:epi	is:sg	lx:ord	et:lat	di:*	fq:0	id:225866
IIᵈᵉ/--	po:adj	is:fem	is:sg	lx:ord	et:lat	di:*	fq:0	id:232677
IIⁿᵈ/--	po:adj	is:mas	is:sg	lx:ord	et:lat	di:*	fq:0	id:232676
IId	po:adj	is:mas	is:sg	lx:ord	et:lat	di:*	fq:3	id:232678
IIde/--	po:adj	is:fem	is:sg	lx:ord	et:lat	di:*	fq:3	id:204178
IIe/--	po:adj	is:epi	is:sg	lx:ord	et:lat	di:*	fq:6	id:124376
III/--	po:nb	is:epi	is:pl	se:@	et:lat	di:*	fq:8	id:204051
IIIᵉ/--	po:adj	is:epi	is:sg	lx:ord	et:lat	di:*	fq:0	id:225867
IIIe/--	po:adj	is:epi	is:sg	lx:ord	et:lat	di:*	fq:6	id:124375

immensément/D'Q'	po:adv	di:*	fq:5	id:151806
immensité/S*()	po:nom	is:fem	di:*	fq:6	id:151804
immensurable/S*()	po:adj	is:epi	di:*	fq:4	id:151805
immerger/a4p+()	po:v1__t_q_zz	di:*	fq:6	id:151807
imméritée/F*()	po:adj	di:*	fq:6	id:151874
immersion/S*()	po:nom	is:fem	di:*	fq:6	id:151809
immersive/F*()	po:adj	di:*	fq:4	id:151810
immesurable/S*()	po:adj	is:epi	di:*	id:233159
immettable/S*()	po:adj	is:epi	di:*	fq:3	id:151811
immeuble/S*()	po:nom	is:mas	di:*	fq:7	id:212099
immeuble/S*()	po:adj	is:epi	di:*	fq:7	id:151812
immigrante/F*()	po:nom	po:adj	di:*	fq:6	id:151813
immigration/S*()	po:nom	is:fem	di:*	fq:7	id:151814
immigrationnisme/S*()	po:nom	is:mas	se:polit	di:*	fq:3	id:230217
immigrationniste/S*()	po:adj	is:epi	se:polit	di:*	fq:3	id:230216

indésirable/S*()	po:adj	is:epi	di:*	fq:6	id:152622
indésirablement/D'Q'	po:adv	lx:rare	di:*	fq:0	id:215539
indésirée/F*()	po:adj	di:*	fq:4	id:215746
indésireuse/W*()	po:adj	lx:rare	di:*	fq:0	id:231099
indestructibilité/S*()	po:nom	is:fem	di:*	fq:5	id:152447
indestructible/S*()	po:adj	is:epi	di:*	fq:6	id:152448
indestructiblement/D'Q'	po:adv	di:*	fq:4	id:152449
indétachable/S*()	po:adj	is:epi	di:*	id:233160
indétectable/S*()	po:adj	is:epi	di:*	fq:4	id:152623
indéterminable/S*()	po:adj	is:epi	di:*	fq:5	id:152624
indétermination/S*()	po:nom	is:fem	di:*	fq:6	id:152625
indéterminée/F*()	po:adj	di:*	fq:7	id:152627
indéterminisme/S*()	po:nom	is:mas	di:*	fq:5	id:152626
indéterministe/S*()	po:nom	po:adj	is:epi	di:*	fq:4	id:215475
indétrônable/S*()	po:adj	is:epi	di:*	fq:4	id:152628

interdigitale/W*()	po:adj	di:*	fq:5	id:153284
interdimensionnelle/F*()	po:adj	se:sf	di:*	fq:3	id:226296
interdire/yD()	po:v3_it_q__a	di:*	fq:7	id:153285
interdisciplinaire/S*()	po:adj	is:epi	se:sc	di:*	fq:6	id:153286
interdisciplinarité/S*()	po:nom	is:fem	se:sc	di:*	fq:5	id:153287
interdit/S*()	po:nom	is:mas	di:*	fq:7	id:153288
interentreprises	po:adj	is:epi	is:inv	se:admin	di:*	fq:5	id:217585
interépidémique/S*()	po:adj	is:epi	se:méd	di:*	id:233141
intéressante/F*()	po:adj	di:*	fq:7	id:153563
intéressée/F*()	po:nom	di:*	fq:7	id:153566
intéressement/S*()	po:nom	is:mas	di:*	fq:6	id:153564
intéresser/a4p+()	po:v1_itnq__a	di:*	fq:8	id:153565
intérêt/S*()	po:nom	is:mas	di:*	fq:8	id:153577
interétatique/S*()	po:adj	is:epi	se:polit	di:*	fq:5	id:222975
inter-étatique/S*()	po:adj	is:epi	se:polit	di:C	fq:2	id:222976

interquartile/S*()	po:adj	is:epi	se:math	di:*	fq:4	id:218706
interraciale/W*()	po:adj	di:*	fq:5	id:153388
interrégionale/W*()	po:adj	di:*	fq:6	id:217125
interrègne/S*()	po:nom	is:mas	di:*	fq:5	id:153403
interrelation/S*()	po:nom	is:fem	di:*	fq:6	id:153389
interreliée/F*()	po:adj	di:*	fq:4	id:224836
interreligieuse/W*()	po:adj	se:reli	di:*	fq:5	id:224277
interréticulaire/S*()	po:adj	is:epi	se:cristal	di:*	id:233095
interro/S*()	po:nom	is:fem	lx:abr	lx:fam	di:*	fq:5	id:219479
interrogat/S*()	po:nom	is:mas	lx:vx	se:@	se:droit	di:*	fq:4	id:221853
interrogation/S*()	po:nom	is:fem	di:*	fq:7	id:153390
interrogative/F*()	po:nom	po:adj	di:*	fq:6	id:153391
interrogativement/D'Q'	po:adv	di:*	fq:4	id:153392
interrogatoire/S*()	po:nom	is:mas	di:*	fq:6	id:153393
interrogatrice/F*()	po:nom	po:adj	di:*	fq:5	id:153394

intransportable/S*()	po:adj	is:epi	di:*	fq:4	id:153500
intrant/S*()	po:nom	is:mas	se:techni	se:agri	di:*	fq:6	id:153501
intranucléaire/S*()	po:adj	is:epi	di:*	fq:4	id:153502
intraoculaire/S*()	po:adj	is:epi	di:*	fq:5	id:153504
intra-oculaire/S*()	po:adj	is:epi	di:C	fq:2	id:153476
intrapsychique/S*()	po:adj	is:epi	se:psycho	di:*	fq:5	id:225272
intrarachidienne/F*()	po:adj	se:anat	di:*	fq:4	id:219279
intrarégionale/W*()	po:adj	di:*	id:233102
intraspécifique/S*()	po:adj	is:epi	se:bio	di:*	fq:5	id:228619
intrathoracique/S*()	po:adj	is:epi	se:méd	di:*	fq:5	id:226742
intra-urbaine/F*()	po:adj	di:*	fq:2	id:232521
intra-utérine/F*()	po:adj	di:*	fq:3	id:205385
intravaginale/W*()	po:adj	se:sexe	di:*	fq:4	id:231122
intravasculaire/S*()	po:adj	is:epi	se:méd	di:*	fq:5	id:223010
intraveineuse/W*()	po:adj	se:méd	di:*	fq:5	id:153506

italo-autrichienne/F*()	po:nom	po:adj	di:*	fq:2	id:226343
italo-belge/S*()	po:nom	po:adj	is:epi	di:*	fq:2	id:226342
italo-espagnole/F*()	po:nom	po:adj	di:*	fq:2	id:226525
italo-éthiopienne/F*()	po:nom	po:adj	di:*	fq:3	id:226228
italo-française/F*()	po:nom	po:adj	di:*	fq:2	id:226341
italo-néerlandaise/F*()	po:nom	po:adj	di:*	fq:1	id:226340
italophone/S*()	po:nom	po:adj	is:epi	di:*	fq:4	id:200578
italo-turque/F*()	po:nom	po:adj	di:*	id:233156
item	po:adv	et:lat	di:*	fq:6	id:153942
item/S*()	po:nom	is:mas	et:lat	di:*	fq:6	id:153941
itérabilité/S*()	po:nom	is:fem	lx:rare	lx:néo	di:*	fq:4	id:215667
itérable/S*()	po:adj	is:epi	lx:néo	se:info	di:*	fq:4	id:223160
itérateur/S*()	po:nom	is:mas	se:info	di:*	fq:4	id:228200
itération/S*()	po:nom	is:fem	di:*	fq:5	id:153947
itérative/F*()	po:adj	di:*	fq:6	id:153948

jurée/F.()	po:nom	se:droit	di:*	fq:6	id:154381
jurement/S.()	po:nom	is:mas	di:*	fq:5	id:154367
jurer/a0p+()	po:v1_it_q_zz	di:*	fq:7	id:154368
jureur/S.()	po:nom	is:mas	di:*	fq:5	id:154369
Jürgen	po:prn	is:mas	is:inv	di:*	fq:5	id:221839
juridicisation/S.()	po:nom	is:fem	se:droit	di:*	fq:4	id:227621
juridicité/S.()	po:nom	is:fem	se:droit	di:*	fq:5	id:231498
juridico-politique/S.()	po:adj	is:epi	se:polit	se:droit	di:*	id:233166
juridiction/S.()	po:nom	is:fem	se:droit	di:*	fq:7	id:154370
juridictionnelle/F.()	po:adj	se:droit	di:*	fq:6	id:154371
juridique/S.()	po:adj	is:epi	se:droit	di:*	fq:7	id:154372
juridiquement	po:adv	se:droit	di:*	fq:6	id:154373
juridisme/S.()	po:nom	is:mas	se:droit	di:*	fq:5	id:154374
Jurieu	po:patr	is:epi	is:inv	di:*	fq:5	id:218155
jurisconsulte/S.()	po:nom	is:epi	se:droit	se:hist	di:*	fq:7	id:154375

Katowice	po:npr	is:epi	is:inv	se:cité	di:*	fq:5	id:213738
Katy	po:prn	is:fem	is:inv	di:*	fq:5	id:221763
Katznelson	po:patr	is:epi	is:inv	di:*	fq:4	id:124504
Kaunas	po:npr	is:epi	is:inv	se:cité	di:*	fq:5	id:214006
kava/S.()	po:nom	is:mas	lx:alt	di:*	fq:5	id:154488
kawa/S.()	po:nom	is:mas	di:*	fq:4	id:154489
Kawasaki	po:npr	is:epi	is:inv	se:cité	di:*	fq:5	id:206195

Kay	po:prn	is:fem	is:inv	di:*	fq:5	id:221888
Kay	po:patr	is:epi	is:inv	se:litt	di:X	fq:5	id:227118
kayac/S.()	po:nom	is:mas	lx:var	se:sport	et:étr	di:A	fq:3	id:154490
kayak/S.()	po:nom	is:mas	se:sport	et:étr	di:*	fq:5	id:154491
kayakiste/S.()	po:nom	is:epi	se:sport	et:étr	di:*	fq:4	id:201888
Kayl	po:npr	is:epi	is:inv	se:cité	di:*	fq:4	id:216263
Kayla	po:prn	is:fem	is:inv	di:*	fq:3	id:224210
Kaylee	po:prn	is:fem	is:inv	di:*	fq:3	id:221820
kazakhe/F.()	po:nom	po:adj	se:gent	di:*	fq:5	id:209780

kyste/S.()	po:nom	is:mas	di:*	fq:6	id:154644
kystique/S.()	po:adj	is:epi	di:*	fq:6	id:154645
kyu/S.()	po:nom	is:mas	se:sport	et:jap	di:*	fq:3	id:218741
kyudo/S.()	po:nom	is:mas	et:jap	di:*	fq:3	id:210198
Kyushu	po:npr	is:epi	is:inv	se:île	di:*	fq:4	id:206193
l	po:nom	is:mas	is:inv	di:*	fq:9	id:210964
l/U.||--	po:nom	is:mas	is:inv	lx:symb	di:*	fq:8	id:201034

l’	po:mg	po:det	is:epi	is:sg	se:@	di:*	fq:0	id:213380
l’	po:mg	po:properobj	po:preverb	is:epi	is:sg	se:@	di:*	fq:0	id:232446
L/U.||--	po:nom	is:mas	is:inv	lx:symb	di:*	fq:8	id:201035

la	po:mg	po:det	is:fem	is:sg	se:@	di:*	fq:9	id:154666
la	po:nom	is:mas	is:inv	di:*	fq:9	id:154665
la	po:mg	po:properobj	po:preverb	is:fem	is:sg	se:@	di:*	fq:9	id:225551
là	po:adv	di:*	fq:8	id:156140
Laakdal	po:npr	is:epi	is:inv	se:cité	di:*	fq:3	id:230904
Laarne	po:npr	is:epi	is:inv	se:cité	di:*	fq:3	id:230905
labadens	po:nom	is:mas	is:inv	lx:vx	lx:fam	di:*	fq:3	id:154667
labarum/S.()	po:nom	is:mas	di:*	fq:5	id:154668
là-bas	po:adv	se:@	di:*	fq:5	id:156141
Labastide	po:npr	is:epi	is:inv	se:cité	di:X	fq:5	id:228009

labialisation/S.()	po:nom	is:fem	di:*	fq:4	id:154676
labialiser/a0p+()	po:v1__t_q_zz	di:*	fq:4	id:154677
labiée/F.()	po:nom	po:adj	di:*	fq:5	id:154681
labile/S.()	po:adj	is:epi	di:*	fq:5	id:154678
labilité/S.()	po:nom	is:fem	di:*	fq:5	id:215961
labiodentale/W.()	po:adj	di:*	fq:3	id:154679
labiodentale/S.()	po:nom	is:fem	di:*	fq:3	id:203602

labio-dentale/S.()	po:nom	is:fem	di:C	fq:3	id:203601
labio-dentale/W.()	po:adj	di:C	fq:2	id:203600
labioplastie/S.()	po:nom	is:fem	lx:alt	se:chir	se:sexe	di:*	fq:1	id:231008
labio-vélaire/S.()	po:adj	is:epi	se:lingu	di:*	fq:3	id:223571
labium/S.()	po:nom	is:mas	et:lat	di:*	fq:4	id:154680
labo/S.()	po:nom	is:mas	lx:abr	lx:fam	di:*	fq:5	id:211397
laborante/F.()	po:nom	lx:rare	di:*	fq:4	id:203034
laborantine/F.()	po:nom	se:sc	di:*	fq:5	id:154682
laboratoire/S.()	po:nom	is:mas	se:sc	di:*	fq:7	id:154683

lave-mains	po:nom	is:mas	is:inv	di:M	fq:1	id:155100
lavement/S.()	po:nom	is:mas	di:*	fq:6	id:155105
lave-pont/S.()	po:nom	is:mas	di:R	fq:0	id:201574
lave-pont	po:nom	is:mas	is:inv	di:M	fq:1	id:201573
laver/a0p+()	po:v1__t_q_zz	di:*	fq:7	id:155106
Laveran	po:patr	is:epi	is:inv	di:X	fq:5	id:227246
laverie/S.()	po:nom	is:fem	di:*	fq:5	id:155107

lave-tête	po:nom	is:mas	is:inv	di:M	fq:1	id:155102
lave-tête/S.()	po:nom	is:mas	di:R	fq:0	id:155101
lavette/S.()	po:nom	is:fem	di:*	fq:4	id:155108
laveuse/F.()	po:nom	po:adj	di:*	fq:6	id:155109
lave-vaisselle/S.()	po:nom	is:mas	di:R	fq:1	id:155103
lave-vaisselle	po:nom	is:mas	is:inv	di:M	fq:2	id:155104
lavique/S.()	po:adj	is:epi	se:géol	di:*	fq:4	id:219714
lavis	po:nom	is:mas	is:inv	di:*	fq:6	id:155110
lavoir/S.()	po:nom	is:mas	di:*	fq:6	id:155111

lazulite/S.()	po:nom	is:fem	di:*	fq:4	id:155125
lazurite/S.()	po:nom	is:fem	di:*	fq:3	id:155126
lazzarone/I.()	po:nom	is:mas	et:ita	di:*	fq:5	id:155128
lazzi/S.()	po:nom	is:mas	et:ita	di:*	fq:5	id:155130
lazzi	po:nom	is:mas	is:inv	lx:dic	et:ita	di:C	fq:4	id:155131
lb/||--	po:nom	is:fem	is:inv	lx:symb	di:*	fq:6	id:155145
LCD	po:nom	is:mas	is:inv	lx:sig	et:angl	di:*	fq:5	id:203098

le	po:mg	po:det	is:mas	is:sg	se:@	di:*	fq:9	id:155146
le	po:mg	po:properobj	po:preverb	is:mas	is:sg	se:@	di:*	fq:9	id:225550
lé/S.()	po:nom	is:mas	lx:rare	lx:fxa	se:tex	et:lat	di:*	fq:7	id:156170
Léa	po:prn	is:fem	is:inv	di:*	fq:5	id:124688
leader/S.()	po:nom	is:epi	et:angl	di:M	fq:7	id:155147
leadership/S.()	po:nom	is:mas	et:angl	di:M	fq:6	id:155148
leadeurship/S.()	po:nom	is:mas	lx:rare	et:angl	di:R	fq:0	id:210531
leadeuse/F.()	po:nom	et:angl	di:R	fq:2	id:210530
Leah	po:prn	is:fem	is:inv	di:*	fq:4	id:226275

leptospire/S.()	po:nom	is:mas	se:bact	se:bio	di:*	fq:4	id:218718
leptospirose/S.()	po:nom	is:fem	di:*	fq:5	id:155188
lepture/S.()	po:nom	is:mas	se:zool	di:*	fq:3	id:155189
lequel	po:mg	po:proint	po:prorel	is:mas	is:sg	se:@	di:*	fq:8	id:155190
lerche	po:adv	di:*	fq:3	id:155191
lérot/S.()	po:nom	is:mas	se:zool	di:*	fq:4	id:156239
Leroy	po:patr	is:epi	is:inv	di:*	fq:6	id:224564

les	po:mg	po:det	is:epi	is:pl	se:@	di:*	fq:9	id:214632
les	po:mg	po:properobj	po:preverb	is:epi	is:pl	se:@	di:*	fq:9	id:225552
lès	po:mg	po:prep	lx:vx	lx:fxa	se:@	et:lat	di:*	fq:6	id:156164
Lesage	po:patr	is:epi	is:inv	se:polit	di:*	fq:6	id:231636
lesbianisme/S.()	po:nom	is:mas	di:*	fq:4	id:155192
lesbienne/F.()	po:nom	po:adj	di:*	fq:6	id:155193
lesbophobe/S.()	po:nom	po:adj	is:epi	lx:néo	di:*	fq:3	id:231024
lesbophobie/S.()	po:nom	is:fem	lx:néo	di:*	fq:4	id:231025
Lesbos	po:npr	is:epi	is:inv	se:île	di:*	fq:5	id:230411

leucopoïèse/S.()	po:nom	is:fem	se:bio	et:grec	di:*	fq:3	id:222462
leucorrhée/S.()	po:nom	is:fem	di:*	fq:5	id:155230
leucose/S.()	po:nom	is:fem	di:*	fq:5	id:155231
leucotomie/S.()	po:nom	is:fem	di:*	fq:4	id:155232
leucotrichie/S.()	po:nom	is:fem	lx:rare	se:méd	di:*	fq:1	id:228655
leucoxène/S.()	po:nom	is:mas	se:minér	et:grec	di:*	fq:4	id:226386
leude/S.()	po:nom	is:mas	di:*	fq:5	id:155235

leur	po:mg	po:detpos	is:epi	is:sg	se:@	di:*	fq:8	id:214634
leur/S.()	po:nom	is:epi	se:@	di:*	fq:9	id:155236
leur	po:mg	po:properobj	po:preverb	po:3pe	is:epi	is:pl	se:@	di:*	fq:8	id:215513
leurre/S.()	po:nom	is:mas	di:*	fq:6	id:155237
leurrer/a0p+()	po:v1__t_q_zz	di:*	fq:6	id:155238
leurs	po:mg	po:detpos	is:epi	is:pl	se:@	di:*	fq:8	id:214635
leurszigues	po:mg	po:propersuj	po:properobj	po:3pe	is:epi	is:pl	lx:fam	lx:arg	se:@	di:*	fq:1	id:232411
Leusse	po:patr	is:epi	is:inv	di:X	fq:5	id:227323
Leuze-en-Hainaut	po:npr	is:epi	is:inv	se:cité	di:*	fq:3	id:230910
lev/S.()	po:nom	is:mas	di:*	fq:5	id:155240

livret/S.()	po:nom	is:mas	di:*	fq:6	id:155682
livreuse/F.()	po:nom	di:*	fq:5	id:155683
Livry-Gargan	po:npr	is:epi	is:inv	se:cité	di:*	fq:3	id:124631
lixiviation/S.()	po:nom	is:fem	di:*	fq:5	id:155686
Liz	po:prn	is:fem	is:inv	di:*	fq:5	id:221636
Lizbeth	po:prn	is:fem	is:inv	di:*	fq:3	id:232237
Lizzie	po:prn	is:fem	is:inv	di:*	fq:5	id:222441
Lizzy	po:prn	is:fem	is:inv	di:*	id:233103
Ljubljana	po:npr	is:epi	is:inv	se:cité	di:*	fq:5	id:183381
llano/S.()	po:nom	is:mas	se:géogr	et:esp	di:M	fq:5	id:155693
Llewella	po:prn	is:fem	is:inv	di:X	fq:1	id:228185
Llewellyn	po:prn	is:mas	is:inv	di:*	fq:4	id:232701
Lloyd	po:prn	is:mas	is:inv	di:*	fq:6	id:223793
lm/U.||--	po:nom	is:mas	is:inv	lx:symb	di:*	fq:6	id:201031
ln	po:nom	is:mas	is:inv	lx:abty	se:math	di:*	fq:6	id:223112

mail/S.()	po:nom	is:mas	di:*	fq:6	id:156490
Mailclark	po:npr	is:mas	is:inv	se:soc	di:X	fq:0	id:232074
mailcoach/S.()	po:nom	is:mas	et:angl	di:R	fq:3	id:207115
mail-coach/A.()	po:nom	is:mas	et:angl	di:*	fq:2	id:156491
mailing/S.()	po:nom	is:mas	et:angl	di:*	fq:5	id:156493
mailing-list/S.()	po:nom	is:fem	se:comm	et:angl	et:ita	di:*	fq:3	id:232228
maillage/S.()	po:nom	is:mas	di:*	fq:6	id:156494

Maillane	po:npr	is:epi	is:inv	se:cité	di:X	fq:5	id:227212
Maillane	po:prn	is:fem	is:inv	di:X	fq:5	id:227213
maillard/S.()	po:nom	is:mas	di:*	fq:5	id:156495
maille/S.()	po:nom	is:fem	di:*	fq:6	id:156496
maillechort/S.()	po:nom	is:mas	di:*	fq:5	id:156497
mailler/a0p+()	po:v1_it___zz	di:*	fq:5	id:156498
maillet/S.()	po:nom	is:mas	di:*	fq:5	id:156499
mailleton/S.()	po:nom	is:mas	di:*	fq:1	id:156500
mailleuse/F.()	po:nom	se:@	se:techni	di:*	fq:4	id:223925