anchor.diff:                                      | 0uy -> LblState.Undefined
                                       | _   -> LblState.Defined
                                   let currentElem = buildData ruleIndex lState rl rw
  -                                (recTable.[k,0]).Add (new CellData(currentElem,0u))                                                                
  +                                recTable.[k,0].Add (new CellData(currentElem,0u))                                                                
                       |_ -> ())
       
           fillTable 0 1
  
positive.code: 
      let recognize ((grules, start) as g) s weightCalcFun =
          let recTable = recognitionTable g s weightCalcFun
          (*
          let rec derivation i l top = 
              let nonterminals,bs,cs,rls,rws,lStates,cls,cws = getCellData recTable.[i,l]
              let leftI,leftL,rightI,rightL = getCellCoordinates recTable.[i,l]
              let suitable = ResizeArray.mapi (fun i a -> match a with
                                                          |top -> i) nonterminals
              //for k in 0..(suitable.Count-1) do
              let k = 0
              let curInd = suitable.[k]
              let curRule = top,bs.[curInd],cs.[curInd],cls.[curInd],cws.[curInd]
              let leftNT,rightNT = bs.[curInd],cs.[curInd]
              match i,l with
              |_,0 -> [curRule]
              |_ ->  curRule::((derivation leftI leftL leftNT)@(derivation rightI rightL rightNT))
                      
          let startNTs,_,_,_,_,_,_,_ = getCellData recTable.[0,s.Length-1]
          let result = if ResizeArray.exists((=) start) startNTs
                       then derivation 0 (s.Length-1) start
                       else []
  
          result
          *)
  
          let getString state (lbl:uint8) (weight:uint8) : string = 
              let stateString = 
                  match state with
                  |LblState.Defined -> "defined"
  
negative.code:                                 let newLabel,newlState = chooseNewLabel rl lbl1 lbl2 lState1 lState2
                                  let newWeight = weightCalcFun rw weight1 weight2
                                  let currentElem = buildData ruleIndex newlState newLabel newWeight
                                  recTable.[i,l].Add (new CellData(currentElem,uint32 k))
  
          let elem i l = rules |> Array.Parallel.iteri (fun ruleIndex rule -> for k in 0..(l-1) do processRule rule ruleIndex i k l)
  
  