Index: gc_core/js/lang_core/gc_engine.js
==================================================================
--- gc_core/js/lang_core/gc_engine.js
+++ gc_core/js/lang_core/gc_engine.js
@@ -185,12 +185,12 @@
         for (let dToken of this.lToken) {
             s += `#${dToken["i"]}\t${dToken["nStart"]}:${dToken["nEnd"]}\t${dToken["sValue"]}\t${dToken["sType"]}`;
             if (dToken.hasOwnProperty("lMorph")) {
                 s += "\t" + dToken["lMorph"].toString();
             }
-            if (dToken.hasOwnProperty("tags")) {
-                s += "\t" + dToken["tags"].toString();
+            if (dToken.hasOwnProperty("aTags")) {
+                s += "\t" + dToken["aTags"].toString();
             }
             s += "\n";
         }
         return s;
     }
@@ -338,12 +338,12 @@
         let lNewToken = Array.from(_oTokenizer.genTokens(sSentence, true));
         for (let dToken of lNewToken) {
             if (this.dTokenPos.gl_get(dToken["nStart"], {}).hasOwnProperty("lMorph")) {
                 dToken["lMorph"] = this.dTokenPos.get(dToken["nStart"])["lMorph"];
             }
-            if (this.dTokenPos.gl_get(dToken["nStart"], {}).hasOwnProperty("tags")) {
-                dToken["tags"] = this.dTokenPos.get(dToken["nStart"])["tags"];
+            if (this.dTokenPos.gl_get(dToken["nStart"], {}).hasOwnProperty("aTags")) {
+                dToken["aTags"] = this.dTokenPos.get(dToken["nStart"])["aTags"];
             }
         }
         this.lToken = lNewToken;
         this.dTokenPos.clear();
         for (let dToken of this.lToken) {
@@ -485,12 +485,12 @@
                         }
                     }
                 }
             }
             // token tags
-            if (dToken.hasOwnProperty("tags") && dNode.hasOwnProperty("<tags>")) {
-                for (let sTag in dToken["tags"]) {
+            if (dToken.hasOwnProperty("aTags") && dNode.hasOwnProperty("<tags>")) {
+                for (let sTag in dToken["aTags"]) {
                     if (dNode["<tags>"].hasOwnProperty(sTag)) {
                         if (bDebug) {
                             console.log("  MATCH: /" + sTag);
                         }
                         yield { "iNode1": iNode1, "dNode": dGraph[dNode["<tags>"][sTag]] };
@@ -637,14 +637,14 @@
                             else if (cActionType == "/") {
                                 // Tag
                                 let nTokenStart = (eAct[0] > 0) ? nTokenOffset + eAct[0] : nLastToken + eAct[0];
                                 let nTokenEnd = (eAct[1] > 0) ? nTokenOffset + eAct[1] : nLastToken + eAct[1];
                                 for (let i = nTokenStart; i <= nTokenEnd; i++) {
-                                    if (this.lToken[i].hasOwnProperty("tags")) {
-                                        this.lToken[i]["tags"].add(...sWhat.split("|"))
+                                    if (this.lToken[i].hasOwnProperty("aTags")) {
+                                        this.lToken[i]["aTags"].add(...sWhat.split("|"))
                                     } else {
-                                        this.lToken[i]["tags"] = new Set(sWhat.split("|"));
+                                        this.lToken[i]["aTags"] = new Set(sWhat.split("|"));
                                     }
                                 }
                                 if (bDebug) {
                                     console.log(`    TAG:  ${sWhat} > [${this.lToken[nTokenStart]["sValue"]}:${this.lToken[nTokenEnd]["sValue"]}]`);
                                 }
@@ -1248,11 +1248,11 @@
     }
     return false;
 }
 
 function g_tag (dToken, sTag) {
-    return dToken.hasOwnProperty("tags") && dToken["tags"].has(sTag);
+    return dToken.hasOwnProperty("aTags") && dToken["aTags"].has(sTag);
 }
 
 function g_space_between_tokens (dToken1, dToken2, nMin, nMax=null) {
     let nSpace = dToken2["nStart"] - dToken1["nEnd"]
     if (nSpace < nMin) {

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
@@ -231,12 +231,12 @@
         s += "now:      " + self.sSentence  + "\n"
         for dToken in self.lToken:
             s += '#{i}\t{nStart}:{nEnd}\t{sValue}\t{sType}'.format(**dToken)
             if "lMorph" in dToken:
                 s += "\t" + str(dToken["lMorph"])
-            if "tags" in dToken:
-                s += "\t" + str(dToken["tags"])
+            if "aTags" in dToken:
+                s += "\t" + str(dToken["aTags"])
             s += "\n"
         #for nPos, dToken in self.dTokenPos.items():
         #    s += "{}\t{}\n".format(nPos, dToken)
         return s
 
@@ -341,12 +341,12 @@
         self.sSentence = sSentence
         lNewToken = list(_oTokenizer.genTokens(sSentence, True))
         for dToken in lNewToken:
             if "lMorph" in self.dTokenPos.get(dToken["nStart"], {}):
                 dToken["lMorph"] = self.dTokenPos[dToken["nStart"]]["lMorph"]
-            if "tags" in self.dTokenPos.get(dToken["nStart"], {}):
-                dToken["tags"] = self.dTokenPos[dToken["nStart"]]["tags"]
+            if "aTags" in self.dTokenPos.get(dToken["nStart"], {}):
+                dToken["aTags"] = self.dTokenPos[dToken["nStart"]]["aTags"]
         self.lToken = lNewToken
         self.dTokenPos = { dToken["nStart"]: dToken  for dToken in self.lToken  if dToken["sType"] != "INFO" }
         if bDebug:
             echo("UPDATE:")
             echo(self)
@@ -442,12 +442,12 @@
                                 if bDebug:
                                     echo("  MATCH: @" + sRegex)
                                 yield { "iNode1": iNode1, "dNode": dGraph[dNode["<re_morph>"][sRegex]] }
                                 bTokenFound = True
         # token tags
-        if "tags" in dToken and "<tags>" in dNode:
-            for sTag in dToken["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 { "iNode1": iNode1, "dNode": dGraph[dNode["<tags>"][sTag]] }
                     bTokenFound = True
@@ -555,14 +555,14 @@
                             elif cActionType == "/":
                                 # Tag
                                 nTokenStart = nTokenOffset + eAct[0]  if eAct[0] > 0  else nLastToken + eAct[0]
                                 nTokenEnd = nTokenOffset + eAct[1]  if eAct[1] > 0  else nLastToken + eAct[1]
                                 for i in range(nTokenStart, nTokenEnd+1):
-                                    if "tags" in self.lToken[i]:
-                                        self.lToken[i]["tags"].update(sWhat.split("|"))
+                                    if "aTags" in self.lToken[i]:
+                                        self.lToken[i]["aTags"].update(sWhat.split("|"))
                                     else:
-                                        self.lToken[i]["tags"] = set(sWhat.split("|"))
+                                        self.lToken[i]["aTags"] = set(sWhat.split("|"))
                                 if bDebug:
                                     echo("    TAG: {} >  [{}:{}]".format(sWhat, self.lToken[nTokenStart]["sValue"], self.lToken[nTokenEnd]["sValue"]))
                                 if sWhat not in self.dTags:
                                     self.dTags[sWhat] = [nTokenStart, nTokenStart]
                                 else:
@@ -1037,11 +1037,11 @@
         return True
     return False
 
 
 def g_tag (dToken, sTag):
-    return "tags" in dToken and sTag in dToken["tags"]
+    return "aTags" in dToken and sTag in dToken["aTags"]
 
 
 def g_space_between_tokens (dToken1, dToken2, nMin, nMax=None):
     nSpace = dToken2["nStart"] - dToken1["nEnd"]
     if nSpace < nMin: