anchor.diff:                  // 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
  +                    finalStates, regexOverlapInfo
                   else
                       /// The (indices of the) Regexes accepted by this DFA state.
                       let finalStateInputRegexes =
  
positive.code: 
          /// Maps each final (accepting) DFA state to the
          /// (index of) the Regex it accepts.
          let finalStates =
              (Map.empty, compilationState.DfaStateToNfaStateSet)
              ||> Map.fold (fun finalStates dfaState nfaStateSet ->
                  /// The NFA states (if any) in the set of NFA states represented
                  /// by this DFA state which are final (accepting) states.
                  let nfaFinalStateSet =
  
negative.code:                         |> 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. *)
  
                      /// 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,
                      regexOverlapInfo)
  
          // Create the DFA.
          let dfa =
  