Index: gc_core/py/lang_core/gc_engine.py
==================================================================
--- gc_core/py/lang_core/gc_engine.py
+++ gc_core/py/lang_core/gc_engine.py
@@ -603,54 +603,55 @@
     def _getNextMatchingNodes (self, dToken, dGraph, dNode, bDebug=False):
         "generator: return nodes where <dToken> “values” match <dNode> arcs"
         # token value
         if dToken["sValue"] in dNode:
             if bDebug:
-                print("value found: ", dToken["sValue"])
+                print("MATCH:", dToken["sValue"])
             yield dGraph[dNode[dToken["sValue"]]]
         # token lemmas
         if "<lemmas>" in dNode:
             for sLemma in _oSpellChecker.getLemma(dToken["sValue"]):
                 if sLemma in dNode["<lemmas>"]:
-                    #print("lemma found: ", sLemma)
+                    if bDebug:
+                        print("MATCH: >" + sLemma)
                     yield dGraph[dNode["<lemmas>"][sLemma]]
         # universal arc
         if "*" in dNode:
             if bDebug:
-                print("generic arc")
+                print("MATCH: *")
             yield dGraph[dNode["*"]]
         # regex value arcs
         if "<re_value>" in dNode:
             for sRegex in dNode["<re_value>"]:
                 if re.search(sRegex, dToken["sValue"]):
                     if bDebug:
-                        print("value regex matching: ", sRegex)
+                        print("MATCH: ~" + sRegex)
                     yield dGraph[dNode["<re_value>"][sRegex]]
         # regex morph arcs
         if "<re_morph>" in dNode:
             for sRegex in dNode["<re_morph>"]:
                 if "¬" not in sRegex:
                     # no anti-pattern
                     if any(re.search(sRegex, sMorph)  for sMorph in _oSpellChecker.getMorph(dToken["sValue"])):
                         if bDebug:
-                            print("morph regex matching: ", sRegex)
+                            print("MATCH: @" + sRegex)
                         yield dGraph[dNode["<re_morph>"][sRegex]]
                 else:
                     # there is an anti-pattern
                     sPattern, sNegPattern = sRegex.split("¬", 1)
                     if sNegPattern == "*":
                         # all morphologies must match with <sPattern>
                         if all(re.search(sPattern, sMorph)  for sMorph in _oSpellChecker.getMorph(dToken["sValue"])):
                             if bDebug:
-                                print("morph regex matching: ", sRegex)
+                                print("MATCH: @" + sRegex)
                             yield dGraph[dNode["<re_morph>"][sRegex]]
                     else:
                         if sNegPattern and any(re.search(sNegPattern, sMorph)  for sMorph in _oSpellChecker.getMorph(dToken["sValue"])):
                             continue
                         if any(re.search(sPattern, sMorph)  for sMorph in _oSpellChecker.getMorph(dToken["sValue"])):
                             if bDebug:
-                                print("morph regex matching: ", sRegex)
+                                print("MATCH: @" + sRegex)
                             yield dGraph[dNode["<re_morph>"][sRegex]]
 
     def parse (self, dGraph, dPriority, sCountry="${country_default}", dOptions=None, bShowRuleId=False, bDebug=False, bContext=False):
         dErr = {}
         dPriority = {}  # Key = position; value = priority
@@ -657,11 +658,11 @@
         dOpt = _dOptions  if not dOptions  else dOptions
         lPointer = []
         bChange = False
         for dToken in self.lToken:
             if bDebug:
-                print("=", dToken["sValue"])
+                print("TOKEN:", dToken["sValue"])
             # check arcs for each existing pointer
             lNextPointer = []
             for dPointer in lPointer:
                 for dNode in self._getNextMatchingNodes(dToken, dGraph, dPointer["dNode"], bDebug):
                     lNextPointer.append({"iToken": dPointer["iToken"], "dNode": dNode})
@@ -669,12 +670,12 @@
             # check arcs of first nodes
             for dNode in self._getNextMatchingNodes(dToken, dGraph, dGraph[0], bDebug):
                 lPointer.append({"iToken": dToken["i"], "dNode": dNode})
             # check if there is rules to check for each pointer
             for dPointer in lPointer:
-                if bDebug:
-                    print("+", dPointer)
+                #if bDebug:
+                #    print("+", dPointer)
                 if "<rules>" in dPointer["dNode"]:
                     bHasChanged, errs = self._executeActions(dGraph, dPointer["dNode"]["<rules>"], dPointer["iToken"]-1, dPriority, dOpt, sCountry, bShowRuleId, bDebug, bContext)
                     dErr.update(errs)
                     if bHasChanged:
                         bChange = True
@@ -685,10 +686,13 @@
         dErrs = {}
         bChange = False
         for sLineId, nextNodeKey in dNode.items():
             for sRuleId in dGraph[nextNodeKey]:
                 try:
+                    if bDebug:
+                        print("ACTION:", sRuleId)
+                        print(dRule[sRuleId])
                     bCondMemo = None
                     sOption, sFuncCond, cActionType, sWhat, *eAct = dRule[sRuleId]
                     # action in lActions: [ condition, action type, replacement/suggestion/action[, iTokenStart, iTokenEnd[, nPriority, message, URL]] ]
                     if not sOption or dOptions.get(sOption, False):
                         bCondMemo = not sFuncCond or globals()[sFuncCond](self.lToken, nTokenOffset, sCountry, bCondMemo)