anchor.diff:      //--Функция для добавления нового правила------------------------------------------------------
   
       let newRule (rule: Rule.t<_, _>) (epsRef: string list) = 
  -        
           if not epsRef.IsEmpty then
  -            incr index
  -            [{
  -                name=rule.name
  -                args=[]
  -                _public=rule._public
  -                metaArgs=[]
  -                body=PSeq(
  -                                (match rule.body with PSeq(e, a, l) -> e | x -> []) |> List.collect 
  +            let numberEpsRef = genPermutation epsRef.Length 
  +            let numberBody = 
  +                let i = ref 0
  +                match rule.body with
  +                |PSeq(elements, _, _) -> 
  +                    PSeq(
  +                        elements |> List.collect
  +                            (fun elem ->
  +                                match elem.rule with
  +                                |PRef(t, _) when not (isEps (fst t)).IsEmpty -> 
  +                                    incr i
  +                                    [{
  +                                        omit = elem.omit
  +                                        rule = PRef(( (!i).ToString(), (0, 0)), None)
  +                                        binding = elem.binding
  +                                        checker = elem.checker
  +                                    }]
  +                                |x -> [elem]
  +                            ),
  +                            (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) = 
  +                [{
  +                    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 
                                       (fun elem ->
                                           match elem.rule with
  -                                        |PRef(t, _) when not (isEps (fst t)).IsEmpty -> []
  +                                        |PRef(t, _) when 
  +                                            eps 
  +                                            |> List.map (fun e -> e.ToString()) 
  +                                            |> List.exists (fun e -> (e = (fst t))) -> []
  +                                        |PRef(t, _) when 
  +                                            not (
  +                                                eps 
  +                                                |> List.map (fun e -> e.ToString()) 
  +                                                |> List.exists (fun e -> (e = (fst t)))) -> 
  +                                             [{
  +                                                omit = elem.omit
  +                                                rule = PRef((epsRef.Item(System.Convert.ToInt32(fst t) - 1).ToString(), (0, 0)), None)
  +                                                binding = elem.binding
  +                                                checker = elem.checker
  +                                            }]
                                           |x -> [elem]
                                       )
                                   ,
  -                                (match rule.body with PSeq(e, a, l) -> a | x -> None), 
  -                                (match rule.body with PSeq(e, a, l) -> l | x -> None))
  -            }]
  +                                (match numberRule.body with PSeq(e, a, l) -> a | x -> None), 
  +                                (match numberRule.body with PSeq(e, a, l) -> l | x -> None))
  +                }]
  +            let numberRule = 
  +                {
  +                    name=rule.name
  +                    args=rule.args
  +                    _public=rule._public
  +                    metaArgs=rule.metaArgs
  +                    body=numberBody
  +                }
  +            numberEpsRef |> List.collect
  +                (fun eps ->
  +                    addRule numberRule eps)
           else
               []
  -
  +            
  +            
       //--Добавляем новые правила--------------------------------------------------------------------
       
       ruleList |> List.collect
  
positive.code: 
  let deleteEpsRule (ruleList: Rule.t<_, _> list) = 
      
      //--Находим все эпсилон-правила----------------------------------------------------------------
  
      let epsList = 
  
negative.code: open System.Collections.Generic
  open Yard.Core.IL.Rule
  
  //--Функция которая удаляет правила в правиле------------------------------------------------------
  
  let private reductionRule (ruleList: Rule.t<_, _> list) = 
  
      let index = ref 0
  
      let reduction = ref []
      
  