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
@@ -164,11 +164,11 @@
             if not bParagraph and bSentenceChange:
                 oSentence.update(s)
                 bSentenceChange = False
             for sGraphName, sLineId in lRuleGroup:
                 if bDebug:
-                    print(sGraphName, sLineId)
+                    print("\n>>>> GRAPH:", sGraphName, sLineId)
                 bParagraphChange, errs = oSentence.parse(dAllGraph[sGraphName], dPriority, sCountry, dOptions, bShowRuleId, bDebug, bContext)
                 dErrs.update(errs)
                 if bParagraphChange:
                     s = oSentence.rewrite()
                     if bDebug:
@@ -598,70 +598,83 @@
 
     def update (self, sSentence):
         self.sSentence = sSentence
         self.lToken = list(_oTokenizer.genTokens(sSentence, True))
 
-    def _getNextMatchingNodes (self, dToken, dGraph, dNode):
+    def _getNextMatchingNodes (self, dToken, dGraph, dNode, bDebug=False):
         "generator: return nodes where <dToken> “values” match <dNode> arcs"
         # token value
         if dToken["sValue"] in dNode:
-            #print("value found: ", dToken["sValue"])
+            if bDebug:
+                print("value found: ", 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)
                     yield dGraph[dNode["<lemmas>"][sLemma]]
         # universal arc
         if "*" in dNode:
-            #print("generic arc")
+            if bDebug:
+                print("generic arc")
             yield dGraph[dNode["*"]]
         # regex value arcs
         if "<re_value>" in dNode:
             for sRegex in dNode["<re_value>"]:
                 if re.search(sRegex, dToken["sValue"]):
-                    #print("value regex matching: ", sRegex)
+                    if bDebug:
+                        print("value regex matching: ", 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)
                         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)
                             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)
                             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
         dOpt = _dOptions  if not dOptions  else dOptions
         lPointer = []
         bChange = False
         for dToken in self.lToken:
+            if bDebug:
+                print("=", dToken["sValue"])
             # check arcs for each existing pointer
             lNextPointer = []
             for dPointer in lPointer:
-                for dNode in self._getNextMatchingNodes(dToken, dGraph, dPointer["dNode"]):
+                for dNode in self._getNextMatchingNodes(dToken, dGraph, dPointer["dNode"], bDebug):
                     lNextPointer.append({"iToken": dPointer["iToken"], "dNode": dNode})
             lPointer = lNextPointer
             # check arcs of first nodes
-            for dNode in self._getNextMatchingNodes(dToken, dGraph, dGraph[0]):
+            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 "<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