anchor.diff:                              let nonTerminals2,_,_,_ = recTable.[k+i+1,l-k-1]
                               let nonTerminals,_,_,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),(rule::rules))
  +                            then recTable.[i,l] <- (a::nonTerminals),(i,k),(k+i+1,l-k-1),(rule::rules)
           |_               -> ()   
   
      let elem i l = rules |>  Array.iter (fun rule -> for k in 0..(l-1) do processRule rule i k l)
  
positive.code:          match currentRule with
           |ToBranch(_,left,right) -> left,right
           |ToLeaf(_,terminal)     -> terminal.ToString(),""  
        match (i,l) with 
        |(_,0) -> [ToLeaf(top,leftNT.[0])]
        |_     -> currentRule::(subRecognize leftI leftL leftNT)@(subRecognize rightI rightL rightNT)
     let resultRules = if List.exists ((=)start) ((fun (a,_,_,_) -> a) recTable.[0,s.Length-1])
                       then subRecognize 0 (s.Length-1) start//если цепочка принадлежит языку L(g)
                       else []
  
     System.Console.WriteLine(s)
     System.Console.WriteLine("Rules:")
     printRules resultRules
     //printOutput resultRules start    
  
  
negative.code:                                                                        
  let recognitionTable (rules,_) (s:string) = 
             
     let recTable = Microsoft.FSharp.Collections.Array2D.create s.Length s.Length ([],(0,0),(0,0),[])
     //recTable(i,l), для l > 0
  
     let inline processRule rule i k l =
  