anchor.diff:  
       let move stateSet symbol = 
           Set.map 
  -            (fun state -> Set.map 
  -                               (fun rule -> rule.ToStateID)
  -                               (Set.filter 
  -                                     (fun rule -> rule.FromStateID = state && rule.Symbol = symbol) 
  -                                     nlfa.NRules))
  +            (fun state -> 
  +                Set.map 
  +                    (fun rule -> rule.ToStateID)
  +                    (Set.filter 
  +                            (fun rule -> rule.FromStateID = state && rule.Symbol = symbol) 
  +                            nlfa.NRules))
               stateSet
               |> Set.unionMany
   
  
positive.code:                             else elt::buf)
                          []
                          lst
                  |> Set.ofList
  
              let _rules =
                  List.map 
  
negative.code:                 symbols
      done
  
      let revert rules = 
          List.map (fun (x,y,z) -> (z,y,x)) rules
  
      let minimaze z =
          let states = 
              List.fold (fun buf (_from,_,_to) ->  Set.add _from buf |> Set.add _to) Set.empty (!newRules)
              |> List.ofSeq
  
          let startStates = 
              (List.filter (Set.exists (fun x -> (=) x  z)) states)
  
          
          let rules = revert (!newRules) |> Set.ofList
  
          let lMove stateSet symbol rules = 
              Set.map 
                  (fun state -> 
                      Set.map 
                          (fun (f,s,t) -> t)
                          (Set.filter 
                                  (fun (f,s,t) -> f = state && s = symbol) 
                                  rules))
                  stateSet
                  |> Set.unionMany
                  
                             
          let visitedNewStates = ref []
          let notVisitedNewStates = List.map Set.singleton startStates |> ref
          let lNewRules = ref []
  
          
          while not (List.isEmpty !notVisitedNewStates) do
              let T = (!notVisitedNewStates).Head
              visitedNewStates :=  T :: !visitedNewStates
              notVisitedNewStates := (!notVisitedNewStates).Tail
              Set.iter
                      (fun symbol ->
                      let U = lMove T symbol rules
                      if not (Set.isEmpty U)
                          then
                              if  not ((List.exists ((=)U) !notVisitedNewStates)  || (List.exists ((=)U) !visitedNewStates))
                              then 
                                  notVisitedNewStates := U :: !notVisitedNewStates
                              lNewRules := (T,symbol,U)::!lNewRules)
                      symbols
          done
          
          newRules := List.map (fun (a,b,c) -> Set.unionMany a , b , Set.unionMany c) !lNewRules
  
  
      let newAutomata  = 
          //minimaze nlfa.NFinaleState
          //printf "First Minimize end\n"
          //minimaze nlfa.NStartState
          //printf "Second Minimize end\n"
          let states = 
              List.fold (fun buf (_from,_,_to) ->  Set.add _from buf |> Set.add _to) Set.empty (!newRules)            
              |> List.ofSeq
  
          printf "States set: \n"
          List.iter (fun s -> printf "["; Set.iter (printf "%A;") s; printf"];") states
          printf "\n"
  
          printf "is printed \n"
           
          let alterNames = dict (List.zip states [0..(List.length states)-1])
          let getAlterName s = alterNames.[s]            
  
          let startState = getAlterName (List.find (Set.exists ((=)nlfa.NStartState)) states)
          let finaleStates = List.filter (Set.exists (fun x -> (=) x  nlfa.NFinaleState)) states
          let alterFinaleStates = List.map getAlterName finaleStates
          let dummyStates = 
              let l = List.length states
  