anchor.diff:              // or not the lexer is generated with support for Unicode.
               let stateTransitionEmitter =
                   if options.Unicode then
  -//                    /// The set of Unicode transition chars used to label state-transition-edges,
  -//                    /// minus the low ASCII characters and complete Unicode categories.
  -//                    let specificUnicodeChars =
  -//                        compiledRules
  -//                        |> UnicodeLexer.transitionChars
  -//                        |> UnicodeLexer.specificUnicodeChars
  -                    UnicodeLexer.transitionVectorElements
  +                    /// The set of Unicode transition chars used to label state-transition-edges,
  +                    /// minus the low ASCII characters and complete Unicode categories.
  +                    let specificUnicodeChars = UnicodeLexer.transitionChars compiledRules
  +                    UnicodeLexer.transitionVectorElements specificUnicodeChars
                   else
                       AsciiLexer.transitionVectorElements
   
  
positive.code:         characters which don't actually have a transition out of the current state.
      *)
  
      /// Emits the elements into a Unicode transition table row for the given DFA state.
      let transitionVectorElements (*specificUnicodeChars*) compiledRule ruleDfaStateId baseDfaStateId (indentingWriter : IndentedTextWriter) =
          // Preconditions
          // TODO
  
          let ruleDfaTransitions = compiledRule.Dfa.Transitions
  
          /// The transitions out of this DFA state, keyed by the
          /// character labeling the transition edge.
          // OPTIMIZE : This should use an IntervalMap for better performance.
          // Additionally, it should be created on-the-fly while creating the DFA instead of having to re-compute it here.
          let outTransitions =
              (Map.empty, ruleDfaTransitions.AdjacencyMap)
              ||> HashMap.fold (fun outTransitions edgeKey edgeSet ->
                  // Filter to include only this DFA state's out-edges.
                  if edgeKey.Source <> ruleDfaStateId then
                      outTransitions
                  else
                      // Add the transition edges to the map.
                      let target = edgeKey.Target + baseDfaStateId
  
                      (outTransitions, edgeSet)
                      ||> CharSet.fold (fun outTransitions c ->
                          Map.add c target outTransitions))
  
          // Emit the transition vector elements for the lower range of ASCII elements [0-127].
          for c = 0 to 127 do
  
negative.code: 
          //
          let unicodeCategoryTransitions, unicodeCharTransitions =
              optimizeTransitions outTransitions
  
          // Emit entries for specific Unicode elements.
          // Note that fslex requires the transition vectors for every state in the DFA to contain the same number
          // of entries for specific Unicode characters, so we may need to emit entries for characters which don't
          // label a transition edge from this state (in that case, we emit an entry which transitions to the error state).
          unicodeTransitionChars
          |> CharSet.iter (fun c ->
              // The state targeted by the transition edge labeled by 'c'.
              let targetStateId =
                  // First, check to see if this state has a specific Unicode transition for 'c'.
                  unicodeCharTransitions
                  |> Map.tryFind c
                  //
                  |> Option.bind id
                  // If there wasn't a specific transition for this character, is there a transition
                  // for this character's Unicode category?
                  |> Option.tryFillWith (fun () ->
                      let category = System.Globalization.CharUnicodeInfo.GetUnicodeCategory c
                      Map.tryFind category unicodeCategoryTransitions
                      |> Option.bind id)
                  // If this state doesn't have an out-transition-edge labeled with 'c',
                  // transition to the error state (by using the sentinel value as the target state id).
                  |> Option.fill (tag <| int sentinelValue)
  
              // Emit the character itself (as a uint16).
              writeUInt16LiteralElement indentingWriter <| uint16 c
  
              // Emit the target state ID.
              writeUInt16LiteralElement indentingWriter <| Checked.uint16 targetStateId)
  