anchor.diff:      //Вывод правил
       let printRules =
          (function
  -       | ToBranch(a,b,c,_),l -> [a; "->"; b; c; "  "; (match l with | Some t -> t | None -> "")]
  +       | ToBranch(a,b,c,_,_),l -> [a; "->"; b; c; "  "; (match l with | Some t -> t | None -> "")]
          | ToLeaf(a,b,_),l     -> [a;"->";b.ToString();"  "; (match l with | Some t -> t | None -> "") ]
          >> String.concat "")
          |> List.map
  
positive.code:           for k in 0..(s.Length-1) do
               match rule with
               |ToLeaf(a,b,l) -> if b = s.[k] then
                                  let nonTerminals,_,_,lbl,rules = recTable.[k,0]
                                  recTable.[k,0] <- ((a::nonTerminals),(-1,-1),(-1,-1),(l::lbl),(rule::rules))
               |_           -> ()
         //последующие столбцы
         fillTable 0 1
  
negative.code:              | None, None -> ruleLbl
               | _ -> List.find (Option.isSome) [lbls1.Head;lbls2.Head] 
  
         let newWeight ruleWeight (weights1:List<Option<int>>) (weights2:List<Option<int>>) : Option<int> = 
               match (weights1.IsEmpty,weights2.IsEmpty) with
               |true,true -> ruleWeight 
               |_ ->    
                   match weights1.Head,weights2.Head with
                   |Some w1, Some w2 -> Some(w1 + w2)
                   |None, None -> ruleWeight
                   |_ -> List.find (Option.isSome) [weights1.Head;weights2.Head] 
  
         let processRule rule i k l =
              match rule with
              |ToBranch(a,b,c,ruleLbl,ruleWeight) ->
                  let nonTerminals1,_,_,lbls1,weights1,_ = recTable.[i,k]
                  let nonTerminals2,_,_,lbls2,weights2,_ = recTable.[k+i+1,l-k-1]
                  let nonTerminals,_,_,lbls,weights,rules = recTable.[i,l]
                  if (List.exists ((=)b) nonTerminals1) && (List.exists ((=)c) nonTerminals2)
                  then
                      recTable.[i,l] <- (a::nonTerminals),(i,k),(k+i+1,l-k-1),(newLbl ruleLbl lbls1 lbls2 ::lbls),(newWeight ruleWeight weights1 weights2 ::weights),(rule::rules)    
              |_               -> ()   
  
         let elem i l = rules |> Array.iter (fun rule -> for k in 0..(l-1) do processRule rule i k l)
  