anchor.diff:                              (match rule.body with PSeq(e, a, l) -> a | x -> None),
                               (match rule.body with PSeq(e, a, l) -> l | x -> None))
                   |x -> rule.body
  -            let addRule (numberRule: Rule.t<_, _>) (eps: int list) = 
  +            let addRule (numberRule: Rule.t<_, _>) eps =                
                   [{
                       name=numberRule.name
                       args=numberRule.args
                       _public=numberRule._public
                       metaArgs=numberRule.metaArgs
                       body=PSeq(
  -                                (match numberRule.body with PSeq(e, a, l) -> e | x -> []) |> List.collect 
  +                                (match numberRule.body with PSeq(e, a, l) -> e | x -> [])
  +                                |> List.collect 
                                       (fun elem ->
                                           match elem.rule with
                                           |PRef(t, _) when 
  -                                            eps 
  -                                            |> List.map (fun e -> e.ToString()) 
  -                                            |> List.exists (fun e -> (e = (fst t))) -> []
  +                                            eps
  +                                            |> List.map (fun e -> string e) 
  +                                            |> List.exists (fun e -> e = fst t) -> []
                                           |PRef(t, _) when 
                                               not (
                                                   eps 
  
positive.code:     //--Функция для проверки вхождения эпсилон-правила---------------------------------------------
  
      let isEps s = 
          epsList |> List.collect
              (fun eps -> if s = eps then [eps] else [])
      
      //--Список эпсилон-правил входящих в данное правило--------------------------------------------     
  
  
negative.code:                         elements |> List.collect
                              (fun elem ->
                                  match elem.rule with
                                  |PRef(t, _) when fst t |> isEps |> List.isEmpty |> not-> 
                                      incr i
                                      [{
                                          omit = elem.omit
  