anchor.diff:  // It is part of YaccConstructor.
   namespace CYK
   
  -//(16|   16| 16|8       |       8  |) 
  +
  +//(16|   16| 16|8       |       8  |)
   //(E |->  Z|  X|<lblName|lblWeight>|)
  -type rule = int64 
  +type rule = uint64 
  +
  +type CYKGrammar = array<rule>
   
   [<AutoOpen>]
  -module RuleHelpers =
  +module RuleHelpers = 
  +    open System.Collections.Generic
  +    open  Yard.Core.IL
       let buildRule rName r1 r2 lblName lblWeight =
           let lbl = (uint16 lblName <<< 8) ||| uint16 lblWeight
           let r1 = (uint32 rName <<< 16) ||| uint32 r1
           let r2 = (uint32 r2 <<< 16) ||| uint32 lbl
  -        ((uint64 r1) <<< 32) ||| uint64 r2
  -
  -    let getRule (rule:uint64) =
  +        let r = ((uint64 r1) <<< 32) ||| uint64 r2
  +        r
  +
  +    let getRule (rule:rule) =
           let r1,r2 = uint32 ((rule >>> 32) &&&  0xFFFFFFFFUL), uint32 (rule &&& 0xFFFFFFFFUL)
           let rName,r1 = uint16 ((r1 >>> 16) &&& 0xFFFFFFFFu), uint16 (r1 &&& 0xFFFFFFFFu)
           let r2,lbl = uint16 ((r2 >>> 16) &&& 0xFFFFFFFFu), uint16 (r2 &&& 0xFFFFFFFFu)
  -        let lblName,lblWeight = uint8 ((lbl >>> 8) &&& uint8 0xFFFFFFFFu), uint8 (lbl &&& uint8 0xFFFFFFFFu)
  +        let lblName,lblWeight = uint8 ((lbl >>> 8) &&& uint16 0xFFFFFFFFu), uint8 (lbl &&& uint16 0xFFFFFFFFu)
           rName, r1, r2, lblName, lblWeight
  +
  +    // Now we are not support action code. So skip it.
  +    let grammarFromIL (il:Yard.Core.IL.Definition.t<_,_>) =
  +        let ntermDict = new Dictionary<_,_>()
  +        let termDict = new Dictionary<_,_>()
  +        let lblDict = new Dictionary<_,_>()
  +        let processRule (r:Rule.t<_,_>) =
  +            let name = r.name
  +            let body = r.body
  +            match body with
  +            | Production.PSeq ([t],_) -> ""
  +            | Production.PSeq ([nt1;nt2],_) -> ""
  +            | _ -> failwith "CYK. Incorrect rule structure. Must be in CNF"
  +            
  +        il.grammar |> List.map processRule
  +        
  +    let print rule = 
  +        let rName, r1, r2, lblName, lblWeight = getRule rule
  +        [rName]
   
   //Правила контекстно-свободной грамматики в нормальной форме Хомского
   type Rule = 
  
positive.code:              match lbls1.Head,lbls2.Head with
               | Some v1, Some v2 when v1<>v2 -> Some("conflict")
               | 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
  
negative.code:     let printTableLabels = 
          (function
          | Some v -> v
          | None   -> "--")
          |> List.map
          >>String.concat "; "
              
  