anchor.diff:     for rule in rules do
         for k in 0..(s.Length-1) do
            match rule with
  -         |ToLeaf(a,b) -> if b = s.[k] then
  -                            let nonTerminals,_,_,rules = recTable.[k,0]
  -                            recTable.[k,0] <- ((a::nonTerminals),(-1,-1),(-1,-1),(rule::rules))
  +         |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,(rule::rules))
            |_           -> ()
      //последующие столбцы
      fillTable 0 1
  
positive.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 =
          match rule with
          |ToBranch(a,b,c) -> let nonTerminals1,_,_,_ = recTable.[i,k]
                              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)
          |_               -> ()   
  
     let elem i l = rules |>  Array.iter (fun rule -> for k in 0..(l-1) do processRule rule i k l)
  
negative.code:    let recTable = recognitionTable g s
     //восстановление вывода по таблице начиная с ячейки recTable(i,l) нетерминала top
     let rec subRecognize i l top = 
        let nonTerminals,(leftI,leftL),(rightI,rightL),lbl,rs = recTable.[i,l]
        //правило вида А->_, где А = top
        let currentRule = List.find (fun (ToBranch(st,_,_,l)|ToLeaf(st,_,l)) -> st = top) rs
        let leftNT,rightNT = 
           match currentRule with
           |ToBranch(_,left,right,l) -> left,right
           |ToLeaf(_,terminal,l)     -> terminal.ToString(),""  
        match i,l with
        | _,0 -> [ToLeaf(top,leftNT.[0],None)]
        | _     -> currentRule::(subRecognize leftI leftL leftNT)@(subRecognize rightI rightL rightNT)
     let resultRules = if List.exists ((=)start) ((fun (a,_,_,_,l) -> a) recTable.[0, s.Length-1])
                       then subRecognize 0 (s.Length-1) start//если цепочка принадлежит языку L(g)
                       else []
  
  