anchor.diff:              processSuccessors node operands' automata' unionNodes
   
           let entriesNum = ddg.Graph.InEdges(node) |> List.ofSeq |> List.length
  -        if entriesNum > 1
  -        // union node processing (loop, if-block end, etc.)
  +        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 optAutomataMaps = Map.tryFind node unionNodes
  +            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(_, bodyNodeIndex) ->
  -//                match optAutomataMaps 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
  
positive.code:     let setLoopExitDirection node dirHelper = 
          setDirection node dirHelper isLoopExitOrOuterNode
  
      let isRightDirection node (dirHelper: LoopsDirectionHelper) =
          if not <| List.isEmpty dirHelper.Stack
          then
              let loopInfo, checker = List.head dirHelper.Stack
              let isRightDir = checker node loopInfo
  
negative.code: //                | None -> 
  //                    // just start processing body
                  failwith unsupportedCaseMsg
              | _ -> processNodeAndSuccessors node operands unionFsaMap unionNodes'
      
      let varFsaMap, _ = build ddg.Root [] Map.empty Map.empty
      let nfsa = Map.find ddg.VarName varFsaMap
  