anchor.diff:                              let lblWeight = 
                                   Microsoft.FSharp.Core.Operators.byte (lbl &&& Microsoft.FSharp.Core.Operators.uint16 0xFFFFFFFFu)
                               lblWeight
  -
  -                        let getRuleNum (rule:tblData) =
  -                            let rNum = Microsoft.FSharp.Core.Operators.uint32 ((rule >>> 32) &&&  0xFFFFFFFFUL)
  -                            rNum
  -
  +                            
                           let getLblState (rule:tblData) = 
                               let r2 = Microsoft.FSharp.Core.Operators.uint32 (rule &&& 0xFFFFFFFFUL)
                               let lState = Microsoft.FSharp.Core.Operators.uint16 ((r2 >>> 16) &&& 0xFFFFFFFFu)
  -                            let lblState =
  -                                match lState with
  -                                | 0us -> LblState.Defined
  -                                | 1us -> LblState.Undefined
  -                                | 2us -> LblState.Conflict
  -                                | _ -> failwith "Unexpected lblState value!"
  -                            lblState
  -
  +                            if lState = 0us then LblState.Defined
  +                            elif lState = 1us then LblState.Undefined
  +                            elif lState = 2us then LblState.Conflict
  +                            else failwith "Unexpected lblState value!"
  +                            
                           let getCellLabel(rule:tblData) = 
                               let r2 = Microsoft.FSharp.Core.Operators.uint32 (rule &&& 0xFFFFFFFFUL)
                               let lbl = Microsoft.FSharp.Core.Operators.uint16 (r2 &&& 0xFFFFFFFFu)
  
positive.code:                             let lbl = Microsoft.FSharp.Core.Operators.uint16 (r2 &&& 0xFFFFFFFFu)
                              let lblWeight = Microsoft.FSharp.Core.Operators.byte (lbl &&& 0xFFFFus)
                              lblWeight
                              
                          let getCellRuleTop (cellData:CellData) (rules:rule[]) =
                              let curRuleNum = getRuleNum cellData.rData
                              let ruleName = getRuleName rules.[int curRuleNum]
                              ruleName
                                                      
                          let buildData rNum (lState:LblState) (lblName:Microsoft.FSharp.Core.uint8) (lblWeight:Microsoft.FSharp.Core.uint8) =
                              let (lbl:Microsoft.FSharp.Core.uint16) = 
                                  (Microsoft.FSharp.Core.Operators.uint16 lblName <<< 8) ||| Microsoft.FSharp.Core.Operators.uint16 lblWeight
                              let (r2:Microsoft.FSharp.Core.uint32) = (uint32 lState <<< 16) ||| uint32 lbl
                              let r =  (uint64 rNum <<< 32) ||| uint64 r2
                              r
  
                          let chooseNewLabel ruleLabel (lbl1:byte) (lbl2:byte) lState1 lState2 =
                              if lState1 = LblState.Conflict then [| int noLbl; int LblState.Conflict |] // new LabelWithState(noLbl, LblState.Conflict)
                              elif lState2 = LblState.Conflict then [| int noLbl; int LblState.Conflict |] // new LabelWithState(noLbl, LblState.Conflict)
                              elif lState1 = LblState.Undefined && lState2 = LblState.Undefined && ruleLabel = noLbl then [| int noLbl; int LblState.Undefined |] // new LabelWithState(noLbl, LblState.Undefined)
                              else
                                  let mutable notEmptyLbl1 = noLbl
                                  let mutable notEmptyLbl2 = noLbl
                                  let mutable notEmptyLbl3 = noLbl 
                                  let mutable realLblCount = 0
                                  if lbl1 <> noLbl then 
                                      notEmptyLbl1 <- lbl1
                                      realLblCount <- realLblCount + 1
                                  if lbl2 <> noLbl then
                                      if realLblCount = 0 then notEmptyLbl1 <- lbl2
                                      elif realLblCount = 1 then notEmptyLbl2 <- lbl2
                                      realLblCount <- realLblCount + 1
                                  if ruleLabel <> noLbl then 
                                      if realLblCount = 0 then notEmptyLbl1 <- ruleLabel
                                      elif realLblCount = 1 then notEmptyLbl2 <- ruleLabel
                                      elif realLblCount = 2 then notEmptyLbl3 <- ruleLabel
                                      realLblCount <- realLblCount + 1
  
                                  if realLblCount = 1 ||
                                      (realLblCount = 2 && notEmptyLbl2 = notEmptyLbl1) ||
                                      (realLblCount = 3 && notEmptyLbl2 = notEmptyLbl1 && notEmptyLbl3 = notEmptyLbl1)
                                  then [| int noLbl; int LblState.Defined |] // new LabelWithState(notEmptyLbl1, LblState.Defined)
                                  else [| int noLbl; int LblState.Conflict |] // new LabelWithState(noLbl, LblState.Conflict)
                      
                          let processRule rule ruleIndex i k l =
                              let r2 = getR2 rule
                              if r2 <> 0us then
  
negative.code:                                 for i in 1..columnIndex-1 do
                                      diff := (!diff + i)
                                  !diff
                                                                                              
                          let getRuleName (rule:rule) = 
                              let r1 = Microsoft.FSharp.Core.Operators.uint32 ((rule >>> 32) &&&  0xFFFFFFFFUL)
                              let rName = Microsoft.FSharp.Core.Operators.uint16 ((r1 >>> 16) &&& 0xFFFFFFFFu)
  