             }
     }
     
+    
+    
+    // MARK: Private Methods
+    
+    private func quickIncompatibleFind(with convertedString: String) -> [IncompatibleCharacter] {
+        
+        zip(self, convertedString).enumerated()
+            .filter { $1.0 != $1.1 }
+            .map { (offset, characters) in
+                let location = self.index(self.startIndex, offsetBy: offset).utf16Offset(in: self)
+                
+                return IncompatibleCharacter(character: characters.0,
+                                             convertedCharacter: String(characters.1),
+                                             location: location,
+                                             lineNumber: self.lineNumber(at: location))
+            }
+    }
+    
 }

            let convertedString = String(data: data, encoding: encoding)
            else { assertionFailure(); return [] }
        
        return convertedString.difference(from: self).removals
            .map { (change) in
                guard case let .remove(offset, character, _) = change else { preconditionFailure() }

    
    var range: NSRange {
        
        NSRange(location: self.location, length: self.character.utf16.count)
    }
    
    
    override var debugDescription: String {
        
        "<\(self): \(self.character) -\(self.location)>"
    }
    
}
