anchor.diff:      let setLoopExitDirection node dirHelper = 
           setDirection node dirHelper isLoopExitOrOuterNode
   
  +    let hasRestrictions (dirHelper: LoopsDirectionHelper) =
  +        not <| List.isEmpty dirHelper.Stack
  +
       let isRightDirection node (dirHelper: LoopsDirectionHelper) =
  -        if not <| List.isEmpty dirHelper.Stack
  +        if hasRestrictions dirHelper
           then
               let loopInfo, checker = List.head dirHelper.Stack
               let isRightDir = checker node loopInfo
  
positive.code:     |> Seq.map (fun n -> n.Id, collectInfo n)
      |> Map.ofSeq
              
  type State = char * Position<int>
  type FSAMap = Map<string, FSA<State>>
  
  type DirectionChecker = GraphNode -> LoopInfo -> bool
  type LoopsDirectionHelper = {
      LoopsInfo: Map<int, LoopInfo>
  
negative.code:             processSuccessors node operands' automata' unionNodes
  
          let entriesNum = ddg.Graph.InEdges(node) |> List.ofSeq |> List.length
          let optTraversedEntries = Map.tryFind node unionNodes
          let traversedEntries = automata :: Option.getOrElse optTraversedEntries []
          let traversedNum = List.length traversedEntries
          let allEntriesTraversed =
              entriesNum = 0 ||
              match node.Type with
              | LoopNode(_, _) -> entriesNum - 1 = traversedNum // todo: support more than 2 entries
              | _ -> entriesNum = traversedNum
          if not allEntriesTraversed
          then
              let unionNodes' = Map.add node traversedEntries unionNodes
              automata, unionNodes'
          else
              // all paths leading to this node are traversed, we can union automata
              // and continue processing its successors
              let unionFsaMap = unionFsaMaps traversedEntries
              let unionNodes' = Map.remove node unionNodes
              match node.Type with
              | LoopNode(_, _) -> 
  //                let loopFsa = Map.tryFind node loopsFsa
  //                match loopFsa with
  //                | Some(fsaMaps) -> 
  //                    // we have already been in current loop node
  //                    let oldFsaMap = List.head fsaMaps
  