anchor.diff:              let emit n = 
                   if trans.ContainsKey(n) then 
                     outputCodedUInt16 os trans.[n].Id 
  +                  trans.[n].Id 
                   else
                     outputCodedUInt16 os sentinel
  +                  sentinel
               for i = 0 to numLowUnicodeChars-1 do 
                   let c = char i
  -                emit (EncodeChar c);
  +                tableTransitions.[state.Id].[i] <- emit (EncodeChar c);
  +            k := numLowUnicodeChars - 1
               for c in specificUnicodeChars do 
                   outputCodedUInt16 os (int c); 
  -                emit (EncodeChar c);
  +                tableTransitions.[state.Id].[(incr k; !k)] <- emit (EncodeChar c);
               for i = 0 to NumUnicodeCategories-1 do 
  -                emit (EncodeUnicodeCategoryIndex i);
  -            emit Eof;
  +                tableTransitions.[state.Id].[(incr k; !k)] <- emit (EncodeUnicodeCategoryIndex i);
  +            tableTransitions.[state.Id].[(sizeTable - 1)] <- emit Eof;
               cfprintfn os "|];"
           done;
       
  
positive.code:         // Each entry is an encoded UInt16 value indicating the next state to transition to for this input.
          //
          // For the SpecificUnicodeChars the entries are char/next-state pairs.
          for state in dfaNodes do
              cfprintfn os "    (* State %d *)" state.Id;
              fprintf os "     [| ";
  
negative.code:         let resFST = new FST<_,_>()
          resFST.InitState.Add((fst perRuleData.[0]).Id) //we SUGGEST that we have one init state
          
          let stEOF = tableTransitions.[0].[(sizeTable - 1)] 
          new TaggedEdge<_,_>(0, stEOF, new EdgeLbl<_,_>(Smbl (char Eof), Eps)) |> resFST.AddVerticesAndEdge |> ignore
          resFST.FinalState.Add(stEOF)
                           
          for state in dfaNodes do
              for i in 0..(sizeTable - 1) do
                  let st = tableTransitions.[state.Id].[i]
                  if st <> sentinel 
                  then 
                      new TaggedEdge<_,_>(state.Id, st, new EdgeLbl<_,_>(Smbl (char (if i = sizeTable - 1 then int Eof else i)), Eps)) |> resFST.AddVerticesAndEdge |> ignore                       
                  else 
                      if state.Id <> 0
                      then 
                          let action = if actionFunc.[state.Id].Count > 0 then Smbl (actionFunc.[state.Id].[0]) else Eps
                          if tableTransitions.[0].[i] <> sentinel || i = sizeTable - 1
                          then  
                              new TaggedEdge<_,_>(state.Id, tableTransitions.[0].[i], new EdgeLbl<_,_>(Smbl (char (if i = sizeTable - 1 then int Eof else i)), action)) |> resFST.AddVerticesAndEdge |> ignore
                              
          let getVal printV s = 
              match s with
  