anchor.diff:                          |> Set.map (fun nfaState ->
                               Map.find nfaState nfa.FinalStates)
   
  -                    (* If this DFA state accepts more than one of the input Regexes,
  -                       it means those Regexes overlap. Since a DFA state can only
  -                       accept a single Regex, we simply choose the Regex with the
  -                       lowest-valued index; this convention is a de-facto standard
  -                       for lexer generators. *)
  -                    (* TODO :   Add something to the compilation result so we can log
  -                                any occurrences of this 'disambiguation' and perhaps
  -                                also emit an MSBuild-style warning message to let the
  -                                user know the patterns overlap. *)
  +                    (* If this DFA state accepts more than one of the input Regexes, it means
  +                       those Regexes overlap. Since a DFA state can only accept a single Regex,
  +                       we simply choose the Regex with the lowest-valued index; this convention
  +                       is a de-facto standard for lexer generators. *)
   
                       /// The (index of) the Regex accepted by this DFA state.
                       let acceptedRegex = Set.minElement finalStateInputRegexes
   
  +                    // If there was more than one final state, add information about the
  +                    // overlapped states to 'regexOverlapInfo'.
  +                    let regexOverlapInfo =
  +                        if Set.count finalStateInputRegexes = 1 then
  +                            regexOverlapInfo
  +                        else
  +                            let overlapInfo = {
  +                                Accepted = acceptedRegex;
  +                                Overlapped = Set.remove acceptedRegex finalStateInputRegexes; }
  +                            overlapInfo :: regexOverlapInfo
  +
                       // Add this DFA state and the accepted Regex to the map.
  -                    Map.add dfaState acceptedRegex finalStates)
  +                    Map.add dfaState acceptedRegex finalStates,
  +                    regexOverlapInfo)
   
           // Create the DFA.
           let dfa =
  
positive.code:     // Return the compiled DFA, discarding any additional data in the result.
      compilationResult.Dfa
  
  
  (* TODO :   Implement an 'ofNfaWithLog' function which is similar to 'ofNfa'
              but takes an additional parameter (e.g., a TextWriter) which it
              will use to log additional compilation information before returning
              the compiled DFA. *)
  
  
  /// Minimizes a Dfa.
  let minimize (dfa : Dfa<'Symbol>) : Dfa<'Symbol> =
      raise <| System.NotImplementedException "Dfa.minimize"
  
  //
  let tokenize (dfa : Dfa<'Symbol>) (symbols : seq<'Symbol>) : seq<'Symbol[]> =
  
negative.code:                 // If any of the NFA states in this DFA state are final (accepting) states,
                  // then this DFA state is also an accepting state.
                  if Set.isEmpty nfaFinalStateSet then
                      finalStates, regexOverlapInfo
                  else
                      /// The (indices of the) Regexes accepted by this DFA state.
                      let finalStateInputRegexes =
  