diff --git a/src/compiler/OptTree-AutoMarkup-BasisVertexesExtractor.ref b/src/compiler/OptTree-AutoMarkup-BasisVertexesExtractor.ref
new file mode 100644
index 00000000..8d82fcdd
--- /dev/null
+++ b/src/compiler/OptTree-AutoMarkup-BasisVertexesExtractor.ref
@@ -0,0 +1,194 @@
+$INCLUDE "LibraryEx";
+
+*$FROM OptTree-AutoMarkup-Common
+$EXTERN OptTree-AutoMarkup-GetSetDifference,
+        OptTree-AutoMarkup-Contains,
+        OptTree-AutoMarkup-GetElemByKey,
+        OptTree-AutoMarkup-GetParents,
+        OptTree-AutoMarkup-Equal;
+
+/**
+	<OptTree-AutoMarkup-ExtractBasisVertexes e.ExtractedGraph>
+    = (e.BasisVertex)* (e.Graph)
+
+	e.BasisVertex = e.FuncName
+*/
+
+$ENTRY OptTree-AutoMarkup-ExtractBasisVertexes {
+  e.Graph
+    = <OptTree-AutoMarkup-GetGraphRoots (e.Graph)>
+      : (e.GraphRoots)
+    = <OptTree-AutoMarkup-GetBasisVertexes
+        (e.GraphRoots)
+        e.Graph
+      >
+      : (
+          (e.CurrentPath)
+          (e.Proccessed)
+          (e.BasisVertexes)
+          (e.Graph^)
+        )
+    = (e.BasisVertexes) (e.Graph);
+}
+
+OptTree-AutoMarkup-GetGraphRoots {
+  (e.Graph)
+    = <MapAccum
+        {
+          ((e.Result) (e.Graph^))
+          (Func (Indirect function for implicit calls) Children (e.Children))
+            = ((e.Result) (e.Graph));
+
+          ((e.Result) (e.Graph^))
+          (Func (e.FuncName) Children (e.Children))
+            , e.Graph
+              : e.GraphHead
+                (
+                  Func (e.ParentName)
+                  Children (e.ChildrenHead (e.FuncName) e.ChildrenTail)
+                )
+                e.GraphTail
+            , <OptTree-AutoMarkup-Equal (e.ParentName) (e.FuncName)> : False
+            = ((e.Result) (e.Graph));
+
+          ((e.Result) (e.Graph^))
+          (Func (e.FuncName) Children (e.Children))
+            = ((e.Result (e.FuncName)) (e.Graph))
+        }
+        ((/*result*/) (e.Graph)) e.Graph
+      >
+      : ((e.Roots) (e.Graph^))
+    = (e.Roots);
+}
+
+OptTree-AutoMarkup-GetBasisVertexes-GetResultByNode {
+  (Func (e.Name) Children (e.Children))
+  ((e.CurrentPath) (e.Proccessed) (e.BasisVertexes) (e.Graph))
+    = <MapAccum
+        {
+          ((e.CurrentPath^) (e.Proccessed^) (e.BasisVertexes^) (e.Graph^))
+          (e.ChildFunc)
+            , e.BasisVertexes : e._ (e.ChildFunc) e._
+            = (
+                (e.CurrentPath)
+                (e.Proccessed)
+                (e.BasisVertexes)
+                (e.Graph)
+              );
+
+          ((e.CurrentPath^) (e.Proccessed^) (e.BasisVertexes^) (e.Graph^))
+          (e.Name)
+            , e.CurrentPath : e._ (e.ChildFunc) e._
+            = (
+                (e.CurrentPath)
+                (e.Proccessed)
+                (e.BasisVertexes (e.Name))
+                (e.Graph)
+              );
+
+          ((e.CurrentPath^) (e.Proccessed^) (e.BasisVertexes^) (e.Graph^))
+          (e.ChildFunc)
+            , e.CurrentPath : e._ (e.ChildFunc) e._
+            = (
+                (e.CurrentPath)
+                (e.Proccessed)
+                (e.BasisVertexes (e.ChildFunc))
+                (e.Graph)
+              );
+
+          ((e.CurrentPath^) (e.Proccessed^) (e.BasisVertexes^) (e.Graph^))
+          (e.ChildFunc)
+            , e.Proccessed : e._ (e.ChildFunc) e._
+            = (
+                (e.CurrentPath)
+                (e.Proccessed)
+                (e.BasisVertexes)
+                (e.Graph)
+              );
+
+          ((e.CurrentPath^) (e.Proccessed^) (e.BasisVertexes^) (e.Graph^))
+          (e.ChildFunc)
+            = e.CurrentPath (e.ChildFunc) : e.NewCurrentPath
+            = <OptTree-AutoMarkup-GetBasisVertexes
+                ((e.ChildFunc))
+                (
+                  (e.NewCurrentPath)
+                  (e.Proccessed)
+                  (e.BasisVertexes)
+                  (e.Graph)
+                )
+              >
+              : (
+                  (e.NewCurrentPath^)
+                  (e.Proccessed^)
+                  (e.BasisVertexes^)
+                  (e.Graph^)
+                )
+            = (
+                (e.CurrentPath)
+                (e.Proccessed)
+                (e.BasisVertexes)
+                (e.Graph)
+              );
+        }
+        ((e.CurrentPath) (e.Proccessed) (e.BasisVertexes) (e.Graph))
+        e.Children
+      >
+      : ((e.CurrentPath^) (e.Proccessed^) (e.BasisVertexes^) (e.Graph^))
+      = e.Proccessed (e.Name) : e.NewProccessed
+      = (
+          (e.CurrentPath)
+          (e.NewProccessed)
+          (e.BasisVertexes)
+          (e.Graph)
+        );
+
+  (e.Other)
+  ((e.CurrentPath) (e.Proccessed) (e.BasisVertexes) (e.Graph))
+    = ((e.CurrentPath) (e.Proccessed) (e.BasisVertexes) (e.Graph));
+}
+
+
+OptTree-AutoMarkup-GetBasisVertexes {
+  (e.NextGraphNodes)
+  (
+    (e.CurrentPath)
+    (e.Proccessed)
+    (e.BasisVertexes)
+    (e.Graph)
+  )
+    = <MapAccum
+        {
+          ((e.CurrentPath^)(e.Proccessed^)(e.BasisVertexes^)(e.Graph^))
+          (e.FuncName)
+            = <OptTree-AutoMarkup-GetElemByKey
+                (e.FuncName)
+                (e.Graph)
+              >
+              : e.Node (e.Graph^)
+            = <OptTree-AutoMarkup-GetBasisVertexes-GetResultByNode
+                (e.Node)
+                ((e.CurrentPath)(e.Proccessed)(e.BasisVertexes)(e.Graph))
+              >
+        }
+        (
+          (e.CurrentPath)
+          (e.Proccessed)
+          (e.BasisVertexes)
+          (e.Graph)
+        )
+        e.NextGraphNodes
+      >;
+
+  (e.RootNodes)
+  e.Graph
+    = <OptTree-AutoMarkup-GetBasisVertexes
+        (e.RootNodes)
+        (
+          ()
+          ()
+          ()
+          (e.Graph)
+        )
+      >;
+}
\ No newline at end of file
diff --git a/src/compiler/OptTree-AutoMarkup-Common.ref b/src/compiler/OptTree-AutoMarkup-Common.ref
new file mode 100644
index 00000000..ccdc3dbb
--- /dev/null
+++ b/src/compiler/OptTree-AutoMarkup-Common.ref
@@ -0,0 +1,88 @@
+$INCLUDE "LibraryEx";
+
+/**
+	<OptTree-AutoMarkup-GetSetDifference (e.FirstSet) (e.SecondSet)> ==
+  (e.FirstSet\e.SecondSet)
+*/
+
+$ENTRY OptTree-AutoMarkup-GetSetDifference {
+  (e.FirstSet) (e.SecondSet)
+    = <Map
+        {
+          e.Node, <OptTree-AutoMarkup-Contains e.Node (e.SecondSet)> : False
+            = e.Node;
+
+          e.Other
+            = ;
+        }
+        e.FirstSet
+      >
+      : e.Res
+    = (e.Res);
+}
+
+/**
+	<OptTree-AutoMarkup-Contains (e.Elem) (e.Array)> == True|False
+*/
+
+$ENTRY OptTree-AutoMarkup-Contains {
+  (e.Elem) (e.ArrayHead (e.Elem) e.ArrayTail)
+    = True;
+
+  (e.Elem) (e.Array)
+    =  False;
+}
+
+/**
+  <OptTree-AutoMarkup-Equal (e.First) (e.Second)> == True|False
+*/
+
+$ENTRY OptTree-AutoMarkup-Equal {
+  (e.X) (e.X)
+    = True;
+
+  (e.X) (e.Y)
+    = False;
+}
+
+/**
+	<OptTree-AutoMarkup-GetElemByKey (e.Key) (e.Graph)>
+    == e.GraphNode (e.Graph)
+
+	e.GraphNode = (Func (e.Key) Children (e.Children))
+*/
+
+$ENTRY OptTree-AutoMarkup-GetElemByKey {
+  (e.Key) (e.GraphHead (Func (e.Key) Children (e.Children)) e.GraphTail)
+    = Func (e.Key) Children (e.Children)
+      (e.GraphHead (Func (e.Key) Children (e.Children)) e.GraphTail);
+
+  (e.Key) (e.Graph)
+    = /* пусто */ (e.Graph);
+}
+
+/**
+	<OptTree-AutoMarkup-GetParents (e.ChildName) (e.Graph)> == e.GraphNode*
+
+	e.GraphNode = (Func (e.Key) Children (e.Children))
+
+	e.Children = (e._ (e.ChildName) e._)
+*/
+
+$ENTRY OptTree-AutoMarkup-GetParents {
+  (e.ChildName)
+  (e.Graph-B (Func (e.FuncName) Children (e._ (e.ChildName) e._)) e.Graph-E)
+    = (e.FuncName)
+      <OptTree-AutoMarkup-GetParents (e.ChildName) (e.Graph-E)>;
+
+  (e.ChildName) (e._)
+    = ;
+}
+
+$ENTRY OptTree-AutoMarkup-IsEmpty {
+  ()
+    = True;
+
+  e.Other
+    = False;
+}
diff --git a/src/compiler/OptTree-AutoMarkup-GraphExtractor.ref b/src/compiler/OptTree-AutoMarkup-GraphExtractor.ref
new file mode 100644
index 00000000..29bd6cd8
--- /dev/null
+++ b/src/compiler/OptTree-AutoMarkup-GraphExtractor.ref
@@ -0,0 +1,463 @@
+$INCLUDE "LibraryEx";
+
+*$FROM DisplayName
+$EXTERN DisplayName;
+
+*$FROM OptTree-AutoMarkup-Common
+$EXTERN OptTree-AutoMarkup-Contains,
+        OptTree-AutoMarkup-GetElemByKey;
+
+/**
+  <OptTree-AutoMarkup-ExtractGraph e.AST> == e.FunctionCallsGraph
+*/
+
+$ENTRY OptTree-AutoMarkup-ExtractFunctionCallsGraph {
+  e.AST
+    = <MapAccum
+        {
+          ((e.GraphNodes) (e.IndirectChildren))
+          e.AstNode
+            = <OptTree-AutoMarkup-GetFuncs e.AstNode>
+              :
+                {
+                  (e.Node) (e.NodeIndirectChildren)
+                    = (
+                        (e.GraphNodes (e.Node))
+                        (e.IndirectChildren e.NodeIndirectChildren)
+                      );
+
+                  e.Other
+                    = ((e.GraphNodes) (e.IndirectChildren));
+                }
+
+        }
+        ((/*graph nodes*/) (/*indirect children*/)) e.AST
+      >
+      : ((e.ExtractedFuncs) (e.IndirectChildren))
+     = <Map &OptTree-AutoMarkup-GetMetatablesNames e.AST>
+      : e.MetatablesNames
+    = <Unique e.IndirectChildren>
+      : e.UniqueIndirectChildren
+    = <Map
+        {
+          (e.FuncName)
+            , e.MetatablesNames : e.MetatableHead (e.FuncName) e.MetatableTail
+            = ;
+
+          e.Other
+            = e.Other;
+        }
+        e.UniqueIndirectChildren
+      >
+      : e.ClearedUniqueIndirectChildren
+    = (Func (Indirect function for implicit calls)
+      Children (e.ClearedUniqueIndirectChildren))
+      : e.IndirectFuncNode
+    = <Map &OptTree-AutoMarkup-GetMetatablesNames e.AST>
+      : e.MetatablesNames
+    = <Map &OptTree-AutoMarkup-GetMetatables e.AST>
+      : e.ExtractedMetaTables
+    = <OptTree-AutoMarkup-InlineFuncCallsWithMetatable
+        (e.ExtractedFuncs)
+        (e.ExtractedMetaTables)
+      >
+      : e.InlinedGraph
+    = <Map &OptTree-AutoMarkup-GetEntryPoints e.AST>
+      : e.EntryPoints
+    = e.EntryPoints e.UniqueIndirectChildren
+      : e.EntryPoints^
+    = <OptTree-AutoMarkup-GetClearedByEntryPointsGraph
+        (e.InlinedGraph)
+        (e.EntryPoints)
+      >
+      : ((e.ResultGraph) (e.InlinedGraph^))
+    = <Unique e.IndirectFuncNode e.ResultGraph>;
+}
+
+OptTree-AutoMarkup-GetEntryPoints {
+  (Function GN-Entry (e.FuncName) Sentences e.Body)
+    = (e.FuncName);
+
+  (Function s.Scope (e.FuncName) Sentences e.Body)
+    ,<OneOf (e.FuncName) (INIT) (FINAL)> : True
+    = (e.FuncName);
+
+  e.Smth
+    = ;
+}
+
+OptTree-AutoMarkup-GetClearedByEntryPointsGraph {
+  (e.Graph) (e.EntryPoints)
+    = <OptTree-AutoMarkup-GetClearedByEntryPointsGraph
+        (e.Graph)
+        ()
+        (e.EntryPoints)
+      >;
+
+  (e.Graph) (e.ProccessedNodes) (e.EntryPoints)
+    = <MapAccum
+        {
+          ((e.ProcessedNodes) (e.Result) (e.Graph^))
+          (e.EntryPoint)
+            , <OptTree-AutoMarkup-Contains
+                (e.EntryPoint)
+                (e.ProcessedNodes)
+              > : False
+            = (e.ProcessedNodes (e.EntryPoint))
+              : (e.NewProcessedNodes)
+            = <OptTree-AutoMarkup-GetElemByKey
+                (e.EntryPoint)
+                (e.Graph)
+              >
+              : e.Node (e.Graph^)
+            = e.Node
+              : {
+                  Func (e.FuncName) Children (e.Children)
+                    = <OptTree-AutoMarkup-GetClearedByEntryPointsGraph
+                        (e.Graph)
+                        (e.NewProcessedNodes)
+                        (e.Children)
+                      >
+                      : ((e.SubTreeResult) (e.Graph^))
+                    = (
+                        (e.NewProcessedNodes)
+                        (
+                          e.Result
+                          (Func (e.FuncName) Children (e.Children))
+                          e.SubTreeResult
+                        )
+                        (e.Graph)
+                      );
+
+                  e._
+                    = (
+                        (e.NewProcessedNodes)
+                        (e.Result)
+                        (e.Graph)
+                      );
+                };
+
+          ((e.ProcessedNodes) (e.Result) (e.Graph^)) e.Other
+            = ((e.ProcessedNodes) (e.Result) (e.Graph));
+        }
+        ((e.ProccessedNodes) (/*result*/) (e.Graph)) e.EntryPoints
+      >
+      : ((e.ProccessedNodes^) (e.Result) (e.Graph^))
+    = ((e.Result) (e.Graph))
+}
+
+OptTree-AutoMarkup-GetMetatables {
+  (Function s.ScopeClass (e.Name) Metatable e.Metatable)
+    = <Map
+        &OptTree-AutoMarkup-ExtractFunctionCallsFromMetatable
+        e.Metatable
+      >
+      : e.FunctionCalls
+    = (e.Name (<Unique e.FunctionCalls>));
+
+  e.Smth
+    = ;
+}
+
+OptTree-AutoMarkup-GetMetatablesNames {
+  (Function s.ScopeClass (e.Name) Metatable e.Metatable)
+    = (e.Name);
+
+  e.Smth
+    = ;
+}
+
+OptTree-AutoMarkup-GetFuncs {
+  (Function s.ScopeClass (e.Name) Sentences e.Body)
+    = <MapAccum
+        {
+          ((e.DirectCalls)(e.ImplicitCalls)(e.IndirectChildren))
+          (e.Sentence)
+            = <OptTree-AutoMarkup-ExtractFunctionCallsFromSentencesBody
+                (e.Sentence)
+              >
+              : (e.SentenceDirectCalls)
+                (e.SentecnseImplicitCalls)
+                (e.SentecnseIndirectChildren)
+            = (
+                (e.DirectCalls e.SentenceDirectCalls)
+                (e.ImplicitCalls e.SentecnseImplicitCalls)
+                (e.IndirectChildren e.SentecnseIndirectChildren)
+              )
+        }
+        ((/*direct calls*/) (/*implicit calls*/) (/*indirect children*/))
+        e.Body
+      >
+      : ((e.DirectCalls) (e.ImplicitCalls) (e.IndirectChildren))
+    = <Unique e.DirectCalls> : e.UniqueDirectCalls
+    = (e.ImplicitCalls)
+      : {
+          ()
+            = ;
+
+          (e._)
+            = (Indirect function for implicit calls)
+        }
+        : e.IndirectChild
+    = (Func (e.Name) Children (e.UniqueDirectCalls e.IndirectChild))
+      (e.IndirectChildren);
+
+  e.Smth
+    = ;
+}
+
+OptTree-AutoMarkup-ExtractFunctionCallsFromMetatable {
+  ((Symbol Identifier e.Ident) (Symbol Name e.Name))
+    = (e.Name);
+}
+
+OptTree-AutoMarkup-ExtractFunctionCallsFromSentencesBody {
+  ((e.Pattern) e.Conditions (e.Result))
+    = <OptTree-AutoMarkup-ExtractExpressionName e.Pattern>
+      : (e.PatternNames) (e.PatternIndirectCalls) (e.PatternIndirectChildren)
+    = <MapAccum
+        {
+          ((e.DirectCalls)(e.IndirectCalls)(e.IndirectChildren))
+          (Condition (e.Name) (e.ConditionResult) (e.ConditionPattern))
+              = <OptTree-AutoMarkup-ExtractExpressionName
+                  e.ConditionResult
+                >
+                : (e.ConditionResultCalls)
+                  (e.ConditionResultIndirectCalls)
+                  (e.ConditionResultIndirectChildren)
+              = <OptTree-AutoMarkup-ExtractExpressionName
+                  e.ConditionPattern
+                >
+                : (e.ConditionPatternCalls)
+                  (e.ConditionPatternIndirectCalls)
+                  (e.ConditionPatternIndirectChildren)
+              = (
+                  (
+                    e.DirectCalls
+                    e.ConditionResultCalls
+                    e.ConditionPatternCalls
+                  )
+                  (
+                    e.IndirectCalls
+                    e.ConditionResultIndirectCalls
+                    e.ConditionPatternIndirectCalls
+                  )
+                  (
+                    e.IndirectChildren
+                    e.ConditionResultIndirectChildren
+                    e.ConditionPatternIndirectChildren
+                  )
+                );
+        }
+        ((/*direct calls*/) (/*indirect calls*/) (/*indirect children*/))
+        e.Conditions
+      >
+      : (
+          (e.ConditionNames)
+          (e.ConditionIndirectCalls)
+          (e.ConditionIndirectChildren)
+        )
+    = <OptTree-AutoMarkup-ExtractExpressionName e.Result>
+      : (e.ResultNames) (e.ResultIndirectCalls) (e.ResultIndirectChildren)
+    = (
+        e.PatternNames
+        e.ConditionNames
+        e.ResultNames
+      )
+      (
+        e.PatternIndirectCalls
+        e.ConditionIndirectCalls
+        e.ResultIndirectCalls
+      )
+      (
+        e.PatternIndirectCalls
+        e.ConditionIndirectChildren
+        e.ResultIndirectChildren
+      );
+}
+
+OptTree-AutoMarkup-InnerExtractExpressionName {
+  (e.Expr) (e.DirectCalls) (e.IndirectDetected) (e.IndirectChildren)
+    = <MapAccum
+        {
+          ((e.DirectCalls^) (e.IndirectDetected^) (e.IndirectChildren^))
+          (Symbol Name e.Name)
+            = (
+                (e.DirectCalls (e.Name))
+                (e.IndirectDetected)
+                (e.IndirectChildren)
+              );
+
+          ((e.DirectCalls^) (e.IndirectDetected^) (e.IndirectChildren^))
+          (t.Marker e.Nested)
+            , <OneOf
+                (t.Marker)
+                (Brackets)
+                (ADT-Brackets)
+                (ClosureBrackets)
+              > : True
+            = <OptTree-AutoMarkup-InnerExtractExpressionName
+                (e.Nested)
+                (e.DirectCalls)
+                (e.IndirectDetected)
+                (e.IndirectChildren)
+              >;
+
+          ((e.DirectCalls^) (e.IndirectDetected^) (e.IndirectChildren^))
+          (CallBrackets
+            (Symbol Name e.Name)
+            e.NestedHead
+            (Symbol Name e.IndirectChild)
+            e.NestedTail
+          )
+            = (e.IndirectChild)
+              <Map
+                {
+                  (Symbol Name e.NextInderectChild)
+                    = (e.NextInderectChild);
+
+                  e.Other
+                    = ;
+                }
+                e.NestedTail
+              >
+              : e.AdditionaIndirectChildren
+            = <Map
+                {
+                  (Symbol Name e._)
+                    = ;
+
+                  e.Other
+                    = e.Other;
+                }
+                e.NestedHead e.NestedTail
+              >
+              : e.Nested^
+            = <OptTree-AutoMarkup-InnerExtractExpressionName
+                (e.Nested)
+                (e.DirectCalls)
+                (e.IndirectDetected)
+                (e.IndirectChildren)
+              >
+              : (
+                  (e.DirectCalls^)
+                  (e.IndirectDetected^)
+                  (e.IndirectChildren^)
+                )
+            = (
+                (e.DirectCalls (e.Name))
+                (e.IndirectDetected)
+                (e.IndirectChildren e.AdditionaIndirectChildren)
+              );
+
+          ((e.DirectCalls^) (e.IndirectDetected^) (e.IndirectChildren^))
+          (CallBrackets (Symbol Name e.Name) e.Nested)
+            = <OptTree-AutoMarkup-InnerExtractExpressionName
+                (e.Nested)
+                (e.DirectCalls)
+                (e.IndirectDetected)
+                (e.IndirectChildren)
+              >
+              : (
+                  (e.DirectCalls^)
+                  (e.IndirectDetected^)
+                  (e.IndirectChildren^)
+                )
+            = (
+                (e.DirectCalls (e.Name))
+                (e.IndirectDetected)
+                (e.IndirectChildren)
+              );
+
+          ((e.DirectCalls^) (e.IndirectDetected^) (e.IndirectChildren^))
+          (CallBrackets e.Nested)
+            = <OptTree-AutoMarkup-InnerExtractExpressionName
+                (e.Nested)
+                (e.DirectCalls)
+                (e.IndirectDetected)
+                (e.IndirectChildren)
+              >
+              : (
+                  (e.DirectCalls^)
+                  (e.IndirectDetected^)
+                  (e.IndirectChildren^)
+                )
+            = (
+                (e.DirectCalls)
+                (Indirect detected)
+                (e.IndirectChildren)
+              );
+
+          ((e.DirectCalls^) (e.IndirectDetected^) (e.IndirectChildren^))
+          (t.Marker e.Smth)
+            = ((e.DirectCalls) (e.IndirectDetected) (e.IndirectChildren));
+        }
+        ((e.DirectCalls) (e.IndirectDetected) (e.IndirectChildren))
+        e.Expr
+      >;
+}
+
+OptTree-AutoMarkup-ExtractExpressionName {
+  e.Expr
+    = <OptTree-AutoMarkup-InnerExtractExpressionName (e.Expr) () () ()>
+      : ((e.DirectCalls) (e.IndirectDetected) (e.IndirectChildren))
+    = (e.DirectCalls) (e.IndirectDetected) (e.IndirectChildren)
+}
+
+OptTree-AutoMarkup-InlineFuncCallsWithMetatable {
+  (e.ExtractedFuncs) (e.ExtractedMetaTables)
+    = <Map
+        {
+          e.Elem
+            = <OptTree-AutoMarkup-InlineOneFuncChildrenWithMetatable
+                e.Elem
+                (e.ExtractedMetaTables)
+              >;
+        }
+        e.ExtractedFuncs
+      >;
+}
+
+OptTree-AutoMarkup-InlineOneFuncChildrenWithMetatable {
+  (Func (e.Name) Children (e.UniqueFunctionCalls)) (e.ExtractedMetaTables)
+      = <Map
+          {
+            e.Elem
+              = <OptTree-AutoMarkup-GetCallsFromMetaTables
+                  e.Elem
+                  (e.ExtractedMetaTables)
+                >;
+          }
+          e.UniqueFunctionCalls
+        >
+        : e.ReplacedChildren
+      = <Unique e.ReplacedChildren>
+        : e.UniqueReplacedChildren
+      = (Func (e.Name) Children (e.UniqueReplacedChildren));
+}
+
+OptTree-AutoMarkup-GetCallsFromMetaTables {
+  (e.FuncName) (e.ExtractedMetaTables)
+    = (<Map
+        {
+          (e.Key (e.Value))
+            , e.Key : e.FuncName
+            = e.Value;
+
+          (e.Other)
+            = ;
+        }
+        e.ExtractedMetaTables
+      >)
+      : e.ReplaceValue
+    = <Fetch
+        e.ReplaceValue
+        {
+          ()
+            = (e.FuncName);
+
+          (e.FuncSet)
+            = e.FuncSet;
+        }
+      >;
+}
\ No newline at end of file
diff --git a/src/compiler/OptTree-AutoMarkup-SpecializableExtractor.ref b/src/compiler/OptTree-AutoMarkup-SpecializableExtractor.ref
new file mode 100644
index 00000000..625943df
--- /dev/null
+++ b/src/compiler/OptTree-AutoMarkup-SpecializableExtractor.ref
@@ -0,0 +1,329 @@
+$INCLUDE "LibraryEx";
+
+*$FROM GlobalGen
+$EXTERN GlobalGen;
+
+*$FROM GenericMatch
+$EXTERN GenericMatch;
+
+*$FROM Log
+$EXTERN Log-PutLine;
+
+/**
+  <OptTree-AutoMarkup-GetSpecializableDict (e.AST)>
+    == ((e.FuncName) '->' ((e.TypedVariable)+))
+
+  e.TypedVariable = {s.VariableType}
+                    {STAT | dyn}
+                    {index}
+*/
+
+$ENTRY OptTree-AutoMarkup-GetSpecializableDict {
+  (e.AST)
+    = <Map
+        {
+          (Function s.ScopeClass (e.Name) Sentences e.Body)
+            = <Map
+                {
+                  ((e.Pattern) e.Conditions (e.Result))
+                    = (e.Pattern);
+
+                  e.Other
+                    = ;
+                }
+                e.Body
+              >
+              : e.ExtractedPatterns
+            = <OptTree-AutoMarkup-ContainsDuplications
+                (e.ExtractedPatterns)
+              >
+              : {
+                  True
+                    = (NOTSPECIALIZABLE (e.Name));
+
+                  False
+                    = <OptTree-AutoMarkup-GetSpecifiedPattern
+                        (e.ExtractedPatterns)
+                      >
+                      : e.SpecifiedPattern
+                    = <OptTree-AutoMarkup-GetSpecializableDictNode
+                        (e.Name)
+                        (e.SpecifiedPattern)
+                      >
+                      : e.DictNode
+                    = e.DictNode;
+              };
+
+          e.Other
+            = ;
+        }
+        e.AST
+      >;
+
+  e.Other
+    = ;
+}
+
+OptTree-AutoMarkup-GetSpecializableDictNode {
+  (e.FuncName) (e.SpecifiedPattern)
+    , e.SpecifiedPattern : e.Head ('e.STAT' e.Suffix) e.Tail
+    = (SPECIALIZABLE (e.FuncName) '->' (e.SpecifiedPattern));
+
+  (e.FuncName) e.Other
+    = (NOTSPECIALIZABLE (e.FuncName));
+}
+
+OptTree-AutoMarkup-ContainsDuplications {
+  (e.ExtractedPatterns)
+    = <Map
+        {
+          (e.Patterns)
+            = <Map
+                &OptTree-AutoMarkup-GetPatternVariables
+                e.Patterns
+              >
+              : e.Stm
+            = e.Stm
+              : {
+                  e.Head (e.Variable) e._ (e.Variable) e.Tail
+                    = (True);
+
+                  e.Other
+                    = (False);
+                };
+        }
+        e.ExtractedPatterns
+      >
+      : {
+          e.Head (True) e.Tail
+            = True;
+
+          e.Other
+            = False;
+        }
+}
+
+OptTree-AutoMarkup-GetPatternVariables {
+  (TkVariable e.Name)
+    = (e.Name);
+
+  (Symbol Identifier VAR e.Name)
+    = (e.Name);
+
+  (Brackets e.Nested)
+    = <Map
+        {
+          (e.SubPattern)
+            = <OptTree-AutoMarkup-GetPatternVariables (e.SubPattern)>;
+        }
+        e.Nested
+      >;
+
+  (e.Other)
+    = ;
+}
+
+OptTree-AutoMarkup-GetSpecifiedPattern {
+  (e.ExtractedPatterns)
+    = <OptTree-AutoMarkup-GetIndexedGlobalGens (e.ExtractedPatterns)>
+      : e.IndexedGlobalGens
+    = <Map
+        {
+          (e.ConcretePattern)
+            = <GenericMatch
+                (e.ConcretePattern)
+                (e.IndexedGlobalGens)
+              >
+              : e.GenericMatch
+            = (e.GenericMatch);
+        }
+        e.ExtractedPatterns
+      >
+      : e.GenericMatches
+    = <OptTree-AutoMarkup-GetVariableMatches
+        (e.GenericMatches)
+        (e.IndexedGlobalGens)
+      >
+      : e.VariableMatchesDict
+    = <OptTree-AutoMarkup-GetVariableSpecType (e.VariableMatchesDict)>
+      : e.TypedVariables
+    = e.TypedVariables;
+}
+
+OptTree-AutoMarkup-GetIndexedGlobalGens {
+  ()
+    = ();
+
+  (e.Patterns)
+    = <GlobalGen e.Patterns>
+      : e.GlobalGens
+    = <OptTree-AutoMarkup-FillIndexes (e.GlobalGens) 't'>
+      : e.Result
+    = <OptTree-AutoMarkup-FillIndexes (e.Result) 'e'>
+      : e.Result^
+    = <OptTree-AutoMarkup-FillIndexes (e.Result) 's'>
+      : e.Result^
+    = e.Result;
+
+  e.Other
+    = ;
+}
+
+OptTree-AutoMarkup-FillIndexes {
+  (e.GlobalGens) s.Type
+    = <OptTree-AutoMarkup-FillIndexes (0) (e.GlobalGens) s.Type>
+      : (e._) e.IndexedTypeGlobalGens
+    = e.IndexedTypeGlobalGens;
+
+  (e.StartIndex) (e.GlobalGens) s.Type
+    = <MapAccum
+        {
+          (e.CurrentIndex) (TkVariable s.Type)
+            = TkVariable s.Type '.' e.CurrentIndex
+              : e.IndexedVariable
+            = <Add e.CurrentIndex 1>
+              : e.NewIndex
+            = (e.NewIndex) (e.IndexedVariable);
+
+          (e.CurrentIndex) (TkVariable e.Other)
+            = (e.CurrentIndex) (TkVariable e.Other);
+
+          (e.CurrentIndex) (Brackets e.Nested)
+            = <OptTree-AutoMarkup-FillIndexes
+                (e.CurrentIndex)
+                (e.Nested)
+                s.Type
+              >
+              : (e.NextIndex) e.IndexedTypeGlobalGens
+            = (e.NextIndex) (Brackets e.IndexedTypeGlobalGens);
+
+          (e.CurrentIndex) (e.Other)
+            = (e.CurrentIndex) (e.Other);
+        }
+        (e.StartIndex) e.GlobalGens
+      >
+}
+
+OptTree-AutoMarkup-GetVariableMatchesByIndexedGlobalGen {
+  TkVariable e.VariableName (e.GenericMatches)
+    = <Map
+        {
+          (Clear e.Dict)
+            = <OptTree-AutoMarkup-GetMatchesByVariableName
+                (e.VariableName)
+                (e.Dict)
+              >;
+
+          e.Other
+            = ;
+        }
+        e.GenericMatches
+      >
+      : e.CurrentVariableRes
+    = <OptTree-AutoMarkup-GetVariablesTypes e.CurrentVariableRes>
+      : e.CurrentVariableTypeRes
+    = (e.VariableName ':' e.CurrentVariableTypeRes);
+
+  Brackets e.Nested (e.GenericMatches)
+    = <OptTree-AutoMarkup-GetVariableMatchesByIndexedGlobalGen
+        e.Nested
+        (e.GenericMatches)
+      >;
+
+  (e.Nested) (e.GenericMatches)
+    = <OptTree-AutoMarkup-GetVariableMatchesByIndexedGlobalGen
+        e.Nested
+        (e.GenericMatches)
+      >;
+
+  e.Other
+    = ;
+}
+
+OptTree-AutoMarkup-GetVariableMatches {
+  (e.GenericMatches) (e.IndexedGlobalGens)
+    = <Map
+        {
+          e.IndexedGlobalGenNode
+            = <OptTree-AutoMarkup-GetVariableMatchesByIndexedGlobalGen
+                (e.IndexedGlobalGenNode)
+                (e.GenericMatches)
+              >;
+        }
+        e.IndexedGlobalGens
+      >
+}
+
+OptTree-AutoMarkup-GetVariablesTypes{
+  ()
+    = ();
+
+  TkVariable 's' e._
+    = TkVariable 's';
+  TkVariable 't' e._
+    = TkVariable 't';
+  TkVariable 'e' e._
+    = TkVariable 'e';
+
+  Symbol e.Tail
+    = Symbol e.Tail;
+
+  Symbol Char e.Tail
+    = Symbol Char e.Tail;
+
+  Brackets e.Nested
+    = <Map
+        &OptTree-AutoMarkup-GetVariablesTypes
+        e.Nested
+      >
+      : e.NestedRes
+    = Brackets e.NestedRes;
+
+  (e.Nested) e.Tail
+    = (<OptTree-AutoMarkup-GetVariablesTypes e.Nested>)
+      <OptTree-AutoMarkup-GetVariablesTypes e.Tail>;
+
+  e.Other
+    = e.Other;
+}
+
+OptTree-AutoMarkup-IsAllEqual {
+  (e.Single)
+    = True;
+
+  (e.Value) (e.Value)
+    = True;
+
+  (e.First) (e.Next) e.Tail
+    , e.Next : e.First
+    = <OptTree-AutoMarkup-IsAllEqual (e.First) e.Tail>;
+
+  e._
+    = False;
+}
+
+OptTree-AutoMarkup-GetMatchesByVariableName {
+  (e.Key) (e.Head (e.Value ':' (e.Key)) e.Tail)
+    = (e.Value);
+
+  (e.Key) e.Other
+    = ;
+}
+
+OptTree-AutoMarkup-GetVariableSpecType {
+  (e.VariableMatchesDict)
+    = <Map
+        {
+          (t.VariableType '.' t.VariableIndex ':' e.Matches)
+            = <OptTree-AutoMarkup-IsAllEqual e.Matches>
+              : {
+                  True
+                    = (t.VariableType '.STAT' t.VariableIndex);
+
+                  False
+                    = (t.VariableType '.dyn' t.VariableIndex);
+                }
+        }
+        e.VariableMatchesDict
+      >
+}
\ No newline at end of file
diff --git a/src/compiler/OptTree-AutoMarkup.ref b/src/compiler/OptTree-AutoMarkup.ref
index 6a1f7fd0..0ca75f17 100644
--- a/src/compiler/OptTree-AutoMarkup.ref
+++ b/src/compiler/OptTree-AutoMarkup.ref
@@ -1,10 +1,195 @@
+$INCLUDE "LibraryEx";
+
+*$FROM Log
+$EXTERN Log-PutLine, Log-AST;
+
+*$FROM DisplayName
+$EXTERN DisplayName;
+
+*$FROM OptTree-AutoMarkup-GraphExtractor
+$EXTERN OptTree-AutoMarkup-ExtractFunctionCallsGraph;
+
+*$FROM OptTree-AutoMarkup-SpecializableExtractor
+$EXTERN OptTree-AutoMarkup-GetSpecializableDict;
+
+*$FROM OptTree-AutoMarkup-BasisVertexesExtractor
+$EXTERN OptTree-AutoMarkup-ExtractBasisVertexes;
+
+*$FROM OptTree-AutoMarkup-Common
+$EXTERN OptTree-AutoMarkup-Contains,
+        OptTree-AutoMarkup-GetSetDifference,
+        OptTree-AutoMarkup-IsEmpty;
+
 /**
   <OptTree-AutoMarkup s.OptAutoMarkup e.AST> == e.AST
 */
+
 $ENTRY OptTree-AutoMarkup {
-  NoOpt e.AST = e.AST;
+  NoOpt e.AST
+    = <Log-PutLine 'AutoMarkup is disabled'> :
+    = e.AST;
 
   OptAutoMarkup e.AST
-*   TODO: реализовать разметку
-    = e.AST;
+    = <OptTree-AutoMarkup-GetSpecializableDict (e.AST)>
+      : e.SpecializableDict
+    = <OptTree-AutoMarkup-GetForbiddenToSpecializeFunctionNames (e.AST)>
+      : e.ForbiddenToSpecializeFunctionNames
+    = <OptTree-AutoMarkup-GetSpecializePatterns
+        (e.SpecializableDict)
+        (e.ForbiddenToSpecializeFunctionNames)
+      >
+      : e.SpecPatterns
+    = <OptTree-AutoMarkup-ExtractFunctionCallsGraph e.AST>
+      : e.ExtractedGraph
+    = <OptTree-AutoMarkup-ExtractBasisVertexes e.ExtractedGraph>
+      : (e.BasisVertexes) (e.ExtractedGraph^)
+    = <OptTree-AutoMarkup-GetDrivenFunctions
+        (e.ExtractedGraph)
+        (e.BasisVertexes)
+      >
+      : e.DrivenFunctions
+    = <OptTree-AutoMarkup-GetForbiddenToDriveFunctions e.AST>
+      : e.ForbiddenToDriveFuncs
+    = <OptTree-AutoMarkup-GetSetDifference
+        (e.DrivenFunctions)
+        (e.ForbiddenToDriveFuncs)
+      >
+      : (e.FunctionToDrive)
+    = <OptTree-AutoMarkup-GetUpdatedWithDrivenFunctionsAst
+        (e.AST)
+        (e.FunctionToDrive)
+        (e.BasisVertexes)
+      >
+      : e.DrivedAst
+    = e.DrivedAst e.SpecPatterns;
+}
+
+OptTree-AutoMarkup-GetForbiddenToSpecializeFunctionNames {
+  (e.AST)
+    = <Map
+        {
+          (Spec (e.Name) e.SpecPattern)
+            = (e.Name);
+
+          (Function s.ScopeClass (e.FuncName) Sentences e.Body)
+            , (e.FuncName) : (e.FuncName '@' e.FuncNameTail)
+            = (e.FuncName);
+
+          (Function s.ScopeClass (e.FuncName) Sentences e.Body)
+            , (e.FuncName) : (e.FuncNameMain SUF e.FuncNameTail)
+            = (e.FuncName);
+
+          e.Other
+            = ;
+        }
+        e.AST
+      >
+}
+
+OptTree-AutoMarkup-GetSpecializePatterns {
+  (e.SpecializableDict) (e.Filter)
+    = <Map
+        {
+          (SPECIALIZABLE (e.FuncName) '->' (e.SpecifiedPattern))
+            , <OptTree-AutoMarkup-Contains (e.FuncName)(e.Filter)> : False
+            , <OptTree-AutoMarkup-IsEmpty (e.SpecifiedPattern)> : False
+            = <Map
+                {
+                  (e.Variable)
+                    = (TkVariable e.Variable)
+                }
+                e.SpecifiedPattern
+              >
+              : e.MarkedSpecPattern
+            = (Spec (e.FuncName) e.MarkedSpecPattern);
+
+          e.Other
+            = ;
+        }
+        e.SpecializableDict
+      >
+}
+
+OptTree-AutoMarkup-GetForbiddenToDriveFunctions {
+  e.AST
+    = (INIT) (FINAL)
+      <Map
+        {
+          (s.Label e.Name)
+            , <OptTree-AutoMarkup-Contains
+                (s.Label)
+                ((Drive)(Inline)(Intrinsic))
+              > : True
+            = (e.Name);
+
+          (Declaration GN-Entry e.FuncName)
+            = (e.FuncName);
+
+          (Function GN-Entry (e.FuncName) Sentences e.Body)
+            = (e.FuncName);
+
+          (Function s.Scope (e.FuncName) Sentences e.Body)
+            , (e.FuncName) : (e.Head '*' s.Num e.Tail)
+            = (e.FuncName);
+
+          (Function s.Scope (e.FuncName) Sentences e.Body)
+            = <Lenw e.Body>
+              : s.SentencesCount e.Body^
+            = <TermCompare s.SentencesCount 20>
+              : {
+                  '>'
+                    = (e.FuncName);
+
+                  e.Other
+                    = ;
+                };
+
+          e.Other
+            = ;
+        }
+        e.AST
+      >
+}
+
+OptTree-AutoMarkup-GetDrivenFunctions {
+  (e.ExtractedGraph) (e.BasisVertexes)
+    = <Map
+        {
+          (Func (Indirect function for implicit calls) Children (e.Children))
+            = ;
+
+          (Func (e.FuncName) Children (e.Children))
+          , <OptTree-AutoMarkup-Contains (e.FuncName)(e.BasisVertexes)> : False
+            = (e.FuncName);
+
+          e.Other
+            = ;
+        }
+        e.ExtractedGraph
+      >
 }
+
+OptTree-AutoMarkup-GetUpdatedWithDrivenFunctionsAst {
+  (e.AST) (e.FunctionsToDrive) (e.BasisVertexes)
+    = <Map
+        {
+          (e.FuncName)
+            = (Drive e.FuncName);
+        }
+        e.FunctionsToDrive
+      >
+      : e.DrivedFunctions
+    = <Map
+        {
+          (Drive e.Name)
+            , e.BasisVertexes : e._ (e.Name) e._
+            = ;
+
+          t.Other
+            = t.Other;
+        }
+        e.AST
+      >
+      : e.ClearAST
+    = e.ClearAST e.DrivedFunctions;
+}
\ No newline at end of file