anchor.diff:      let printTableLabels = 
           (function
           | Some v -> v
  -        | None -> "--")
  +        | None   -> "--")
           |> List.map
           >>String.concat "; "
               
  
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: // It is part of YaccConstructor.
  namespace CYK
  
  
  //(16|   16| 16|8       |       8  |)
  //(E |->  Z|  X|<lblName|lblWeight>|)
  type rule = uint64 
  
  type CYKGrammar = array<rule>
  
  [<AutoOpen>]
  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
          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) &&& 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 = 
  