# Auto Correct

In this part, you will implement an auto-correct system that is very effective and useful.

## Outline
- [0. Overview]
    - [0.1 Edit Distance]
- [1. Data Preprocessing]
    - [1.1 Exercise 1]
    - [1.2 Exercise 2]
    - [1.3 Exercise 3]
- [2. String Manipulation]
    - [2.1 Exercise 4]
    - [2.2 Exercise 5]
    - [2.3 Exercise 6]
    - [2.4 Exercise 7]
- [3. Combining the edits]
    - [3.1 Exercise 8]
    - [3.2 Exercise 9]
    - [3.3 Exercise 10]
- [4. Minimum Edit Distance]
    - [4.1 Exercise 11]

## 0. Overview

You use autocorrect every day on your cell phone and computer. In this assignment, you will explore what really goes on behind the scenes. Of course, the model you are about to implement is not identical to the one used in your phone, but it is still quite good.

Similar systems are used everywhere.
- For example, if you type in the word **"I am lerningg"**, chances are very high that you meant to write **"learning"**, as shown in **Figure 1**.

 Figure 1

#### 0.1 Edit Distance

You will implement models that correct words that are 1 and 2 edit distances away.
- We say two words are n edit distance away from each other when we need n edits to change one word into another.

An edit could consist of one of the following options:

- Delete (remove a letter): ‘hat’ => ‘at, ha, ht’
- Switch (swap 2 adjacent letters): ‘eta’ => ‘eat, tea,...’
- Replace (change 1 letter to another): ‘jat’ => ‘hat, rat, cat, mat, ...’
- Insert (add a letter): ‘te’ => ‘the, ten, ate, ...’

You will be using the four methods above to implement an Auto-correct.
- To do so, you will need to compute probabilities that a certain word is correct given an input.

This auto-correct you are about to implement was first created by [Peter Norvig](https://en.wikipedia.org/wiki/Peter_Norvig) in 2007.
- His [original article](https://norvig.com/spell-correct.html) may be a useful reference for this assignment.

The goal of our spell check model is to compute the following probability:

$$P(c|w) = \frac{P(w|c)\times P(c)}{P(w)} \tag{Eqn-1}$$

The equation above is [Bayes Rule](https://en.wikipedia.org/wiki/Bayes%27_theorem).
- Equation 1 says that the probability of a word being correct $P(c|w) $is equal to the probability of having a certain word $w$, given that it is correct $P(w|c)$, multiplied by the probability of being correct in general $P(C)$ divided by the probability of that word $w$ appearing $P(w)$ in general.
- To compute equation 1, you will first import a data set and then create all the probabilities that you need using that data set.

# Part 1: Data Preprocessing

```python
import re
from collections import Counter
import numpy as np
import pandas as pd
```

As in any other machine learning task, the first thing you have to do is process your data set.
- Many courses load in pre-processed data for you.
- However, in the real world, when you build these NLP systems, you load the datasets and process them.
- So let's get some real world practice in pre-processing the data!

Your first task is to read in a file called **'shakespeare.txt'** which is found in your file directory. To look at this file you can go to `File ==> Open `.

### Exercise 1
Implement the function `process_data` which

1) Reads in a corpus (text file)

2) Changes everything to lowercase

3) Returns a list of words.

    General Hints

General Hints to get started

Python input and output

Python 're' documentation

    Detailed Hints

Detailed hints if you're stuck

Use 'with' syntax to read a file

Decide whether to use 'read()' or 'readline().  What's the difference?

Choose whether to use either str.lower() or str.lowercase().  What is the difference?

Use re.findall(pattern, string)

Look for the "Raw String Notation" section in the Python 're' documentation to understand the difference between r'\W', r'\W' and '\\W'.

For the pattern, decide between using '\s', '\w', '\s+' or '\w+'.  What do you think are the differences?

```python
def process_data(file_name):
    """
    Input:
        A file_name which is found in your current directory. You just have to read it in.
    Output:
        words: a list containing all the words in the corpus (text file you read) in lower case.
    """
    words = [] # return this variable correctly

    ### START CODE HERE ###
    with open (file_name) as f:
        read_data = f.read()

    read_data = read_data.lower()

    words = re.findall(r'\w+', read_data)
    ### END CODE HERE ###

    return words
```

Note, in the following cell, 'words' is converted to a python `set`. This eliminates any duplicate entries.

```python
word_l = process_data('shakespeare.txt')
vocab = set(word_l)  # this will be your new vocabulary
print(f"The first ten words in the text are: \n{word_l[0:10]}")
print(f"There are {len(vocab)} unique words in the vocabulary.")
```

    The first ten words in the text are:
    ['o', 'for', 'a', 'muse', 'of', 'fire', 'that', 'would', 'ascend', 'the']
    There are 6116 unique words in the vocabulary.

#### Expected Output
```Python
The first ten words in the text are:
['o', 'for', 'a', 'muse', 'of', 'fire', 'that', 'would', 'ascend', 'the']
There are 6116 unique words in the vocabulary.
```

### Exercise 2

Implement a `get_count` function that returns a dictionary
- The dictionary's keys are words
- The value for each word is the number of times that word appears in the corpus.

For example, given the following sentence: **"I am happy because I am learning"**, your dictionary should return the following:

     Key
     Value

     I
     2

    am
    2

    happy
    1

    because
    1

    learning
    1

**Instructions**:
Implement a `get_count` which returns a dictionary where the key is a word and the value is the number of times the word appears in the list.

    Hints

Try implementing this using a for loop and a regular dictionary. This may be good practice for similar coding interview questions

You can also use defaultdict instead of a regualr dictionary, along with the for loop

Otherwise, to skip using a for loop, you can use Python's  Counter class

```python
def get_count(word_l):
    '''
    Input:
        word_l: a set of words representing the corpus.
    Output:
        word_count_dict: The wordcount dictionary where key is the word and value is its frequency.
    '''

    word_count_dict = {}  # fill this with word counts
    ### START CODE HERE
    word_count_dict = Counter(word_l)
    ### END CODE HERE ###
    return word_count_dict
```

```python
word_count_dict = get_count(word_l)
print(f"There are {len(word_count_dict)} key values pairs")
print(f"The count for the word 'thee' is {word_count_dict.get('thee',0)}")
```

    There are 6116 key values pairs
    The count for the word 'thee' is 240

#### Expected Output
```Python
There are 6116 key values pairs
The count for the word 'thee' is 240
```

### Exercise 3
Given the dictionary of word counts, compute the probability that each word will appear if randomly selected from the corpus of words.

$$P(w_i) = \frac{C(w_i)}{M} \tag{Eqn-2}$$
where

$C(w_i)$ is the total number of times $w_i$ appears in the corpus.

$M$ is the total number of words in the corpus.

For example, the probability of the word 'am' in the sentence **'I am happy because I am learning'** is:

$$P(am) = \frac{C(w_i)}{M} = \frac {2}{7} \tag{Eqn-3}.$$

**Instructions:** Implement `get_probs` function which gives you the probability
that a word occurs in a sample. This returns a dictionary where the keys are words, and the value for each word is its probability in the corpus of words.

    Hints

General advice

 Use dictionary.values()

 Use sum()

 The cardinality (number of words in the corpus should be equal to len(word_l).  You will calculate this same number, but using the word count dictionary.

If you're using a for loop:

 Use dictionary.keys()

If you're using a dictionary comprehension:

Use dictionary.items()

```python
def get_probs(word_count_dict):
    '''
    Input:
        word_count_dict: The wordcount dictionary where key is the word and value is its frequency.
    Output:
        probs: A dictionary where keys are the words and the values are the probability that a word will occur.
    '''
    probs = {}  # return this variable correctly

    ### START CODE HERE ###
    m = sum(word_count_dict.values())
    probs = {w: word_count_dict[w] / m  for w in word_count_dict}
    ### END CODE HERE ###
    return probs
```

```python
probs = get_probs(word_count_dict)
print(f"Length of probs is {len(probs)}")
print(f"P('thee') is {probs['thee']:.4f}")
```

    Length of probs is 6116
    P('thee') is 0.0045

#### Expected Output

```Python
Length of probs is 6116
P('thee') is 0.0045
```

# Part 2: String Manipulations

Now, that you have computed $P(w_i)$ for all the words in the corpus, you will write a few functions to manipulate strings so that you can edit the erroneous strings and return the right spellings of the words. In this section, you will implement four functions:

* `delete_letter`: given a word, it returns all the possible strings that have **one character removed**.
* `switch_letter`: given a word, it returns all the possible strings that have **two adjacent letters switched**.
* `replace_letter`: given a word, it returns all the possible strings that have **one character replaced by another different letter**.
* `insert_letter`: given a word, it returns all the possible strings that have an **additional character inserted**.

#### List comprehensions

String and list manipulation in python will often make use of a python feature called  [list comprehensions](https://docs.python.org/3/tutorial/datastructures.html#list-comprehensions). The routines below will be described as using list comprehensions, but if you would rather implement them in another way, you are free to do so as long as the result is the same. Further, the following section will provide detailed instructions on how to use list comprehensions and how to implement the desired functions. If you are a python expert, feel free to skip the python hints and move to implementing the routines directly.

Python List Comprehensions embed a looping structure inside of a list declaration, collapsing many lines of code into a single line. If you are not familiar with them, they seem slightly out of order relative to for loops.

 Figure 2

The diagram above shows that the components of a list comprehension are the same components you would find in a typical for loop that appends to a list, but in a different order. With that in mind, we'll continue the specifics of this assignment. We will be very descriptive for the first function, `deletes()`, and less so in later functions as you become familiar with list comprehensions.

### Exercise 4

**Instructions for delete_letter():** Implement a `delete_letter()` function that, given a word, returns a list of strings with one character deleted.

For example, given the word **nice**, it would return the set: {'ice', 'nce', 'nic', 'nie'}.

**Step 1:** Create a list of 'splits'. This is all the ways you can split a word into Left and Right: For example,
'nice is split into : `[('', 'nice'), ('n', 'ice'), ('ni', 'ce'), ('nic', 'e'), ('nice', '')]`
This is common to all four functions (delete, replace, switch, insert).

 Figure 3

**Step 2:** This is specific to `delete_letter`. Here, we are generating all words that result from deleting one character.
This can be done in a single line with a list comprehension. You can make use of this type of syntax:
`[f(a,b) for a, b in splits if condition]`

For our 'nice' example you get:
['ice', 'nce', 'nie', 'nic']

 Figure 4

#### Levels of assistance

Try this exercise with these levels of assistance.
- We hope that this will make it both a meaningful experience but also not a frustrating experience.
- Start with level 1, then move onto level 2, and 3 as needed.

    - Level 1. Try to think this through and implement this yourself.
    - Level 2. Click on the "Level 2 Hints" section for some hints to get started.
    - Level 3. If you would prefer more guidance, please click on the "Level 3 Hints" cell for step by step instructions.

- If you are still stuck, look at the images in the "list comprehensions" section above.

    Level 2 Hints

 Use array slicing like my_string[0:2]

 Use list comprehensions or for loops

    Level 3 Hints

splits: Use array slicing, like my_str[0:2], to separate a string into two pieces.

Do this in a loop or list comprehension, so that you have a list of tuples.

 For example, "cake" can get split into "ca" and "ke". They're stored in a tuple ("ca","ke"), and the tuple is appended to a list.  We'll refer to these as L and R, so the tuple is (L,R)

When choosing the range for your loop, if you input the word "cans" and generate the tuple  ('cans',''), make sure to include an if statement to check the length of that right-side string (R) in the tuple (L,R)

deletes: Go through the list of tuples and combine the two strings together. You can use the + operator to combine two strings

When combining the tuples, make sure that you leave out a middle character.

Use array slicing to leave out the first character of the right substring.

```python
def delete_letter(word, verbose=False):
    '''
    Input:
        word: the string/word for which you will generate all possible words
                in the vocabulary which have 1 missing character
    Output:
        delete_l: a list of all possible strings obtained by deleting 1 character from word
    '''

    delete_l = []
    split_l = []

    ### START CODE HERE ###
    split_l = [(word[:i], word[i:]) for i in range(len(word) + 1)]
    delete_l = [L[:] + R[1:] for L, R in split_l if R]
    ### END CODE HERE ###

    if verbose: print(f"input word {word}, \nsplit_l = {split_l}, \ndelete_l = {delete_l}")

    return delete_l
```

```python
delete_word_l = delete_letter(word="cans",
                        verbose=True)
```

    input word cans,
    split_l = [('', 'cans'), ('c', 'ans'), ('ca', 'ns'), ('can', 's'), ('cans', '')],
    delete_l = ['ans', 'cns', 'cas', 'can']

#### Expected Output
```CPP
Note: You might get a slightly different result with split_l

input word cans,
split_l = [('', 'cans'), ('c', 'ans'), ('ca', 'ns'), ('can', 's')],
delete_l = ['ans', 'cns', 'cas', 'can']
```

#### Note 1
- Notice how it has the extra tuple `('cans', '')`.
- This will be fine as long as you have checked the size of the right-side substring in tuple (L,R).
- Can you explain why this will give you the same result for the list of deletion strings (delete_l)?

```CPP
input word cans,
split_l = [('', 'cans'), ('c', 'ans'), ('ca', 'ns'), ('can', 's'), ('cans', '')],
delete_l = ['ans', 'cns', 'cas', 'can']
```

#### Note 2
If you end up getting the same word as your input word, like this:

```Python
input word cans,
split_l = [('', 'cans'), ('c', 'ans'), ('ca', 'ns'), ('can', 's'), ('cans', '')],
delete_l = ['ans', 'cns', 'cas', 'can', 'cans']
```

- Check how you set the `range`.
- See if you check the length of the string on the right-side of the split.

```python
# test # 2
print(f"Number of outputs of delete_letter('at') is {len(delete_letter('at'))}")
```

    Number of outputs of delete_letter('at') is 2

#### Expected output

```CPP
Number of outputs of delete_letter('at') is 2
```

### Exercise 5

**Instructions for switch_letter()**: Now implement a function that switches two letters in a word. It takes in a word and returns a list of all the possible switches of two letters **that are adjacent to each other**.
- For example, given the word 'eta', it returns {'eat', 'tea'}, but does not return 'ate'.

**Step 1:** is the same as in delete_letter()
**Step 2:** A list comprehension or for loop which forms strings by swapping adjacent letters. This is of the form:
`[f(L,R) for L, R in splits if condition]`  where 'condition' will test the length of R in a given iteration. See below.

 Figure 5

#### Levels of difficulty

Try this exercise with these levels of difficulty.
- Level 1. Try to think this through and implement this yourself.
- Level 2. Click on the "Level 2 Hints" section for some hints to get started.
- Level 3. If you would prefer more guidance, please click on the "Level 3 Hints" cell for step by step instructions.

    Level 2 Hints

 Use array slicing like my_string[0:2]

 Use list comprehensions or for loops

To do a switch, think of the whole word as divided into 4 distinct parts.  Write out 'cupcakes' on a piece of paper and see how you can split it into ('cupc', 'k', 'a', 'es')

    Level 3 Hints

splits: Use array slicing, like my_str[0:2], to separate a string into two pieces.

Splitting is the same as for delete_letter

To perform the switch, go through the list of tuples and combine four strings together. You can use the + operator to combine strings

The four strings will be the left substring from the split tuple, followed by the first (index 1) character of the right substring, then the zero-th character (index 0) of the right substring, and then the remaining part of the right substring.

Unlike delete_letter, you will want to check that your right substring is at least a minimum length.  To see why, review the previous hint bullet point (directly before this one).

```python
def switch_letter(word, verbose=False):
    '''
    Input:
        word: input string
     Output:
        switches: a list of all possible strings with one adjacent charater switched
    '''

    switch_l = []
    split_l = []

    ### START CODE HERE ###
    split_l = [(word[:i], word[i:])for i in range(len(word) + 1)]
    switch_l = [L + R[1] + R[0] + R[2:] for L, R in split_l if len(R) > 1]
    ### END CODE HERE ###

    if verbose: print(f"Input word = {word} \nsplit_l = {split_l} \nswitch_l = {switch_l}")

    return switch_l
```

```python
switch_word_l = switch_letter(word="eta",
                         verbose=True)
```

    Input word = eta
    split_l = [('', 'eta'), ('e', 'ta'), ('et', 'a'), ('eta', '')]
    switch_l = ['tea', 'eat']

#### Expected output

```Python
Input word = eta
split_l = [('', 'eta'), ('e', 'ta'), ('et', 'a')]
switch_l = ['tea', 'eat']
```

#### Note 1

You may get this:
```Python
Input word = eta
split_l = [('', 'eta'), ('e', 'ta'), ('et', 'a'), ('eta', '')]
switch_l = ['tea', 'eat']
```
- Notice how it has the extra tuple `('eta', '')`.
- This is also correct.
- Can you think of why this is the case?

#### Note 2

If you get an error
```Python
IndexError: string index out of range
```
- Please see if you have checked the length of the strings when switching characters.

```python
# test # 2
print(f"Number of outputs of switch_letter('at') is {len(switch_letter('at'))}")
```

    Number of outputs of switch_letter('at') is 1

#### Expected output

```CPP
Number of outputs of switch_letter('at') is 1
```

### Exercise 6
**Instructions for replace_letter()**: Now implement a function that takes in a word and returns a list of strings with one **replaced letter** from the original word.

**Step 1:** is the same as in `delete_letter()`

**Step 2:** A list comprehension or for loop which form strings by replacing letters.  This can be of the form:
`[f(a,b,c) for a, b in splits if condition for c in string]`   Note the use of the second for loop.
It is expected in this routine that one or more of the replacements will include the original word. For example, replacing the first letter of 'ear' with 'e' will return 'ear'.

**Step 3:** Remove the original input letter from the output.

    Hints

To remove a word from a list, first store its contents inside a set()

Use set.discard('the_word') to remove a word in a set (if the word does not exist in the set, then it will not throw a KeyError.  Using set.remove('the_word') throws a KeyError if the word does not exist in the set.

```python
def replace_letter(word, verbose=False):
    '''
    Input:
        word: the input string/word
    Output:
        replaces: a list of all possible strings where we replaced one letter from the original word.
    '''

    letters = 'abcdefghijklmnopqrstuvwxyz'
    replace_l = []
    split_l = []

    ### START CODE HERE ###
    replace_set = set([word.replace(i, c) for i in word for c in letters])
    ### END CODE HERE ###

    # turn the set back into a list and sort it, for easier viewing
    replace_l = sorted(list(replace_set))
    if word in replace_l:
        replace_l.remove(word)

    if verbose: print(f"Input word = {word} \nsplit_l = {split_l} \nreplace_l {replace_l}")

    return replace_l
```

```python
replace_l = replace_letter(word='can',
                              verbose=True)
```

    Input word = can
    split_l = []
    replace_l ['aan', 'ban', 'caa', 'cab', 'cac', 'cad', 'cae', 'caf', 'cag', 'cah', 'cai', 'caj', 'cak', 'cal', 'cam', 'cao', 'cap', 'caq', 'car', 'cas', 'cat', 'cau', 'cav', 'caw', 'cax', 'cay', 'caz', 'cbn', 'ccn', 'cdn', 'cen', 'cfn', 'cgn', 'chn', 'cin', 'cjn', 'ckn', 'cln', 'cmn', 'cnn', 'con', 'cpn', 'cqn', 'crn', 'csn', 'ctn', 'cun', 'cvn', 'cwn', 'cxn', 'cyn', 'czn', 'dan', 'ean', 'fan', 'gan', 'han', 'ian', 'jan', 'kan', 'lan', 'man', 'nan', 'oan', 'pan', 'qan', 'ran', 'san', 'tan', 'uan', 'van', 'wan', 'xan', 'yan', 'zan']

#### Expected Output**:
```Python
Input word = can
split_l = [('', 'can'), ('c', 'an'), ('ca', 'n')]
replace_l ['aan', 'ban', 'caa', 'cab', 'cac', 'cad', 'cae', 'caf', 'cag', 'cah', 'cai', 'caj', 'cak', 'cal', 'cam', 'cao', 'cap', 'caq', 'car', 'cas', 'cat', 'cau', 'cav', 'caw', 'cax', 'cay', 'caz', 'cbn', 'ccn', 'cdn', 'cen', 'cfn', 'cgn', 'chn', 'cin', 'cjn', 'ckn', 'cln', 'cmn', 'cnn', 'con', 'cpn', 'cqn', 'crn', 'csn', 'ctn', 'cun', 'cvn', 'cwn', 'cxn', 'cyn', 'czn', 'dan', 'ean', 'fan', 'gan', 'han', 'ian', 'jan', 'kan', 'lan', 'man', 'nan', 'oan', 'pan', 'qan', 'ran', 'san', 'tan', 'uan', 'van', 'wan', 'xan', 'yan', 'zan']
```
- Note how the input word 'can' should not be one of the output words.

#### Note 1
If you get something like this:

```Python
Input word = can
split_l = [('', 'can'), ('c', 'an'), ('ca', 'n'), ('can', '')]
replace_l ['aan', 'ban', 'caa', 'cab', 'cac', 'cad', 'cae', 'caf', 'cag', 'cah', 'cai', 'caj', 'cak', 'cal', 'cam', 'cao', 'cap', 'caq', 'car', 'cas', 'cat', 'cau', 'cav', 'caw', 'cax', 'cay', 'caz', 'cbn', 'ccn', 'cdn', 'cen', 'cfn', 'cgn', 'chn', 'cin', 'cjn', 'ckn', 'cln', 'cmn', 'cnn', 'con', 'cpn', 'cqn', 'crn', 'csn', 'ctn', 'cun', 'cvn', 'cwn', 'cxn', 'cyn', 'czn', 'dan', 'ean', 'fan', 'gan', 'han', 'ian', 'jan', 'kan', 'lan', 'man', 'nan', 'oan', 'pan', 'qan', 'ran', 'san', 'tan', 'uan', 'van', 'wan', 'xan', 'yan', 'zan']
```
- Notice how split_l has an extra tuple `('can', '')`, but the output is still the same, so this is okay.

#### Note 2
If you get something like this:
```Python
Input word = can
split_l = [('', 'can'), ('c', 'an'), ('ca', 'n'), ('can', '')]
replace_l ['aan', 'ban', 'caa', 'cab', 'cac', 'cad', 'cae', 'caf', 'cag', 'cah', 'cai', 'caj', 'cak', 'cal', 'cam', 'cana', 'canb', 'canc', 'cand', 'cane', 'canf', 'cang', 'canh', 'cani', 'canj', 'cank', 'canl', 'canm', 'cann', 'cano', 'canp', 'canq', 'canr', 'cans', 'cant', 'canu', 'canv', 'canw', 'canx', 'cany', 'canz', 'cao', 'cap', 'caq', 'car', 'cas', 'cat', 'cau', 'cav', 'caw', 'cax', 'cay', 'caz', 'cbn', 'ccn', 'cdn', 'cen', 'cfn', 'cgn', 'chn', 'cin', 'cjn', 'ckn', 'cln', 'cmn', 'cnn', 'con', 'cpn', 'cqn', 'crn', 'csn', 'ctn', 'cun', 'cvn', 'cwn', 'cxn', 'cyn', 'czn', 'dan', 'ean', 'fan', 'gan', 'han', 'ian', 'jan', 'kan', 'lan', 'man', 'nan', 'oan', 'pan', 'qan', 'ran', 'san', 'tan', 'uan', 'van', 'wan', 'xan', 'yan', 'zan']
```
- Notice how there are strings that are 1 letter longer than the original word, such as `cana`.
- Please check for the case when there is an empty string `''`, and if so, do not use that empty string when setting replace_l.

```python
# test # 2
print(f"Number of outputs of switch_letter('at') is {len(switch_letter('at'))}")
```

    Number of outputs of switch_letter('at') is 1

#### Expected output
```CPP
Number of outputs of switch_letter('at') is 1
```

### Exercise 7

**Instructions for insert_letter()**: Now implement a function that takes in a word and returns a list with a letter inserted at every offset.

**Step 1:** is the same as in `delete_letter()`

**Step 2:** This can be a list comprehension of the form:
`[f(a,b,c) for a, b in splits if condition for c in string]`

```python
def insert_letter(word, verbose=False):
    '''
    Input:
        word: the input string/word
    Output:
        inserts: a set of all possible strings with one new letter inserted at every offset
    '''
    letters = 'abcdefghijklmnopqrstuvwxyz'
    insert_l = []
    split_l = []

    ### START CODE HERE ###
    split_l = [(word[:i], word[i:]) for i in range(len(word) + 1)]
    insert_l = [L + c + R for L, R in split_l for c in letters]
    ### END CODE HERE ###

    if verbose: print(f"Input word {word} \nsplit_l = {split_l} \ninsert_l = {insert_l}")

    return insert_l
```

```python
insert_l = insert_letter('at', True)
print(f"Number of strings output by insert_letter('at') is {len(insert_l)}")
```

    Input word at
    split_l = [('', 'at'), ('a', 't'), ('at', '')]
    insert_l = ['aat', 'bat', 'cat', 'dat', 'eat', 'fat', 'gat', 'hat', 'iat', 'jat', 'kat', 'lat', 'mat', 'nat', 'oat', 'pat', 'qat', 'rat', 'sat', 'tat', 'uat', 'vat', 'wat', 'xat', 'yat', 'zat', 'aat', 'abt', 'act', 'adt', 'aet', 'aft', 'agt', 'aht', 'ait', 'ajt', 'akt', 'alt', 'amt', 'ant', 'aot', 'apt', 'aqt', 'art', 'ast', 'att', 'aut', 'avt', 'awt', 'axt', 'ayt', 'azt', 'ata', 'atb', 'atc', 'atd', 'ate', 'atf', 'atg', 'ath', 'ati', 'atj', 'atk', 'atl', 'atm', 'atn', 'ato', 'atp', 'atq', 'atr', 'ats', 'att', 'atu', 'atv', 'atw', 'atx', 'aty', 'atz']
    Number of strings output by insert_letter('at') is 78

#### Expected output

```Python
Input word at
split_l = [('', 'at'), ('a', 't'), ('at', '')]
insert_l = ['aat', 'bat', 'cat', 'dat', 'eat', 'fat', 'gat', 'hat', 'iat', 'jat', 'kat', 'lat', 'mat', 'nat', 'oat', 'pat', 'qat', 'rat', 'sat', 'tat', 'uat', 'vat', 'wat', 'xat', 'yat', 'zat', 'aat', 'abt', 'act', 'adt', 'aet', 'aft', 'agt', 'aht', 'ait', 'ajt', 'akt', 'alt', 'amt', 'ant', 'aot', 'apt', 'aqt', 'art', 'ast', 'att', 'aut', 'avt', 'awt', 'axt', 'ayt', 'azt', 'ata', 'atb', 'atc', 'atd', 'ate', 'atf', 'atg', 'ath', 'ati', 'atj', 'atk', 'atl', 'atm', 'atn', 'ato', 'atp', 'atq', 'atr', 'ats', 'att', 'atu', 'atv', 'atw', 'atx', 'aty', 'atz']
Number of strings output by insert_letter('at') is 78
```

#### Note 1

If you get a split_l like this:
```Python
Input word at
split_l = [('', 'at'), ('a', 't')]
insert_l = ['aat', 'bat', 'cat', 'dat', 'eat', 'fat', 'gat', 'hat', 'iat', 'jat', 'kat', 'lat', 'mat', 'nat', 'oat', 'pat', 'qat', 'rat', 'sat', 'tat', 'uat', 'vat', 'wat', 'xat', 'yat', 'zat', 'aat', 'abt', 'act', 'adt', 'aet', 'aft', 'agt', 'aht', 'ait', 'ajt', 'akt', 'alt', 'amt', 'ant', 'aot', 'apt', 'aqt', 'art', 'ast', 'att', 'aut', 'avt', 'awt', 'axt', 'ayt', 'azt']
Number of strings output by insert_letter('at') is 52
```
- Notice that split_l is missing the extra tuple ('at', '').  For insertion, we actually **WANT** this tuple.
- The function is not creating all the desired output strings.
- Check the range that you use for the for loop.

#### Note 2
If you see this:
```Python
Input word at
split_l = [('', 'at'), ('a', 't'), ('at', '')]
insert_l = ['aat', 'bat', 'cat', 'dat', 'eat', 'fat', 'gat', 'hat', 'iat', 'jat', 'kat', 'lat', 'mat', 'nat', 'oat', 'pat', 'qat', 'rat', 'sat', 'tat', 'uat', 'vat', 'wat', 'xat', 'yat', 'zat', 'aat', 'abt', 'act', 'adt', 'aet', 'aft', 'agt', 'aht', 'ait', 'ajt', 'akt', 'alt', 'amt', 'ant', 'aot', 'apt', 'aqt', 'art', 'ast', 'att', 'aut', 'avt', 'awt', 'axt', 'ayt', 'azt']
Number of strings output by insert_letter('at') is 52
```

- Even though you may have fixed the split_l so that it contains the tuple `('at', '')`, notice that you're still missing some output strings.
    - Notice that it's missing strings such as 'ata', 'atb', 'atc' all the way to 'atz'.
- To fix this, make sure that when you set insert_l, you allow the use of the empty string `''`.

```python
# test # 2
print(f"Number of outputs of insert_letter('at') is {len(insert_letter('at'))}")
```

    Number of outputs of insert_letter('at') is 78

#### Expected output

```CPP
Number of outputs of insert_letter('at') is 78
```

# Part 3: Combining the edits

Now that you have implemented the string manipulations, you will create two functions that, given a string, will return all the possible single and double edits on that string. These will be `edit_one_letter()` and `edit_two_letters()`.

## 3.1 Edit one letter

### Exercise 8

**Instructions**: Implement the `edit_one_letter` function to get all the possible edits that are one edit away from a word. The edits  consist of the replace, insert, delete, and optionally the switch operation. You should use the previous functions you have already implemented to complete this function. The 'switch' function  is a less common edit function, so its use will be selected by an "allow_switches" input argument.

Note that those functions return *lists* while this function should return a *python set*. Utilizing a set eliminates any duplicate entries.

    Hints

 Each of the functions returns a list.  You can combine lists using the `+` operator.

 To get unique strings (avoid duplicates), you can use the set() function.

```python
def edit_one_letter(word, allow_switches = True):
    """
    Input:
        word: the string/word for which we will generate all possible wordsthat are one edit away.
    Output:
        edit_one_set: a set of words with one possible edit. Please return a set. and not a list.
    """

    edit_one_set = set()

    ### START CODE HERE ###
    edit_one_set.update(set(replace_letter(word)))
    edit_one_set.update(set(insert_letter(word)))
    edit_one_set.update(set(delete_letter(word)))
    if allow_switches: edit_one_set.update(set(switch_letter(word)))
    ### END CODE HERE ###

    return set(edit_one_set)
```

```python
tmp_word = "at"
tmp_edit_one_set = edit_one_letter(tmp_word)
# turn this into a list to sort it, in order to view it
tmp_edit_one_l = sorted(list(tmp_edit_one_set))

print(f"input word {tmp_word} \nedit_one_l \n{tmp_edit_one_l}\n")
print(f"The type of the returned object should be a set {type(tmp_edit_one_set)}")
print(f"Number of outputs from edit_one_letter('at') is {len(edit_one_letter('at'))}")
```

    input word at
    edit_one_l
    ['a', 'aa', 'aat', 'ab', 'abt', 'ac', 'act', 'ad', 'adt', 'ae', 'aet', 'af', 'aft', 'ag', 'agt', 'ah', 'aht', 'ai', 'ait', 'aj', 'ajt', 'ak', 'akt', 'al', 'alt', 'am', 'amt', 'an', 'ant', 'ao', 'aot', 'ap', 'apt', 'aq', 'aqt', 'ar', 'art', 'as', 'ast', 'ata', 'atb', 'atc', 'atd', 'ate', 'atf', 'atg', 'ath', 'ati', 'atj', 'atk', 'atl', 'atm', 'atn', 'ato', 'atp', 'atq', 'atr', 'ats', 'att', 'atu', 'atv', 'atw', 'atx', 'aty', 'atz', 'au', 'aut', 'av', 'avt', 'aw', 'awt', 'ax', 'axt', 'ay', 'ayt', 'az', 'azt', 'bat', 'bt', 'cat', 'ct', 'dat', 'dt', 'eat', 'et', 'fat', 'ft', 'gat', 'gt', 'hat', 'ht', 'iat', 'it', 'jat', 'jt', 'kat', 'kt', 'lat', 'lt', 'mat', 'mt', 'nat', 'nt', 'oat', 'ot', 'pat', 'pt', 'qat', 'qt', 'rat', 'rt', 'sat', 'st', 't', 'ta', 'tat', 'tt', 'uat', 'ut', 'vat', 'vt', 'wat', 'wt', 'xat', 'xt', 'yat', 'yt', 'zat', 'zt']

    The type of the returned object should be a set <class 'set'>
    Number of outputs from edit_one_letter('at') is 129

#### Expected Output
```CPP
input word at
edit_one_l
['a', 'aa', 'aat', 'ab', 'abt', 'ac', 'act', 'ad', 'adt', 'ae', 'aet', 'af', 'aft', 'ag', 'agt', 'ah', 'aht', 'ai', 'ait', 'aj', 'ajt', 'ak', 'akt', 'al', 'alt', 'am', 'amt', 'an', 'ant', 'ao', 'aot', 'ap', 'apt', 'aq', 'aqt', 'ar', 'art', 'as', 'ast', 'ata', 'atb', 'atc', 'atd', 'ate', 'atf', 'atg', 'ath', 'ati', 'atj', 'atk', 'atl', 'atm', 'atn', 'ato', 'atp', 'atq', 'atr', 'ats', 'att', 'atu', 'atv', 'atw', 'atx', 'aty', 'atz', 'au', 'aut', 'av', 'avt', 'aw', 'awt', 'ax', 'axt', 'ay', 'ayt', 'az', 'azt', 'bat', 'bt', 'cat', 'ct', 'dat', 'dt', 'eat', 'et', 'fat', 'ft', 'gat', 'gt', 'hat', 'ht', 'iat', 'it', 'jat', 'jt', 'kat', 'kt', 'lat', 'lt', 'mat', 'mt', 'nat', 'nt', 'oat', 'ot', 'pat', 'pt', 'qat', 'qt', 'rat', 'rt', 'sat', 'st', 't', 'ta', 'tat', 'tt', 'uat', 'ut', 'vat', 'vt', 'wat', 'wt', 'xat', 'xt', 'yat', 'yt', 'zat', 'zt']

The type of the returned object should be a set <class 'set'>
Number of outputs from edit_one_letter('at') is 129
```

## Part 3.2 Edit two letters

### Exercise 9

Now you can generalize this to implement to get two edits on a word. To do so, you would have to get all the possible edits on a single word and then for each modified word, you would have to modify it again.

**Instructions**: Implement the `edit_two_letters` function that returns a set of words that are two edits away. Note that creating additional edits based on the `edit_one_letter` function may 'restore' some one_edits to zero or one edits. That is allowed here. This accounted for in get_corrections.

    Hints

You will likely want to take the union of two sets.

You can either use set.union() or use the '|' (or operator) to union two sets

See the documentation  Python sets  for examples of using operators or functions of the Python set.

```python
def edit_two_letters(word, allow_switches = True):
    '''
    Input:
        word: the input string/word
    Output:
        edit_two_set: a set of strings with all possible two edits
    '''

    edit_two_set = set()
    ### START CODE HERE ###
    tmp_edit_one_set = edit_one_letter(word, allow_switches)
    for l in tmp_edit_one_set:
        edit_two_set.update(set(edit_one_letter(l, allow_switches)))
    ### END CODE HERE ###

    return edit_two_set
```

```python
tmp_edit_two_set = edit_two_letters("a")
tmp_edit_two_l = sorted(list(tmp_edit_two_set))
print(f"Number of strings with edit distance of two: {len(tmp_edit_two_l)}")
print(f"First 10 strings {tmp_edit_two_l[:10]}")
print(f"Last 10 strings {tmp_edit_two_l[-10:]}")
print(f"The data type of the returned object should be a set {type(tmp_edit_two_set)}")
print(f"Number of strings that are 2 edit distances from 'at' is {len(edit_two_letters('at'))}")
```

    Number of strings with edit distance of two: 2654
    First 10 strings ['', 'a', 'aa', 'aaa', 'aab', 'aac', 'aad', 'aae', 'aaf', 'aag']
    Last 10 strings ['zv', 'zva', 'zw', 'zwa', 'zx', 'zxa', 'zy', 'zya', 'zz', 'zza']
    The data type of the returned object should be a set <class 'set'>
    Number of strings that are 2 edit distances from 'at' is 7154

#### Expected Output

```CPP
Number of strings with edit distance of two: 2654
First 10 strings ['', 'a', 'aa', 'aaa', 'aab', 'aac', 'aad', 'aae', 'aaf', 'aag']
Last 10 strings ['zv', 'zva', 'zw', 'zwa', 'zx', 'zxa', 'zy', 'zya', 'zz', 'zza']
The data type of the returned object should be a set <class 'set'>
Number of strings that are 2 edit distances from 'at' is 7154
```

## Part 3-3: suggest spelling suggestions

Now you will use your `edit_two_letters` function to get a set of all the possible 2 edits on your word. You will then use those strings to get the most probable word you meant to type aka your typing suggestion.

### Exercise 10
**Instructions**: Implement `get_corrections`, which returns a list of zero to n possible suggestion tuples of the form (word, probability_of_word).

**Step 1:** Generate suggestions for a supplied word: You'll use the edit functions you have developed. The 'suggestion algorithm' should follow this logic:
* If the word is in the vocabulary, suggest the word.
* Otherwise, if there are suggestions from `edit_one_letter` that are in the vocabulary, use those.
* Otherwise, if there are suggestions from `edit_two_letters` that are in the vocabulary, use those.
* Otherwise, suggest the input word.*
* The idea is that words generated from fewer edits are more likely than words with more edits.

Note:
- Edits of one or two letters may 'restore' strings to either zero or one edit. This algorithm accounts for this by preferentially selecting lower distance edits first.

#### Short circuit
In Python, logical operations such as `and` and `or` have two useful properties. They can operate on lists and they have ['short-circuit' behavior](https://docs.python.org/3/library/stdtypes.html). Try these:

```python
# example of logical operation on lists or sets
print( [] and ["a","b"] )
print( [] or ["a","b"] )
#example of Short circuit behavior
val1 =  ["Most","Likely"] or ["Less","so"] or ["least","of","all"]  # selects first, does not evalute remainder
print(val1)
val2 =  [] or [] or ["least","of","all"] # continues evaluation until there is a non-empty list
print(val2)
```

    []
    ['a', 'b']
    ['Most', 'Likely']
    ['least', 'of', 'all']

The logical `or` could be used to implement the suggestion algorithm very compactly. Alternately, if/then constructs could be used.

**Step 2**: Create a 'best_words' dictionary where the 'key' is a suggestion and the 'value' is the probability of that word in your vocabulary. If the word is not in the vocabulary, assign it a probability of 0.

**Step 3**: Select the n best suggestions. There may be fewer than n.

    Hints

edit_one_letter and edit_two_letters return *python sets*.

 Sets have a handy  set.intersection  feature

To find the keys that have the highest values in a dictionary, you can use the Counter dictionary to create a Counter object from a regular dictionary.  Then you can use Counter.most_common(n) to get the n most common keys.

To find the intersection of two sets, you can use set.intersection or the & operator.

If you are not as familiar with short circuit syntax (as shown above), feel free to use if else statements instead.

To use an if statement to check of a set is empty, use 'if not x:' syntax

```python
def get_corrections(word, probs, vocab, n=2, verbose = False):
    '''
    Input:
        word: a user entered string to check for suggestions
        probs: a dictionary that maps each word to its probability in the corpus
        vocab: a set containing all the vocabulary
        n: number of possible word corrections you want returned in the dictionary
    Output:
        n_best: a list of tuples with the most probable n corrected words and their probabilities.
    '''

    suggestions = []
    n_best = []
    temp = []
    ### START CODE HERE ###
    if word in vocab:
        temp.append(word)
    one_letter_suggestion = sorted(list(edit_one_letter(word)))
    for i in one_letter_suggestion:
        if i in vocab:
            temp.append(i)
    two_letter_suggestion = sorted(list(edit_two_letters(word)))
    for i in two_letter_suggestion:
        if i in vocab:
            temp.append(i)
    temp.append(word)
    for i in range(n):
        suggestions.append(temp[i])
        n_best.append((temp[i], probs[temp[i]]))
    ### END CODE HERE ###

    if verbose: print("entered word = ", word, "\nsuggestions = ", suggestions)

    return n_best
```

```python
# Test your implementation - feel free to try other words in my word
my_word = 'dys'
tmp_corrections = get_corrections(my_word, probs, vocab, 2, verbose=True) # keep verbose=True
for i, word_prob in enumerate(tmp_corrections):
    print(f"word {i}: {word_prob[0]}, probability {word_prob[1]:.6f}")

# CODE REVIEW COMMENT: using "tmp_corrections" insteads of "cors". "cors" is not defined
print(f"data type of corrections {type(tmp_corrections)}")
```

    entered word =  dys
    suggestions =  ['days', 'dye']
    word 0: days, probability 0.000410
    word 1: dye, probability 0.000019
    data type of corrections <class 'list'>

#### Expected Output
- Note: This expected output is for `my_word = 'dys'`. Also, keep `verbose=True`
```CPP
entered word =  dys
suggestions =  {'days', 'dye'}
word 0: days, probability 0.000410
word 1: dye, probability 0.000019
data type of corrections <class 'list'>
```

# Part 4: Minimum Edit distance

Now that you have implemented your auto-correct, how do you evaluate the similarity between two strings? For example: 'waht' and 'what'

Also how do you efficiently find the shortest path to go from the word, 'waht' to the word 'what'?

You will implement a dynamic programming system that will tell you the minimum number of edits required to convert a string into another string.

### Part 4.1 Dynamic Programming

Dynamic Programming breaks a problem down into subproblems which can be combined to form the final solution. Here, given a string source[0..i] and a string target[0..j], we will compute all the combinations of substrings[i, j] and calculate their edit distance. To do this efficiently, we will use a table to maintain the previously computed substrings and use those to calculate larger substrings.

You have to create a matrix and update each element in the matrix as follows:

$$\text{Initialization}$$

\begin{align}
D[0,0] &= 0 \\
D[i,0] &= D[i-1,0] + del\_cost(source[i]) \tag{4}\\
D[0,j] &= D[0,j-1] + ins\_cost(target[j]) \\
\end{align}

$$\text{Per Cell Operations}$$
\begin{align}
 \\
D[i,j] =min
\begin{cases}
D[i-1,j] + del\_cost\\
D[i,j-1] + ins\_cost\\
D[i-1,j-1] + \left\{\begin{matrix}
rep\_cost; & if src[i]\neq tar[j]\\
0 ; & if src[i]=tar[j]
\end{matrix}\right.
\end{cases}
\tag{5}
\end{align}

So converting the source word **play** to the target word **stay**, using an input cost of one, a delete cost of 1, and replace cost of 2 would give you the following table:

     #
     s
     t
     a
     y

       #
     0
     1
     2
     3
     4

       p
     1
  2
     3
     4
    5

      l
    2
    3
    4
    5
    6

      a
    3
     4
     5
     4
     5

      y
    4
      5
     6
     5
     4

The operations used in this algorithm are 'insert', 'delete', and 'replace'. These correspond to the functions that you defined earlier: insert_letter(), delete_letter() and replace_letter(). switch_letter() is not used here.

The diagram below describes how to initialize the table. Each entry in D[i,j] represents the minimum cost of converting string source[0:i] to string target[0:j]. The first column is initialized to represent the cumulative cost of deleting the source characters to convert string "EER" to "". The first row is initialized to represent the cumulative cost of inserting the target characters to convert from "" to "NEAR".

 Figure 6 Initializing Distance Matrix

Filling in the remainder of the table utilizes the 'Per Cell Operations' in the equation (5) above. Note, the diagram below includes in the table some of the 3 sub-calculations shown in light grey. Only 'min' of those operations is stored in the table in the `min_edit_distance()` function.

 Figure 7 Filling Distance Matrix

Note that the formula for $D[i,j]$ shown in the image is equivalent to:

\begin{align}
 \\
D[i,j] =min
\begin{cases}
D[i-1,j] + del\_cost\\
D[i,j-1] + ins\_cost\\
D[i-1,j-1] + \left\{\begin{matrix}
rep\_cost; & if src[i]\neq tar[j]\\
0 ; & if src[i]=tar[j]
\end{matrix}\right.
\end{cases}
\tag{5}
\end{align}

The variable `sub_cost` (for substitution cost) is the same as `rep_cost`; replacement cost.  We will stick with the term "replace" whenever possible.

Below are some examples of cells where replacement is used. This also shows the minimum path from the lower right final position where "EER" has been replaced by "NEAR" back to the start. This provides a starting point for the optional 'backtrace' algorithm below.

 Figure 8 Examples Distance Matrix

### Exercise 11

Again, the word "substitution" appears in the figure, but think of this as "replacement".

**Instructions**: Implement the function below to get the minimum amount of edits required given a source string and a target string.

    Hints

The range(start, stop, step) function excludes 'stop' from its output

 words

```python
def min_edit_distance(source, target, ins_cost = 1, del_cost = 1, rep_cost = 2):
    '''
    Input:
        source: a string corresponding to the string you are starting with
        target: a string corresponding to the string you want to end with
        ins_cost: an integer setting the insert cost
        del_cost: an integer setting the delete cost
        rep_cost: an integer setting the replace cost
    Output:
        D: a matrix of len(source)+1 by len(target)+1 containing minimum edit distances
        med: the minimum edit distance (med) required to convert the source string to the target
    '''
    # use deletion and insert cost as  1
    m = len(source)
    n = len(target)
    #initialize cost matrix with zeros and dimensions (m+1,n+1)
    D = np.zeros((m+1, n+1), dtype=int)

    ### START CODE HERE (Replace instances of 'None' with your code) ###

    # Fill in column 0, from row 1 to row m, both inclusive
    for row in range(1, m+1): # Replace None with the proper range
        D[row,0] = D[row-1, 0] + del_cost

    # Fill in row 0, for all columns from 1 to n, both inclusive
    for col in range(1, n+1): # Replace None with the proper range
        D[0,col] = D[0, col-1] + ins_cost

    # Loop through row 1 to row m, both inclusive
    for row in range(1, m+1):

        # Loop through column 1 to column n, both inclusive
        for col in range(1, n+1):

            # Intialize r_cost to the 'replace' cost that is passed into this function
            r_cost = rep_cost

            # Check to see if source character at the previous row
            # matches the target character at the previous column,
            if source[row-1] == target[col-1]:
                # Update the replacement cost to 0 if source and target are the same
                r_cost = 0

            # Update the cost at row, col based on previous entries in the cost matrix
            # Refer to the equation calculate for D[i,j] (the minimum of three calculated costs)
            D[row, col] = min([D[row-1, col] + del_cost, D[row, col-1] + ins_cost, D[row-1,col-1] + r_cost])

    # Set the minimum edit distance with the cost found at row m, column n
    med = D[m, n]

    ### END CODE HERE ###
    return D, med
```

```python
# testing your implementation
source =  'play'
target = 'stay'
matrix, min_edits = min_edit_distance(source, target)
print("minimum edits: ",min_edits, "\n")
idx = list('#' + source)
cols = list('#' + target)
df = pd.DataFrame(matrix, index=idx, columns= cols)
print(df)
```

    minimum edits:  4

       #  s  t  a  y
    #  0  1  2  3  4
    p  1  2  3  4  5
    l  2  3  4  5  6
    a  3  4  5  4  5
    y  4  5  6  5  4

**Expected Results:**

```CPP
minimum edits:  4

   #  s  t  a  y
#  0  1  2  3  4
p  1  2  3  4  5
l  2  3  4  5  6
a  3  4  5  4  5
y  4  5  6  5  4
```

```python
#DO NOT MODIFY THIS CELL
# testing your implementation
source =  'eer'
target = 'near'
matrix, min_edits = min_edit_distance(source, target)
print("minimum edits: ",min_edits, "\n")
idx = list(source)
idx.insert(0, '#')
cols = list(target)
cols.insert(0, '#')
df = pd.DataFrame(matrix, index=idx, columns= cols)
print(df)
```

    minimum edits:  3

       #  n  e  a  r
    #  0  1  2  3  4
    e  1  2  1  2  3
    e  2  3  2  3  4
    r  3  4  3  4  3

**Expected Results**
```CPP
minimum edits:  3

   #  n  e  a  r
#  0  1  2  3  4
e  1  2  1  2  3
e  2  3  2  3  4
r  3  4  3  4  3
```

We can now test several of our routines at once:

```python
source = "eer"
targets = edit_one_letter(source,allow_switches = False)  #disable switches since min_edit_distance does not include them
for t in targets:
    _, min_edits = min_edit_distance(source, t,1,1,1)  # set ins, del, sub costs all to one
    if min_edits != 1: print(source, t, min_edits)
```

    eer mmr 2
    eer iir 2
    eer vvr 2
    eer aar 2
    eer ggr 2
    eer ssr 2
    eer hhr 2
    eer wwr 2
    eer yyr 2
    eer qqr 2
    eer uur 2
    eer llr 2
    eer ffr 2
    eer nnr 2
    eer jjr 2
    eer rrr 2
    eer ppr 2
    eer ddr 2
    eer ccr 2
    eer bbr 2
    eer zzr 2
    eer ttr 2
    eer kkr 2
    eer oor 2
    eer xxr 2

**Expected Results**
```CPP
(empty)
```

The 'replace()' routine utilizes all letters a-z one of which returns the original word.

```python
source = "eer"
targets = edit_two_letters(source,allow_switches = False) #disable switches since min_edit_distance does not include them
for t in targets:
    _, min_edits = min_edit_distance(source, t,1,1,1)  # set ins, del, sub costs all to one
    if min_edits != 2 and min_edits != 1: print(source, t, min_edits)
```

    eer qvvr 3
    eer kkrm 3
    eer xqxr 3
    eer wwar 3
    eer vva 3
    eer niir 3
    eer ffrh 3
    eer moor 3
    eer cdcr 3
    eer bbrh 3
    eer hoor 3
    eer xxhr 3
    eer cch 3
    eer ykkr 3
    eer ddkr 3
    eer rrrk 3
    eer mmrq 3
    eer nngr 3
    eer wwrk 3
    eer ffro 3
    eer hyhr 3
    eer qqd 3
    eer ootr 3
    eer vhhr 3
    eer zzor 3
    eer uutr 3
    eer ppmr 3
    eer dnnr 3
    eer ttdr 3
    eer pqpr 3
    eer jnjr 3
    eer kkcr 3
    eer mm 3
    eer ooe 3
    eer ffrw 3
    eer ggi 3
    eer uupr 3
    eer titr 3
    eer ppd 3
    eer qqrp 3
    eer mhhr 3
    eer fyyr 3
    eer uurs 3
    eer llzr 3
    eer hhb 3
    eer ddrm 3
    eer vvo 3
    eer vvi 3
    eer xppr 3
    eer bbw 3
    eer mmrw 3
    eer rrru 3
    eer awar 3
    eer lqqr 3
    eer ss 3
    eer nnvr 3
    eer oom 3
    eer txtr 3
    eer qqrg 3
    eer jjq 3
    eer mmrr 3
    eer sjjr 3
    eer rrpr 3
    eer hhjr 3
    eer vvsr 3
    eer nnx 3
    eer xccr 3
    eer cwcr 3
    eer vvf 3
    eer didr 3
    eer wjjr 3
    eer qqdr 3
    eer wwv 3
    eer hhv 3
    eer vve 3
    eer jjrw 3
    eer yyhr 3
    eer shhr 3
    eer haar 3
    eer ffvr 3
    eer xxmr 3
    eer bbrg 3
    eer rry 3
    eer ddrs 3
    eer hhnr 3
    eer oohr 3
    eer vvor 3
    eer tto 3
    eer dldr 3
    eer jjpr 3
    eer ccc 3
    eer zzro 3
    eer aars 3
    eer mmpr 3
    eer ddc 3
    eer uuru 3
    eer ppqr 3
    eer xxnr 3
    eer tbtr 3
    eer zzrv 3
    eer bnnr 3
    eer xaxr 3
    eer bbgr 3
    eer bbrq 3
    eer jxjr 3
    eer ccnr 3
    eer kksr 3
    eer zzrn 3
    eer iirr 3
    eer qqra 3
    eer ggrk 3
    eer ikir 3
    eer kkra 3
    eer lalr 3
    eer bbz 3
    eer qqrv 3
    eer ttlr 3
    eer ppx 3
    eer ppbr 3
    eer icir 3
    eer hhzr 3
    eer kxxr 3
    eer npnr 3
    eer kkrt 3
    eer vvh 3
    eer kkry 3
    eer ddru 3
    eer uuv 3
    eer yywr 3
    eer bjjr 3
    eer qqrb 3
    eer ccrw 3
    eer wfwr 3
    eer rrrf 3
    eer xxpr 3
    eer pprd 3
    eer yyru 3
    eer mml 3
    eer ssbr 3
    eer cc 3
    eer bbi 3
    eer ooz 3
    eer rdrr 3
    eer qqrr 3
    eer vvs 3
    eer ahar 3
    eer aae 3
    eer mumr 3
    eer nonr 3
    eer iqqr 3
    eer ggrh 3
    eer nni 3
    eer mmt 3
    eer wwrq 3
    eer qqri 3
    eer ssri 3
    eer mmwr 3
    eer ammr 3
    eer ccrt 3
    eer fmmr 3
    eer wywr 3
    eer aat 3
    eer yjjr 3
    eer kkrw 3
    eer pprp 3
    eer ccyr 3
    eer yrrr 3
    eer yhyr 3
    eer aard 3
    eer xxh 3
    eer wmwr 3
    eer cqqr 3
    eer mmra 3
    eer mlmr 3
    eer jjk 3
    eer uure 3
    eer offr 3
    eer nynr 3
    eer vqvr 3
    eer vvm 3
    eer cchr 3
    eer bbrn 3
    eer jjd 3
    eer txxr 3
    eer puur 3
    eer fffr 3
    eer vvfr 3
    eer onor 3
    eer ggnr 3
    eer zzi 3
    eer kkur 3
    eer xxrj 3
    eer xxu 3
    eer xxrp 3
    eer tvvr 3
    eer bbrz 3
    eer ppe 3
    eer ttyr 3
    eer uhhr 3
    eer uurj 3
    eer zzrf 3
    eer nnry 3
    eer ssw 3
    eer opor 3
    eer ttrg 3
    eer tty 3
    eer mmx 3
    eer rrry 3
    eer ttb 3
    eer cctr 3
    eer wwqr 3
    eer iis 3
    eer liir 3
    eer gllr 3
    eer jwjr 3
    eer vwwr 3
    eer zzc 3
    eer pmpr 3
    eer wiwr 3
    eer vvt 3
    eer xxrt 3
    eer wqwr 3
    eer ccor 3
    eer mxmr 3
    eer fttr 3
    eer pprm 3
    eer hhi 3
    eer kkjr 3
    eer ucur 3
    eer kkn 3
    eer hhq 3
    eer akar 3
    eer ooq 3
    eer vmmr 3
    eer xxrb 3
    eer mdmr 3
    eer iirv 3
    eer nnra 3
    eer yyri 3
    eer ccir 3
    eer aajr 3
    eer vv 3
    eer ulur 3
    eer ggx 3
    eer utur 3
    eer iikr 3
    eer ttcr 3
    eer aaar 3
    eer mmrc 3
    eer rgrr 3
    eer yyrs 3
    eer xxcr 3
    eer mmdr 3
    eer rffr 3
    eer iair 3
    eer mmar 3
    eer kkb 3
    eer vjvr 3
    eer ppxr 3
    eer xxvr 3
    eer ohor 3
    eer wwq 3
    eer llc 3
    eer wnnr 3
    eer ajjr 3
    eer swwr 3
    eer yyra 3
    eer vvq 3
    eer jyyr 3
    eer ccrz 3
    eer lmlr 3
    eer mppr 3
    eer lclr 3
    eer ffrn 3
    eer jjrm 3
    eer ccrs 3
    eer oodr 3
    eer fyfr 3
    eer kttr 3
    eer aoor 3
    eer yayr 3
    eer yyo 3
    eer uurd 3
    eer yyrr 3
    eer dgdr 3
    eer dmmr 3
    eer pdpr 3
    eer xhhr 3
    eer cxxr 3
    eer agar 3
    eer ssfr 3
    eer ojor 3
    eer nnhr 3
    eer xkxr 3
    eer wwra 3
    eer yyg 3
    eer qoor 3
    eer pqqr 3
    eer pddr 3
    eer jggr 3
    eer whhr 3
    eer ssrt 3
    eer muur 3
    eer ddm 3
    eer fff 3
    eer iirq 3
    eer fvfr 3
    eer yyz 3
    eer qppr 3
    eer bbri 3
    eer yqqr 3
    eer zvzr 3
    eer nsnr 3
    eer vbbr 3
    eer ccra 3
    eer uuy 3
    eer gzzr 3
    eer ddmr 3
    eer yyn 3
    eer tiir 3
    eer qrrr 3
    eer gssr 3
    eer aao 3
    eer iijr 3
    eer wwrf 3
    eer wjwr 3
    eer ffx 3
    eer tatr 3
    eer rrrs 3
    eer llra 3
    eer ffg 3
    eer wddr 3
    eer jju 3
    eer faar 3
    eer nncr 3
    eer uoor 3
    eer ssa 3
    eer uun 3
    eer wwrm 3
    eer rrb 3
    eer iixr 3
    eer ayar 3
    eer mmb 3
    eer hjhr 3
    eer nwnr 3
    eer ihir 3
    eer bbl 3
    eer kkmr 3
    eer wyyr 3
    eer vtvr 3
    eer iirb 3
    eer jijr 3
    eer yyrx 3
    eer uui 3
    eer sswr 3
    eer kkrd 3
    eer wdwr 3
    eer jxxr 3
    eer iirc 3
    eer ktkr 3
    eer yyjr 3
    eer jjrr 3
    eer dds 3
    eer pprh 3
    eer accr 3
    eer pssr 3
    eer vvra 3
    eer hllr 3
    eer arrr 3
    eer ssor 3
    eer llm 3
    eer wwgr 3
    eer bbcr 3
    eer qqa 3
    eer aaru 3
    eer wwwr 3
    eer appr 3
    eer mqmr 3
    eer llrx 3
    eer gttr 3
    eer jjrl 3
    eer jvvr 3
    eer qsqr 3
    eer poor 3
    eer mmjr 3
    eer vvp 3
    eer ssrq 3
    eer smsr 3
    eer bbrb 3
    eer ujjr 3
    eer uurw 3
    eer ttpr 3
    eer jjri 3
    eer ssrs 3
    eer knkr 3
    eer crcr 3
    eer wccr 3
    eer yyi 3
    eer ccpr 3
    eer xxrm 3
    eer kukr 3
    eer wwn 3
    eer ttqr 3
    eer rryr 3
    eer zszr 3
    eer ggf 3
    eer ggrq 3
    eer oxor 3
    eer aap 3
    eer xiir 3
    eer mrrr 3
    eer aawr 3
    eer kk 3
    eer uuir 3
    eer rggr 3
    eer sysr 3
    eer qtqr 3
    eer ddj 3
    eer uuvr 3
    eer rrro 3
    eer bbe 3
    eer mwmr 3
    eer aart 3
    eer bbwr 3
    eer cucr 3
    eer itir 3
    eer hhmr 3
    eer fvvr 3
    eer isir 3
    eer bobr 3
    eer mhmr 3
    eer bbs 3
    eer ggd 3
    eer uffr 3
    eer uvvr 3
    eer mmir 3
    eer zzzr 3
    eer ccmr 3
    eer pnpr 3
    eer mvvr 3
    eer llvr 3
    eer kkx 3
    eer mmrz 3
    eer kkir 3
    eer snnr 3
    eer fzfr 3
    eer qdqr 3
    eer yyh 3
    eer rjrr 3
    eer ddrh 3
    eer dyyr 3
    eer ccf 3
    eer jjp 3
    eer ggrm 3
    eer zssr 3
    eer wuur 3
    eer ll 3
    eer tvtr 3
    eer xxyr 3
    eer hhf 3
    eer cct 3
    eer bsbr 3
    eer hbbr 3
    eer aark 3
    eer ttl 3
    eer ddro 3
    eer jjj 3
    eer kkgr 3
    eer nyyr 3
    eer pps 3
    eer jjf 3
    eer qffr 3
    eer oorj 3
    eer zzl 3
    eer mmre 3
    eer ggri 3
    eer ouor 3
    eer zxxr 3
    eer iih 3
    eer oomr 3
    eer iipr 3
    eer hhp 3
    eer uuq 3
    eer bbrm 3
    eer zzrr 3
    eer ooa 3
    eer zzxr 3
    eer zzrb 3
    eer joor 3
    eer bbtr 3
    eer ssre 3
    eer xx 3
    eer kkar 3
    eer qgqr 3
    eer vvdr 3
    eer gjgr 3
    eer suur 3
    eer gjjr 3
    eer vvrv 3
    eer llv 3
    eer sslr 3
    eer pptr 3
    eer ffor 3
    eer ttri 3
    eer wwtr 3
    eer zzrw 3
    eer cci 3
    eer wwrp 3
    eer lklr 3
    eer rrcr 3
    eer wcwr 3
    eer kkpr 3
    eer shsr 3
    eer iyir 3
    eer pplr 3
    eer uuh 3
    eer qqar 3
    eer vvn 3
    eer vvzr 3
    eer xnnr 3
    eer ggg 3
    eer boor 3
    eer ypyr 3
    eer qqf 3
    eer xaar 3
    eer hnnr 3
    eer awwr 3
    eer iirw 3
    eer yyrq 3
    eer jji 3
    eer yyrd 3
    eer yffr 3
    eer axxr 3
    eer qqrl 3
    eer ztzr 3
    eer xxa 3
    eer ttro 3
    eer llro 3
    eer uaar 3
    eer mmu 3
    eer ddd 3
    eer nnnr 3
    eer uurt 3
    eer owwr 3
    eer nnv 3
    eer nddr 3
    eer ajar 3
    eer momr 3
    eer vttr 3
    eer ssry 3
    eer sgsr 3
    eer fwwr 3
    eer sskr 3
    eer bmmr 3
    eer kklr 3
    eer vvrx 3
    eer xxrx 3
    eer pwpr 3
    eer qqxr 3
    eer yyj 3
    eer uuqr 3
    eer whwr 3
    eer zzrj 3
    eer ggyr 3
    eer ppcr 3
    eer kkj 3
    eer hhtr 3
    eer hohr 3
    eer mmmr 3
    eer bpbr 3
    eer iim 3
    eer sddr 3
    eer ttvr 3
    eer yyrm 3
    eer yyvr 3
    eer fcfr 3
    eer kwwr 3
    eer hvvr 3
    eer aarl 3
    eer zzpr 3
    eer wwrt 3
    eer qqmr 3
    eer hhlr 3
    eer cbbr 3
    eer ooru 3
    eer aaro 3
    eer ccp 3
    eer vwvr 3
    eer mamr 3
    eer tssr 3
    eer ggk 3
    eer pprv 3
    eer ppir 3
    eer sszr 3
    eer aah 3
    eer aamr 3
    eer mms 3
    eer aari 3
    eer ttrx 3
    eer ggbr 3
    eer xxsr 3
    eer kkhr 3
    eer nmnr 3
    eer nbnr 3
    eer mmyr 3
    eer aaz 3
    eer jvjr 3
    eer gvvr 3
    eer ggir 3
    eer rrsr 3
    eer iia 3
    eer bbor 3
    eer vvwr 3
    eer aary 3
    eer jjry 3
    eer hhd 3
    eer hhre 3
    eer qqb 3
    eer nns 3
    eer hhor 3
    eer ppgr 3
    eer llk 3
    eer ooqr 3
    eer qqu 3
    eer qzzr 3
    eer xxg 3
    eer rrhr 3
    eer llqr 3
    eer hhcr 3
    eer aaur 3
    eer oppr 3
    eer ppa 3
    eer vvnr 3
    eer uurn 3
    eer wwi 3
    eer pprl 3
    eer ynnr 3
    eer dtdr 3
    eer ccd 3
    eer qqrx 3
    eer nnsr 3
    eer immr 3
    eer abbr 3
    eer aiir 3
    eer uum 3
    eer ffur 3
    eer xxc 3
    eer rrur 3
    eer vvrj 3
    eer tddr 3
    eer ssrc 3
    eer ibir 3
    eer zczr 3
    eer kkre 3
    eer jjrb 3
    eer tta 3
    eer ttj 3
    eer jjwr 3
    eer annr 3
    eer axar 3
    eer bppr 3
    eer ppur 3
    eer yym 3
    eer ssh 3
    eer wwrl 3
    eer mmry 3
    eer pprc 3
    eer llwr 3
    eer rirr 3
    eer nnur 3
    eer zzmr 3
    eer dxxr 3
    eer ybbr 3
    eer ffrp 3
    eer iip 3
    eer gogr 3
    eer xxrs 3
    eer jjqr 3
    eer ppsr 3
    eer ooc 3
    eer bnbr 3
    eer rwwr 3
    eer cllr 3
    eer smmr 3
    eer ddgr 3
    eer zyzr 3
    eer wkwr 3
    eer rhhr 3
    eer kjjr 3
    eer ttc 3
    eer qqg 3
    eer ff 3
    eer mmor 3
    eer xpxr 3
    eer yyar 3
    eer vqqr 3
    eer ddo 3
    eer orrr 3
    eer ddir 3
    eer qqrz 3
    eer aapr 3
    eer kckr 3
    eer zwwr 3
    eer jjh 3
    eer mmg 3
    eer iizr 3
    eer ssrr 3
    eer arar 3
    eer fxxr 3
    eer kdkr 3
    eer srrr 3
    eer llg 3
    eer ggrs 3
    eer cjjr 3
    eer jjrd 3
    eer ttbr 3
    eer yyry 3
    eer iij 3
    eer rrvr 3
    eer kkrk 3
    eer ttk 3
    eer urur 3
    eer zzrm 3
    eer wwor 3
    eer zzry 3
    eer wqqr 3
    eer dbbr 3
    eer iibr 3
    eer oorh 3
    eer aarm 3
    eer ocor 3
    eer ohhr 3
    eer lxxr 3
    eer cpcr 3
    eer cvvr 3
    eer bbru 3
    eer oori 3
    eer xxs 3
    eer xxx 3
    eer kxkr 3
    eer yyor 3
    eer ccjr 3
    eer rrir 3
    eer jiir 3
    eer vvxr 3
    eer sspr 3
    eer kkz 3
    eer ufur 3
    eer kffr 3
    eer rrn 3
    eer usur 3
    eer iirs 3
    eer llrr 3
    eer ullr 3
    eer zz 3
    eer ddy 3
    eer ooo 3
    eer kccr 3
    eer kykr 3
    eer iiv 3
    eer xxp 3
    eer aaw 3
    eer lggr 3
    eer otor 3
    eer prrr 3
    eer ogor 3
    eer jjdr 3
    eer ppt 3
    eer ffdr 3
    eer vvvr 3
    eer aaqr 3
    eer ddzr 3
    eer ilir 3
    eer ddra 3
    eer bblr 3
    eer vnnr 3
    eer dsdr 3
    eer bbc 3
    eer hhhr 3
    eer yygr 3
    eer ppi 3
    eer ffrj 3
    eer hhrj 3
    eer vvre 3
    eer zjzr 3
    eer qqrj 3
    eer yyx 3
    eer nvnr 3
    eer ggrb 3
    eer vvrz 3
    eer spsr 3
    eer ccn 3
    eer ylyr 3
    eer pbbr 3
    eer nnrp 3
    eer yyir 3
    eer jjt 3
    eer ggl 3
    eer vvx 3
    eer llrp 3
    eer ddfr 3
    eer ttur 3
    eer yykr 3
    eer vovr 3
    eer ggb 3
    eer ssnr 3
    eer qmqr 3
    eer vjjr 3
    eer aiar 3
    eer rxxr 3
    eer zztr 3
    eer lblr 3
    eer ttt 3
    eer qhqr 3
    eer nnj 3
    eer oory 3
    eer kkrb 3
    eer krrr 3
    eer sksr 3
    eer gg 3
    eer vzvr 3
    eer aak 3
    eer ssrg 3
    eer iil 3
    eer zzrl 3
    eer vvv 3
    eer afar 3
    eer zdzr 3
    eer zzk 3
    eer cckr 3
    eer djdr 3
    eer jjrq 3
    eer brrr 3
    eer ycyr 3
    eer slsr 3
    eer qbqr 3
    eer jjrh 3
    eer ddrk 3
    eer azar 3
    eer ggrx 3
    eer pph 3
    eer hhrc 3
    eer rssr 3
    eer uzur 3
    eer kkqr 3
    eer tgtr 3
    eer gwwr 3
    eer uour 3
    eer ttrw 3
    eer aad 3
    eer ffrs 3
    eer mmw 3
    eer chhr 3
    eer ooar 3
    eer tjjr 3
    eer wowr 3
    eer wwpr 3
    eer nn 3
    eer lyyr 3
    eer mmrk 3
    eer ssrw 3
    eer auar 3
    eer hhsr 3
    eer jqqr 3
    eer kbbr 3
    eer bmbr 3
    eer jujr 3
    eer zzhr 3
    eer qhhr 3
    eer bbhr 3
    eer zzfr 3
    eer mmv 3
    eer vvyr 3
    eer innr 3
    eer uuk 3
    eer ivir 3
    eer ggpr 3
    eer jrjr 3
    eer zzqr 3
    eer lccr 3
    eer fiir 3
    eer kkq 3
    eer wwry 3
    eer aax 3
    eer ddq 3
    eer zbbr 3
    eer ffir 3
    eer jjre 3
    eer oolr 3
    eer mmc 3
    eer llur 3
    eer wwrg 3
    eer ccdr 3
    eer jjrk 3
    eer rrq 3
    eer zzn 3
    eer tmmr 3
    eer nffr 3
    eer ppg 3
    eer vpvr 3
    eer rrmr 3
    eer yddr 3
    eer ttmr 3
    eer ffy 3
    eer rkrr 3
    eer oaar 3
    eer ssi 3
    eer auur 3
    eer ddg 3
    eer wwrn 3
    eer sso 3
    eer zzrx 3
    eer yssr 3
    eer gddr 3
    eer fufr 3
    eer vvkr 3
    eer zzrg 3
    eer tmtr 3
    eer zzd 3
    eer oaor 3
    eer ssrb 3
    eer ffcr 3
    eer wwir 3
    eer ijir 3
    eer ggfr 3
    eer lylr 3
    eer qqfr 3
    eer vxxr 3
    eer fmfr 3
    eer hddr 3
    eer kokr 3
    eer uuxr 3
    eer nnh 3
    eer jnnr 3
    eer oior 3
    eer zzx 3
    eer lnnr 3
    eer aarq 3
    eer aaxr 3
    eer oorl 3
    eer pp 3
    eer qcqr 3
    eer pllr 3
    eer ssg 3
    eer oob 3
    eer zddr 3
    eer rrv 3
    eer llh 3
    eer fdfr 3
    eer ddry 3
    eer uurv 3
    eer rrrl 3
    eer hhbr 3
    eer kkv 3
    eer dndr 3
    eer nnyr 3
    eer vvbr 3
    eer lvlr 3
    eer uuo 3
    eer ggo 3
    eer rbrr 3
    eer qqhr 3
    eer kks 3
    eer pgpr 3
    eer ttp 3
    eer cjcr 3
    eer ffzr 3
    eer bxbr 3
    eer qvqr 3
    eer oou 3
    eer nxxr 3
    eer rrar 3
    eer adar 3
    eer iira 3
    eer hghr 3
    eer oorw 3
    eer tqqr 3
    eer yysr 3
    eer vvar 3
    eer wwt 3
    eer kkh 3
    eer vvrr 3
    eer pprt 3
    eer quur 3
    eer oror 3
    eer ssz 3
    eer ummr 3
    eer ssrm 3
    eer ggqr 3
    eer jfjr 3
    eer yytr 3
    eer lllr 3
    eer jjw 3
    eer hhz 3
    eer mmrx 3
    eer tutr 3
    eer trrr 3
    eer lwwr 3
    eer ccre 3
    eer apar 3
    eer wwp 3
    eer rxrr 3
    eer iiru 3
    eer bbrw 3
    eer pkkr 3
    eer oovr 3
    eer ccrg 3
    eer aai 3
    eer rrdr 3
    eer oonr 3
    eer zzur 3
    eer qkqr 3
    eer fuur 3
    eer llz 3
    eer zzra 3
    eer zzrk 3
    eer qggr 3
    eer ssur 3
    eer igir 3
    eer jja 3
    eer bba 3
    eer kbkr 3
    eer bbvr 3
    eer jjrp 3
    eer wrrr 3
    eer xxrv 3
    eer bffr 3
    eer bjbr 3
    eer oowr 3
    eer ovvr 3
    eer yyq 3
    eer zzo 3
    eer goor 3
    eer llre 3
    eer ffrm 3
    eer kkrh 3
    eer qaar 3
    eer hhru 3
    eer qqsr 3
    eer ymyr 3
    eer ttrp 3
    eer xxd 3
    eer ffxr 3
    eer kkrn 3
    eer ffl 3
    eer yjyr 3
    eer hzzr 3
    eer vvpr 3
    eer ggh 3
    eer jjsr 3
    eer rrrn 3
    eer lslr 3
    eer llcr 3
    eer ffrt 3
    eer gxgr 3
    eer wwg 3
    eer jjg 3
    eer pxpr 3
    eer qqs 3
    eer ccg 3
    eer rarr 3
    eer bbo 3
    eer nssr 3
    eer zza 3
    eer bkkr 3
    eer zzdr 3
    eer bbfr 3
    eer ukur 3
    eer zyyr 3
    eer gnnr 3
    eer uury 3
    eer glgr 3
    eer kiir 3
    eer door 3
    eer gwgr 3
    eer xxrc 3
    eer jcjr 3
    eer tnnr 3
    eer ghhr 3
    eer rcrr 3
    eer yccr 3
    eer ttrc 3
    eer yyrb 3
    eer biir 3
    eer oow 3
    eer iiar 3
    eer qqrw 3
    eer rfrr 3
    eer ttrb 3
    eer ozzr 3
    eer yhhr 3
    eer aarb 3
    eer hhrx 3
    eer xtxr 3
    eer llb 3
    eer pccr 3
    eer bbrs 3
    eer zzj 3
    eer prpr 3
    eer qkkr 3
    eer vvz 3
    eer xttr 3
    eer sqsr 3
    eer iccr 3
    eer xrrr 3
    eer xxlr 3
    eer nnb 3
    eer duur 3
    eer jkkr 3
    eer yoyr 3
    eer jmmr 3
    eer rru 3
    eer pprz 3
    eer lulr 3
    eer kkvr 3
    eer hnhr 3
    eer zzrh 3
    eer ooj 3
    eer bfbr 3
    eer bbqr 3
    eer fafr 3
    eer wwri 3
    eer czzr 3
    eer zzt 3
    eer addr 3
    eer twwr 3
    eer gngr 3
    eer qqy 3
    eer rrwr 3
    eer mmf 3
    eer zzw 3
    eer kssr 3
    eer uurf 3
    eer ttu 3
    eer llf 3
    eer gbgr 3
    eer ddwr 3
    eer ahhr 3
    eer zzyr 3
    eer qfqr 3
    eer nwwr 3
    eer xxkr 3
    eer uuwr 3
    eer alar 3
    eer bqqr 3
    eer vvrm 3
    eer ssl 3
    eer cczr 3
    eer jyjr 3
    eer ggzr 3
    eer ggvr 3
    eer oof 3
    eer wwjr 3
    eer wtwr 3
    eer jtjr 3
    eer wpwr 3
    eer zkzr 3
    eer uwur 3
    eer uttr 3
    eer dllr 3
    eer hhwr 3
    eer qqro 3
    eer qqre 3
    eer iicr 3
    eer zzrs 3
    eer fofr 3
    eer wxxr 3
    eer ppry 3
    eer caar 3
    eer ffyr 3
    eer asar 3
    eer lkkr 3
    eer hchr 3
    eer dde 3
    eer jjrv 3
    eer ooi 3
    eer ppp 3
    eer bbpr 3
    eer ssv 3
    eer gsgr 3
    eer kka 3
    eer mmrl 3
    eer tt 3
    eer jjrj 3
    eer ddyr 3
    eer oocr 3
    eer zrrr 3
    eer hhc 3
    eer saar 3
    eer zazr 3
    eer ccx 3
    eer ffz 3
    eer yyv 3
    eer ppnr 3
    eer wwrc 3
    eer wxwr 3
    eer gqgr 3
    eer hhpr 3
    eer kmmr 3
    eer kzkr 3
    eer imir 3
    eer ssrf 3
    eer llri 3
    eer cncr 3
    eer jjtr 3
    eer dssr 3
    eer xixr 3
    eer nnir 3
    eer fppr 3
    eer vsvr 3
    eer ccrf 3
    eer rvrr 3
    eer ddtr 3
    eer wwcr 3
    eer oojr 3
    eer lflr 3
    eer wggr 3
    eer ninr 3
    eer ssx 3
    eer nnrs 3
    eer ggry 3
    eer lmmr 3
    eer oddr 3
    eer qoqr 3
    eer maar 3
    eer hvhr 3
    eer dzzr 3
    eer bbx 3
    eer yyrl 3
    eer ddrt 3
    eer pmmr 3
    eer kkrz 3
    eer bbro 3
    eer issr 3
    eer aan 3
    eer fbbr 3
    eer ccrd 3
    eer jjxr 3
    eer jwwr 3
    eer oora 3
    eer mma 3
    eer yzyr 3
    eer qttr 3
    eer mmro 3
    eer ffrf 3
    eer taar 3
    eer nxnr 3
    eer rrm 3
    eer hxhr 3
    eer jljr 3
    eer ggjr 3
    eer iiro 3
    eer rra 3
    eer dpdr 3
    eer tytr 3
    eer ppvr 3
    eer nna 3
    eer uukr 3
    eer iiyr 3
    eer gxxr 3
    eer dodr 3
    eer avvr 3
    eer iddr 3
    eer ikkr 3
    eer jjo 3
    eer uue 3
    eer ffw 3
    eer qccr 3
    eer cuur 3
    eer hyyr 3
    eer wwx 3
    eer vvj 3
    eer kkkr 3
    eer gygr 3
    eer rjjr 3
    eer jjgr 3
    eer lwlr 3
    eer oo 3
    eer oofr 3
    eer hhrw 3
    eer mmrn 3
    eer dcdr 3
    eer ssdr 3
    eer lqlr 3
    eer iwwr 3
    eer nnfr 3
    eer wws 3
    eer kke 3
    eer wwrb 3
    eer qqrd 3
    eer ffhr 3
    eer svsr 3
    eer rkkr 3
    eer rrj 3
    eer ixir 3
    eer bbv 3
    eer gglr 3
    eer nnar 3
    eer xnxr 3
    eer yttr 3
    eer rorr 3
    eer kmkr 3
    eer yoor 3
    eer rrrd 3
    eer xffr 3
    eer jjbr 3
    eer ooyr 3
    eer mqqr 3
    eer ddrg 3
    eer zzu 3
    eer qqor 3
    eer yxyr 3
    eer kknr 3
    eer ptpr 3
    eer dxdr 3
    eer foor 3
    eer llx 3
    eer sbbr 3
    eer iiz 3
    eer nmmr 3
    eer mkmr 3
    eer rqqr 3
    eer vvtr 3
    eer aacr 3
    eer ssru 3
    eer bzzr 3
    eer vgvr 3
    eer bbq 3
    eer ddb 3
    eer ossr 3
    eer vvy 3
    eer qqvr 3
    eer xxir 3
    eer ymmr 3
    eer qiir 3
    eer hhar 3
    eer wwyr 3
    eer ooy 3
    eer ggs 3
    eer yye 3
    eer zizr 3
    eer hht 3
    eer uug 3
    eer nnrd 3
    eer ggz 3
    eer rccr 3
    eer hwwr 3
    eer mmrt 3
    eer vuvr 3
    eer fflr 3
    eer ggrc 3
    eer ddrr 3
    eer iib 3
    eer fgfr 3
    eer jddr 3
    eer ccrb 3
    eer kjkr 3
    eer ccry 3
    eer ojjr 3
    eer zzq 3
    eer iirz 3
    eer xyxr 3
    eer xxgr 3
    eer pprs 3
    eer bccr 3
    eer vppr 3
    eer yyzr 3
    eer jffr 3
    eer bbbr 3
    eer aare 3
    eer mnmr 3
    eer ood 3
    eer xxk 3
    eer bkbr 3
    eer dudr 3
    eer wkkr 3
    eer ffrv 3
    eer ssjr 3
    eer uhur 3
    eer rrk 3
    eer vkkr 3
    eer iirh 3
    eer sppr 3
    eer aara 3
    eer qqrs 3
    eer ggru 3
    eer kkrp 3
    eer buur 3
    eer mssr 3
    eer kkor 3
    eer jdjr 3
    eer ppzr 3
    eer rror 3
    eer uul 3
    eer nbbr 3
    eer mxxr 3
    eer yyre 3
    eer hhrb 3
    eer wwdr 3
    eer vmvr 3
    eer qqo 3
    eer ttfr 3
    eer mwwr 3
    eer lhhr 3
    eer nnzr 3
    eer hhrg 3
    eer pprx 3
    eer kpkr 3
    eer qlqr 3
    eer ffv 3
    eer nhnr 3
    eer uulr 3
    eer uurr 3
    eer mkkr 3
    eer ttn 3
    eer qiqr 3
    eer gmmr 3
    eer mmrj 3
    eer kuur 3
    eer obor 3
    eer uurp 3
    eer hfhr 3
    eer hjjr 3
    eer rqrr 3
    eer kllr 3
    eer wbwr 3
    eer ddi 3
    eer aal 3
    eer tttr 3
    eer ccl 3
    eer bbxr 3
    eer rrrj 3
    eer qwwr 3
    eer plpr 3
    eer iire 3
    eer hhrs 3
    eer iilr 3
    eer brbr 3
    eer ioir 3
    eer nanr 3
    eer qyyr 3
    eer nzzr 3
    eer wswr 3
    eer mmz 3
    eer rri 3
    eer kfkr 3
    eer vhvr 3
    eer rrx 3
    eer zzre 3
    eer ukkr 3
    eer oop 3
    eer tllr 3
    eer tqtr 3
    eer mmrd 3
    eer vvri 3
    eer kkwr 3
    eer bbry 3
    eer ryrr 3
    eer mmj 3
    eer jjvr 3
    eer cttr 3
    eer nnrz 3
    eer fifr 3
    eer jsjr 3
    eer ccq 3
    eer mffr 3
    eer rrrh 3
    eer iiri 3
    eer kkru 3
    eer sllr 3
    eer bbm 3
    eer pspr 3
    eer xddr 3
    eer ffar 3
    eer uyyr 3
    eer llp 3
    eer ttrh 3
    eer qqrt 3
    eer xxrw 3
    eer fnnr 3
    eer hhrv 3
    eer jjzr 3
    eer wwre 3
    eer mmrh 3
    eer oorm 3
    eer zzv 3
    eer oiir 3
    eer uccr 3
    eer uus 3
    eer uua 3
    eer ttra 3
    eer kkw 3
    eer viir 3
    eer sxxr 3
    eer hhfr 3
    eer vvjr 3
    eer mmm 3
    eer iiqr 3
    eer fjfr 3
    eer nnq 3
    eer skkr 3
    eer zzh 3
    eer ffwr 3
    eer crrr 3
    eer pzzr 3
    eer uurh 3
    eer mmrf 3
    eer sssr 3
    eer ssrd 3
    eer ppkr 3
    eer ssra 3
    eer cclr 3
    eer ddv 3
    eer qnqr 3
    eer izzr 3
    eer uurz 3
    eer xdxr 3
    eer ffrr 3
    eer eer 0
    eer cbcr 3
    eer mmrm 3
    eer bqbr 3
    eer cmcr 3
    eer qqtr 3
    eer dda 3
    eer hzhr 3
    eer assr 3
    eer ccu 3
    eer kkg 3
    eer lli 3
    eer oon 3
    eer jmjr 3
    eer ggn 3
    eer yvvr 3
    eer mmtr 3
    eer jjjr 3
    eer dkdr 3
    eer udur 3
    eer oorz 3
    eer lddr 3
    eer ollr 3
    eer qqpr 3
    eer qqw 3
    eer nnrg 3
    eer llt 3
    eer oorv 3
    eer iirf 3
    eer iidr 3
    eer gdgr 3
    eer xxri 3
    eer bzbr 3
    eer wmmr 3
    eer qqur 3
    eer yymr 3
    eer llnr 3
    eer lld 3
    eer ctcr 3
    eer cocr 3
    eer cycr 3
    eer cccr 3
    eer qqry 3
    eer pppr 3
    eer riir 3
    eer ccrq 3
    eer hhrd 3
    eer ddsr 3
    eer mpmr 3
    eer vyyr 3
    eer hbhr 3
    eer wwu 3
    eer scsr 3
    eer zttr 3
    eer xxqr 3
    eer yyrj 3
    eer aanr 3
    eer zqqr 3
    eer bbsr 3
    eer uuj 3
    eer zzjr 3
    eer ssxr 3
    eer kkk 3
    eer ovor 3
    eer idir 3
    eer nnru 3
    eer kgkr 3
    eer xxxr 3
    eer bbb 3
    eer jjv 3
    eer pphr 3
    eer yaar 3
    eer oorb 3
    eer ttrs 3
    eer jjyr 3
    eer ssy 3
    eer bb 3
    eer wwb 3
    eer upur 3
    eer rlrr 3
    eer hhir 3
    eer klkr 3
    eer pprw 3
    eer lttr 3
    eer ussr 3
    eer stsr 3
    eer bbra 3
    eer vvk 3
    eer nnrh 3
    eer ybyr 3
    eer iyyr 3
    eer bxxr 3
    eer tjtr 3
    eer qqkr 3
    eer qqrf 3
    eer raar 3
    eer aahr 3
    eer jjmr 3
    eer pipr 3
    eer ttd 3
    eer ssu 3
    eer fssr 3
    eer susr 3
    eer ppc 3
    eer rrjr 3
    eer jgjr 3
    eer bgbr 3
    eer oobr 3
    eer ihhr 3
    eer tstr 3
    eer nnwr 3
    eer sst 3
    eer xxw 3
    eer ggwr 3
    eer zzir 3
    eer mddr 3
    eer ttw 3
    eer aab 3
    eer yyrz 3
    eer hha 3
    eer hhri 3
    eer sscr 3
    eer ddu 3
    eer ggrg 3
    eer oog 3
    eer hlhr 3
    eer kkro 3
    eer llfr 3
    eer vvro 3
    eer lilr 3
    eer ntnr 3
    eer kkbr 3
    eer yggr 3
    eer ggrt 3
    eer xxt 3
    eer xkkr 3
    eer ggor 3
    eer fftr 3
    eer lla 3
    eer wwe 3
    eer ffn 3
    eer hhrr 3
    eer pyyr 3
    eer yy 3
    eer zzcr 3
    eer wwmr 3
    eer siir 3
    eer nggr 3
    eer bbar 3
    eer rrrw 3
    eer uusr 3
    eer ddrq 3
    eer odor 3
    eer qqi 3
    eer ofor 3
    eer zqzr 3
    eer jjor 3
    eer zzgr 3
    eer iik 3
    eer zzbr 3
    eer zuur 3
    eer kkri 3
    eer nqnr 3
    eer srsr 3
    eer tuur 3
    eer mllr 3
    eer mmrp 3
    eer ggrf 3
    eer cwwr 3
    eer llyr 3
    eer dccr 3
    eer aqar 3
    eer hffr 3
    eer ggv 3
    eer xlxr 3
    eer oyor 3
    eer qqrh 3
    eer rrd 3
    eer ssar 3
    eer iimr 3
    eer xbbr 3
    eer hhdr 3
    eer fqfr 3
    eer ttf 3
    eer ttrf 3
    eer oorp 3
    eer hho 3
    eer ssrp 3
    eer dkkr 3
    eer wwxr 3
    eer ppb 3
    eer giir 3
    eer djjr 3
    eer rrl 3
    eer ppra 3
    eer kkfr 3
    eer qddr 3
    eer gggr 3
    eer ddrb 3
    eer uddr 3
    eer ffrg 3
    eer vfvr 3
    eer ccru 3
    eer kkm 3
    eer ygyr 3
    eer rrrc 3
    eer yiyr 3
    eer iirk 3
    eer ddl 3
    eer pvpr 3
    eer qpqr 3
    eer tth 3
    eer jjn 3
    eer gffr 3
    eer zppr 3
    eer phpr 3
    eer iii 3
    eer xoor 3
    eer iirl 3
    eer ppv 3
    eer zoor 3
    eer qqjr 3
    eer kkrl 3
    eer koor 3
    eer kky 3
    eer hhur 3
    eer lppr 3
    eer xxy 3
    eer dttr 3
    eer ngnr 3
    eer tthr 3
    eer jjrs 3
    eer ppy 3
    eer pprq 3
    eer ysyr 3
    eer vllr 3
    eer ddk 3
    eer yyro 3
    eer yyl 3
    eer bbj 3
    eer yuur 3
    eer urrr 3
    eer cco 3
    eer vccr 3
    eer ggtr 3
    eer jjnr 3
    eer ttrk 3
    eer vvrt 3
    eer unnr 3
    eer ggp 3
    eer ujur 3
    eer mmh 3
    eer aqqr 3
    eer wwrz 3
    eer noor 3
    eer rrgr 3
    eer ynyr 3
    eer iirt 3
    eer yycr 3
    eer gqqr 3
    eer xxb 3
    eer ggcr 3
    eer uzzr 3
    eer gmgr 3
    eer wawr 3
    eer mmn 3
    eer khkr 3
    eer xjxr 3
    eer iiur 3
    eer llrf 3
    eer jjy 3
    eer aac 3
    eer zzsr 3
    eer piir 3
    eer nvvr 3
    eer kggr 3
    eer zze 3
    eer aalr 3
    eer qqcr 3
    eer ifir 3
    eer jaar 3
    eer yyrg 3
    eer bddr 3
    eer ffq 3
    eer cppr 3
    eer xxi 3
    eer ccm 3
    eer uuf 3
    eer ssrk 3
    eer nqqr 3
    eer vavr 3
    eer aarg 3
    eer kskr 3
    eer yzzr 3
    eer bbrj 3
    eer ddpr 3
    eer sasr 3
    eer nne 3
    eer jjur 3
    eer nunr 3
    eer ssj 3
    eer ssrx 3
    eer uux 3
    eer xxro 3
    eer xxe 3
    eer sdsr 3
    eer llsr 3
    eer iio 3
    eer xmxr 3
    eer ixxr 3
    eer nnjr 3
    eer ttrz 3
    eer iiwr 3
    eer ddor 3
    eer dbdr 3
    eer mzzr 3
    eer wwzr 3
    eer vrvr 3
    eer ppor 3
    eer soor 3
    eer xxwr 3
    eer gyyr 3
    eer zzkr 3
    eer nuur 3
    eer kkdr 3
    eer nntr 3
    eer dwwr 3
    eer ddqr 3
    eer pnnr 3
    eer jjhr 3
    eer llrl 3
    eer ccw 3
    eer qqrn 3
    eer clcr 3
    eer dydr 3
    eer ooh 3
    eer iiir 3
    eer mbbr 3
    eer yyrc 3
    eer hhvr 3
    eer mmnr 3
    eer wnwr 3
    eer flfr 3
    eer ncnr 3
    eer ttar 3
    eer lrlr 3
    eer fggr 3
    eer tftr 3
    eer ppwr 3
    eer ssrj 3
    eer kki 3
    eer aarx 3
    eer jllr 3
    eer xxz 3
    eer zzru 3
    eer ffo 3
    eer yvyr 3
    eer nnm 3
    eer vkvr 3
    eer jjl 3
    eer qqru 3
    eer yyw 3
    eer nllr 3
    eer dd 3
    eer llrh 3
    eer uub 3
    eer pupr 3
    eer xxfr 3
    eer vvcr 3
    eer ddar 3
    eer llrq 3
    eer rrrx 3
    eer llrj 3
    eer bubr 3
    eer yylr 3
    eer ppk 3
    eer wwnr 3
    eer ccrc 3
    eer ggro 3
    eer nnn 3
    eer cck 3
    eer tggr 3
    eer jzjr 3
    eer bssr 3
    eer avar 3
    eer ssc 3
    eer tkkr 3
    eer iivr 3
    eer bwbr 3
    eer aaq 3
    eer unur 3
    eer xxru 3
    eer kkf 3
    eer iirm 3
    eer vssr 3
    eer ddlr 3
    eer anar 3
    eer nnrq 3
    eer vvrp 3
    eer iior 3
    eer uuu 3
    eer aavr 3
    eer xvxr 3
    eer yypr 3
    eer rrkr 3
    eer oorx 3
    eer ippr 3
    eer jzzr 3
    eer hhk 3
    eer nnt 3
    eer nnrv 3
    eer rrh 3
    eer jjrx 3
    eer mmp 3
    eer qxqr 3
    eer uuor 3
    eer rttr 3
    eer ssp 3
    eer qwqr 3
    eer zznr 3
    eer hppr 3
    eer uurk 3
    eer xxrf 3
    eer vaar 3
    eer xsxr 3
    eer jjrz 3
    eer lbbr 3
    eer aarn 3
    eer hqqr 3
    eer nrrr 3
    eer zgzr 3
    eer rrg 3
    eer dwdr 3
    eer xxm 3
    eer phhr 3
    eer yyp 3
    eer ooir 3
    eer vvhr 3
    eer hhrp 3
    eer iuir 3
    eer llxr 3
    eer snsr 3
    eer ldlr 3
    eer czcr 3
    eer azzr 3
    eer wbbr 3
    eer mmi 3
    eer zuzr 3
    eer pcpr 3
    eer yllr 3
    eer rnnr 3
    eer okkr 3
    eer llrd 3
    eer ffp 3
    eer bbyr 3
    eer zvvr 3
    eer aarw 3
    eer ddrc 3
    eer nnrl 3
    eer ccbr 3
    eer uxxr 3
    eer llor 3
    eer dmdr 3
    eer llrg 3
    eer ggrd 3
    eer vvur 3
    eer hhl 3
    eer lzlr 3
    eer lljr 3
    eer uuc 3
    eer cicr 3
    eer uuz 3
    eer nfnr 3
    eer pprr 3
    eer ccj 3
    eer kkrx 3
    eer ggy 3
    eer jojr 3
    eer roor 3
    eer xxv 3
    eer aaf 3
    eer rrri 3
    eer kqkr 3
    eer illr 3
    eer kkrj 3
    eer llbr 3
    eer tdtr 3
    eer ssrl 3
    eer nnrj 3
    eer zzar 3
    eer fpfr 3
    eer lly 3
    eer lldr 3
    eer yyy 3
    eer amar 3
    eer ljjr 3
    eer aadr 3
    eer vvu 3
    eer pprk 3
    eer zzrt 3
    eer jjrg 3
    eer huur 3
    eer yyu 3
    eer lls 3
    eer ggre 3
    eer vvb 3
    eer jjx 3
    eer nnor 3
    eer ook 3
    eer ipir 3
    eer mmd 3
    eer ffrb 3
    eer nnrw 3
    eer xjjr 3
    eer xxrr 3
    eer vnvr 3
    eer ffnr 3
    eer aa 3
    eer qqnr 3
    eer cggr 3
    eer xxor 3
    eer xyyr 3
    eer ccwr 3
    eer llrw 3
    eer ww 3
    eer mbmr 3
    eer wwhr 3
    eer hhra 3
    eer uura 3
    eer pzpr 3
    eer ookr 3
    eer ccrh 3
    eer ccb 3
    eer hhn 3
    eer qqh 3
    eer umur 3
    eer wiir 3
    eer hhgr 3
    eer iinr 3
    eer sxsr 3
    eer xwxr 3
    eer ffk 3
    eer oox 3
    eer oore 3
    eer bvvr 3
    eer tccr 3
    eer iid 3
    eer nttr 3
    eer ddrv 3
    eer uurl 3
    eer lolr 3
    eer ssro 3
    eer nng 3
    eer ffrq 3
    eer ccrn 3
    eer ggj 3
    eer wwkr 3
    eer ssmr 3
    eer ltlr 3
    eer jhjr 3
    eer bbur 3
    eer ppfr 3
    eer kkc 3
    eer qxxr 3
    eer xhxr 3
    eer cce 3
    eer ydyr 3
    eer wwrw 3
    eer jajr 3
    eer aaa 3
    eer mggr 3
    eer pjjr 3
    eer zzrc 3
    eer gkgr 3
    eer ggc 3
    eer iird 3
    eer llrv 3
    eer kkrr 3
    eer jbjr 3
    eer dvdr 3
    eer jjfr 3
    eer ffqr 3
    eer ddnr 3
    eer iuur 3
    eer wwa 3
    eer xrxr 3
    eer kkyr 3
    eer gghr 3
    eer yyc 3
    eer affr 3
    eer xuur 3
    eer onnr 3
    eer kkrc 3
    eer bbdr 3
    eer szzr 3
    eer xxo 3
    eer qqrc 3
    eer aggr 3
    eer ffpr 3
    eer ckcr 3
    eer ppn 3
    eer iqir 3
    eer nnrx 3
    eer ppj 3
    eer dggr 3
    eer xxra 3
    eer gugr 3
    eer fnfr 3
    eer ywyr 3
    eer jssr 3
    eer loor 3
    eer voor 3
    eer uxur 3
    eer ccvr 3
    eer tffr 3
    eer ffe 3
    eer bvbr 3
    eer mmkr 3
    eer iaar 3
    eer hkhr 3
    eer znnr 3
    eer ffrk 3
    eer ccrj 3
    eer xxrz 3
    eer rrqr 3
    eer ssqr 3
    eer kkrv 3
    eer bby 3
    eer iic 3
    eer rro 3
    eer vvrs 3
    eer mzmr 3
    eer hthr 3
    eer ttxr 3
    eer qqqr 3
    eer frfr 3
    eer oov 3
    eer hhg 3
    eer ppf 3
    eer kwkr 3
    eer lln 3
    eer llrs 3
    eer llir 3
    eer uqqr 3
    eer hhrz 3
    eer jjro 3
    eer allr 3
    eer bbrk 3
    eer kkrf 3
    eer ssyr 3
    eer httr 3
    eer ttrm 3
    eer ggra 3
    eer ssrv 3
    eer sbsr 3
    eer mttr 3
    eer ddxr 3
    eer ddrw 3
    eer woor 3
    eer oorc 3
    eer jjrn 3
    eer ndnr 3
    eer ggrn 3
    eer swsr 3
    eer zzrz 3
    eer bbrl 3
    eer xxur 3
    eer ssn 3
    eer tktr 3
    eer iig 3
    eer jjrc 3
    eer wwur 3
    eer wwf 3
    eer xxj 3
    eer wlwr 3
    eer svvr 3
    eer ccrl 3
    eer mmrv 3
    eer hmmr 3
    eer qqlr 3
    eer jbbr 3
    eer zccr 3
    eer nnk 3
    eer nnl 3
    eer sss 3
    eer gppr 3
    eer toor 3
    eer vvrc 3
    eer uuw 3
    eer ryyr 3
    eer rrrm 3
    eer uumr 3
    eer rrw 3
    eer ppdr 3
    eer xxf 3
    eer rurr 3
    eer hhy 3
    eer mfmr 3
    eer pttr 3
    eer nnrn 3
    eer hhrt 3
    eer ppre 3
    eer vvqr 3
    eer sse 3
    eer bbrd 3
    eer jjs 3
    eer jjc 3
    eer fzzr 3
    eer sstr 3
    eer uvur 3
    eer ppru 3
    eer oogr 3
    eer zozr 3
    eer ooor 3
    eer cxcr 3
    eer xxtr 3
    eer aaor 3
    eer zzlr 3
    eer krkr 3
    eer iiy 3
    eer irrr 3
    eer hhm 3
    eer iffr 3
    eer ozor 3
    eer xxjr 3
    eer akkr 3
    eer wwsr 3
    eer hhs 3
    eer ssf 3
    eer yyk 3
    eer rrrv 3
    eer zzrp 3
    eer llu 3
    eer kkd 3
    eer llmr 3
    eer kvvr 3
    eer ffrd 3
    eer ttrt 3
    eer qqyr 3
    eer ffrz 3
    eer vvmr 3
    eer ssir 3
    eer mmvr 3
    eer wwy 3
    eer zfzr 3
    eer hhe 3
    eer ddcr 3
    eer xqqr 3
    eer kikr 3
    eer nnqr 3
    eer xxar 3
    eer qssr 3
    eer kkxr 3
    eer bbd 3
    eer uurx 3
    eer uut 3
    eer bbk 3
    eer ffrc 3
    eer jhhr 3
    eer uiur 3
    eer fft 3
    eer dhdr 3
    eer ffsr 3
    eer yuyr 3
    eer nnpr 3
    eer frrr 3
    eer oos 3
    eer lnlr 3
    eer rrrp 3
    eer uwwr 3
    eer wllr 3
    eer uuhr 3
    eer mmfr 3
    eer zrzr 3
    eer zpzr 3
    eer nppr 3
    eer aarz 3
    eer iifr 3
    eer acar 3
    eer nndr 3
    eer ttg 3
    eer mvmr 3
    eer inir 3
    eer hrrr 3
    eer ciir 3
    eer totr 3
    eer oopr 3
    eer bbkr 3
    eer ddx 3
    eer hhry 3
    eer coor 3
    eer njjr 3
    eer oorf 3
    eer ddvr 3
    eer rwrr 3
    eer ppl 3
    eer xxn 3
    eer aaj 3
    eer hqhr 3
    eer ziir 3
    eer zxzr 3
    eer zmmr 3
    eer yyd 3
    eer oyyr 3
    eer yyqr 3
    eer mmhr 3
    eer rprr 3
    eer mmrs 3
    eer llrc 3
    eer ffru 3
    eer nnlr 3
    eer wppr 3
    eer wwlr 3
    eer rrtr 3
    eer rrlr 3
    eer xssr 3
    eer ttrj 3
    eer kkl 3
    eer xxdr 3
    eer ddri 3
    eer qqm 3
    eer olor 3
    eer aarr 3
    eer nnf 3
    eer ffd 3
    eer ggt 3
    eer ivvr 3
    eer aarc 3
    eer rrt 3
    eer rrzr 3
    eer wttr 3
    eer hhrm 3
    eer aarv 3
    eer hhrl 3
    eer vcvr 3
    eer gccr 3
    eer hshr 3
    eer bybr 3
    eer jccr 3
    eer ccrm 3
    eer njnr 3
    eer qql 3
    eer qnnr 3
    eer nnmr 3
    eer oot 3
    eer qq 3
    eer byyr 3
    eer osor 3
    eer juur 3
    eer hiir 3
    eer luur 3
    eer lglr 3
    eer wwru 3
    eer pwwr 3
    eer wwm 3
    eer yyxr 3
    eer mcmr 3
    eer ffjr 3
    eer ttry 3
    eer qbbr 3
    eer xxrd 3
    eer ttor 3
    eer vivr 3
    eer vvrd 3
    eer mmk 3
    eer iirn 3
    eer ttgr 3
    eer nnre 3
    eer ttzr 3
    eer nkkr 3
    eer gigr 3
    eer pvvr 3
    eer mccr 3
    eer ddh 3
    eer zzz 3
    eer vvd 3
    eer bbt 3
    eer ckkr 3
    eer jjar 3
    eer kku 3
    eer tte 3
    eer hhrh 3
    eer wwl 3
    eer kko 3
    eer aam 3
    eer aay 3
    eer wwz 3
    eer hhrf 3
    eer oggr 3
    eer ttrn 3
    eer mjmr 3
    eer jjcr 3
    eer naar 3
    eer ttz 3
    eer ppjr 3
    eer ddz 3
    eer qjjr 3
    eer nlnr 3
    eer uufr 3
    eer qqk 3
    eer uaur 3
    eer ggur 3
    eer lssr 3
    eer wvvr 3
    eer ccgr 3
    eer yyur 3
    eer qqrk 3
    eer zzg 3
    eer ccri 3
    eer hhrq 3
    eer lltr 3
    eer okor 3
    eer llrn 3
    eer thtr 3
    eer jje 3
    eer jjkr 3
    eer wzwr 3
    eer nny 3
    eer iin 3
    eer uuar 3
    eer hhrn 3
    eer ggw 3
    eer hahr 3
    eer hwhr 3
    eer bbp 3
    eer ioor 3
    eer zmzr 3
    eer kakr 3
    eer oozr 3
    eer xxry 3
    eer miir 3
    eer grgr 3
    eer occr 3
    eer oxxr 3
    eer vvgr 3
    eer ddrj 3
    eer xxl 3
    eer llrz 3
    eer mmq 3
    eer ffre 3
    eer iisr 3
    eer rrc 3
    eer vvg 3
    eer syyr 3
    eer fhfr 3
    eer qqz 3
    eer iit 3
    eer iirj 3
    eer uiir 3
    eer ddur 3
    eer ccv 3
    eer tctr 3
    eer oour 3
    eer qqc 3
    eer attr 3
    eer wwrx 3
    eer xxrl 3
    eer vvrq 3
    eer hhw 3
    eer bbrt 3
    eer bbrp 3
    eer lxlr 3
    eer zzy 3
    eer aakr 3
    eer jpjr 3
    eer ooxr 3
    eer kkrg 3
    eer bbrc 3
    eer uunr 3
    eer ggar 3
    eer uubr 3
    eer oord 3
    eer nnbr 3
    eer ggq 3
    eer tzzr 3
    eer uurm 3
    eer sffr 3
    eer rrrt 3
    eer dqqr 3
    eer mmsr 3
    eer bbre 3
    eer tptr 3
    eer iirx 3
    eer rnrr 3
    eer wwrj 3
    eer cmmr 3
    eer rhrr 3
    eer ttwr 3
    eer rzzr 3
    eer yyrk 3
    eer qqv 3
    eer paar 3
    eer ggsr 3
    eer lffr 3
    eer ffgr 3
    eer mmrb 3
    eer ubur 3
    eer nnrc 3
    eer yyrp 3
    eer ttx 3
    eer hkkr 3
    eer rzrr 3
    eer xwwr 3
    eer ddrx 3
    eer ddf 3
    eer nnrt 3
    eer uppr 3
    eer zllr 3
    eer hmhr 3
    eer tti 3
    eer mmur 3
    eer gbbr 3
    eer qqn 3
    eer mjjr 3
    eer wwrs 3
    eer qqbr 3
    eer nznr 3
    eer xzzr 3
    eer ttjr 3
    eer vvrb 3
    eer ddt 3
    eer wwc 3
    eer yfyr 3
    eer yryr 3
    eer kyyr 3
    eer xxrg 3
    eer ggrv 3
    eer nnrk 3
    eer ffi 3
    eer wwbr 3
    eer ccar 3
    eer vdvr 3
    eer yyrf 3
    eer kaar 3
    eer yydr 3
    eer hh 3
    eer ffj 3
    eer mgmr 3
    eer xfxr 3
    eer myyr 3
    eer bttr 3
    eer qaqr 3
    eer llw 3
    eer vlvr 3
    eer tts 3
    eer ibbr 3
    eer drrr 3
    eer ppyr 3
    eer thhr 3
    eer quqr 3
    eer cffr 3
    eer ccqr 3
    eer blbr 3
    eer xxre 3
    eer pbpr 3
    eer mmgr 3
    eer lll 3
    eer iitr 3
    eer guur 3
    eer drdr 3
    eer iix 3
    eer bbmr 3
    eer wwrr 3
    eer ppz 3
    eer ssrz 3
    eer qqt 3
    eer gvgr 3
    eer aagr 3
    eer uud 3
    eer ttrr 3
    eer sggr 3
    eer kddr 3
    eer wwro 3
    eer zzm 3
    eer hxxr 3
    eer ffra 3
    eer zaar 3
    eer uyur 3
    eer zkkr 3
    eer xbxr 3
    eer ghgr 3
    eer nnkr 3
    eer fwfr 3
    eer pypr 3
    eer ttir 3
    eer bhbr 3
    eer wwd 3
    eer bbrf 3
    eer vvrg 3
    eer rmrr 3
    eer vvir 3
    eer kkrq 3
    eer yxxr 3
    eer qqwr 3
    eer bbzr 3
    eer oort 3
    eer ggrz 3
    eer jjra 3
    eer omor 3
    eer vddr 3
    eer qqir 3
    eer ggrr 3
    eer aafr 3
    eer btbr 3
    eer rrf 3
    eer iiu 3
    eer nnxr 3
    eer pkpr 3
    eer aarf 3
    eer jppr 3
    eer ffri 3
    eer pjpr 3
    eer yyrt 3
    eer izir 3
    eer jjz 3
    eer ffmr 3
    eer ffrl 3
    eer vvrl 3
    eer grrr 3
    eer ittr 3
    eer oork 3
    eer ykyr 3
    eer rrrg 3
    eer oorr 3
    eer ssm 3
    eer ccrk 3
    eer llj 3
    eer xvvr 3
    eer vvrf 3
    eer mmlr 3
    eer llrm 3
    eer ttnr 3
    eer aav 3
    eer aas 3
    eer mme 3
    eer lle 3
    eer aag 3
    eer ddrz 3
    eer jrrr 3
    eer ddrl 3
    eer ool 3
    eer kkrs 3
    eer chcr 3
    eer yyyr 3
    eer tntr 3
    eer ttrl 3
    eer ffkr 3
    eer rddr 3
    eer wwrv 3
    eer rrz 3
    eer ttrd 3
    eer iigr 3
    eer vvlr 3
    eer lplr 3
    eer pffr 3
    eer nhhr 3
    eer gtgr 3
    eer xmmr 3
    eer xllr 3
    eer zhzr 3
    eer uucr 3
    eer daar 3
    eer hdhr 3
    eer fhhr 3
    eer nccr 3
    eer yyfr 3
    eer ccs 3
    eer aarp 3
    eer aatr 3
    eer dppr 3
    eer cfcr 3
    eer ywwr 3
    eer szsr 3
    eer ggrl 3
    eer nno 3
    eer uqur 3
    eer qqp 3
    eer rrp 3
    eer wzzr 3
    eer jjru 3
    eer ssrn 3
    eer sfsr 3
    eer jjir 3
    eer kppr 3
    eer aarj 3
    eer rrs 3
    eer rrre 3
    eer qmmr 3
    eer uuyr 3
    eer bllr 3
    eer hhj 3
    eer qyqr 3
    eer rllr 3
    eer llar 3
    eer uurb 3
    eer popr 3
    eer aazr 3
    eer kkt 3
    eer ssd 3
    eer nnc 3
    eer vyvr 3
    eer lrrr 3
    eer nnp 3
    eer ggrp 3
    eer ggmr 3
    eer nnu 3
    eer vuur 3
    eer ffb 3
    eer diir 3
    eer yyf 3
    eer hccr 3
    eer ppw 3
    eer ccro 3
    eer uuzr 3
    eer znzr 3
    eer dfdr 3
    eer hhrk 3
    eer vxvr 3
    eer ijjr 3
    eer khhr 3
    eer fjjr 3
    eer aabr 3
    eer oosr 3
    eer zwzr 3
    eer ppu 3
    eer xxrn 3
    eer hhu 3
    eer vvrk 3
    eer uggr 3
    eer bibr 3
    eer xxzr 3
    eer ppo 3
    eer vvru 3
    eer fkfr 3
    eer rrfr 3
    eer xzxr 3
    eer bcbr 3
    eer nnro 3
    eer oorg 3
    eer qqrq 3
    eer llrt 3
    eer pxxr 3
    eer ddbr 3
    eer kktr 3
    eer ottr 3
    eer llq 3
    eer yiir 3
    eer uuro 3
    eer cca 3
    eer vvry 3
    eer yyrh 3
    eer rrra 3
    eer bwwr 3
    eer ccrx 3
    eer hhh 3
    eer llru 3
    eer mmru 3
    eer hhxr 3
    eer qqrm 3
    eer qzqr 3
    eer cacr 3
    eer oorq 3
    eer uugr 3
    eer aau 3
    eer bhhr 3
    eer ggkr 3
    eer mmy 3
    eer nrnr 3
    eer llry 3
    eer xggr 3
    eer vvrh 3
    eer jjrt 3
    eer yybr 3
    eer nknr 3
    eer bbjr 3
    eer pprb 3
    eer dhhr 3
    eer uuur 3
    eer ddrd 3
    eer zzrq 3
    eer ddhr 3
    eer zzb 3
    eer uurc 3
    eer ccur 3
    eer uujr 3
    eer kkzr 3
    eer wwfr 3
    eer irir 3
    eer tztr 3
    eer cssr 3
    eer ftfr 3
    eer ssrh 3
    eer zlzr 3
    eer rrbr 3
    eer nnrr 3
    eer ommr 3
    eer aasr 3
    eer abar 3
    eer ccxr 3
    eer rmmr 3
    eer ttkr 3
    eer nnw 3
    eer tppr 3
    eer ooro 3
    eer ffbr 3
    eer qqe 3
    eer mmrg 3
    eer xxrk 3
    eer pprg 3
    eer laar 3
    eer jjb 3
    eer llgr 3
    eer gge 3
    eer vvl 3
    eer zzf 3
    eer ttsr 3
    eer wvwr 3
    eer iggr 3
    eer wuwr 3
    eer rrnr 3
    eer gagr 3
    eer ffh 3
    eer trtr 3
    eer zffr 3
    eer yyrv 3
    eer vggr 3
    eer qjqr 3
    eer jttr 3
    eer qrqr 3
    eer hrhr 3
    eer gzgr 3
    eer bbrx 3
    eer wwo 3
    eer wwh 3
    eer sjsr 3
    eer ddre 3
    eer ccrr 3
    eer ccy 3
    eer sttr 3
    eer twtr 3
    eer wwj 3
    eer ayyr 3
    eer ccrv 3
    eer pprf 3
    eer yqyr 3
    eer huhr 3
    eer cgcr 3
    eer sqqr 3
    eer bbu 3
    eer yyb 3
    eer ruur 3
    eer yya 3
    eer msmr 3
    eer xxrh 3
    eer rrrr 3
    eer dvvr 3
    eer ppri 3
    eer uup 3
    eer knnr 3
    eer kkp 3
    eer ffs 3
    eer lzzr 3
    eer ffu 3
    eer zzrd 3
    eer hhyr 3
    eer zzs 3
    eer zggr 3
    eer ggdr 3
    eer wwrh 3
    eer llrk 3
    eer hhx 3
    eer yyrn 3
    eer lvvr 3
    eer wrwr 3
    eer iiw 3
    eer zbzr 3
    eer sshr 3
    eer dddr 3
    eer tyyr 3
    eer nnd 3
    eer oqqr 3
    eer kqqr 3
    eer fbfr 3
    eer pprj 3
    eer qqgr 3
    eer ljlr 3
    eer tltr 3
    eer yynr 3
    eer yppr 3
    eer fllr 3
    eer pprn 3
    eer ggrj 3
    eer hhkr 3
    eer pfpr 3
    eer xgxr 3
    eer xxrq 3
    eer bbrv 3
    eer ggm 3
    eer mmo 3
    eer bbn 3
    eer rppr 3
    eer nnrm 3
    eer cqcr 3
    eer ssk 3
    eer llhr 3
    eer rvvr 3
    eer papr 3
    eer ffrx 3
    eer bbg 3
    eer ttru 3
    eer ssq 3
    eer ddw 3
    eer hphr 3
    eer rsrr 3
    eer bbir 3
    eer dadr 3
    eer xoxr 3
    eer cyyr 3
    eer bbf 3
    eer ssb 3
    eer llkr 3
    eer rrrz 3
    eer gfgr 3
    eer obbr 3
    eer fqqr 3
    eer uuri 3
    eer iif 3
    eer dqdr 3
    eer rrxr 3
    eer ddjr 3
    eer xcxr 3
    eer wwvr 3
    eer jj 3
    eer iirp 3
    eer ttm 3
    eer uudr 3
    eer mmcr 3
    eer yys 3
    eer mrmr 3
    eer dzdr 3
    eer zzvr 3
    eer ttrq 3
    eer ouur 3
    eer bbh 3
    eer ddp 3
    eer pggr 3
    eer ttre 3
    eer jqjr 3
    eer vffr 3
    eer iiry 3
    eer ddrf 3
    eer qqj 3
    eer iihr 3
    eer ii 3
    eer ggu 3
    eer aayr 3
    eer ffry 3
    eer zzwr 3
    eer atar 3
    eer wgwr 3
    eer cvcr 3
    eer mmqr 3
    eer mmri 3
    eer wwk 3
    eer mmbr 3
    eer ggxr 3
    eer jjm 3
    eer wssr 3
    eer ytyr 3
    eer gpgr 3
    eer fkkr 3
    eer vvrw 3
    eer waar 3
    eer vrrr 3
    eer ggrw 3
    eer ssvr 3
    eer dffr 3
    eer rrrq 3
    eer gga 3
    eer aair 3
    eer kzzr 3
    eer ccz 3
    eer gcgr 3
    eer baar 3
    eer jkjr 3
    eer ttrv 3
    eer iwir 3
    eer hihr 3
    eer llo 3
    eer rrrb 3
    eer ttv 3
    eer rtrr 3
    eer ssgr 3
    eer zjjr 3
    eer aoar 3
    eer xxq 3
    eer hhqr 3
    eer ccrp 3
    eer mmzr 3
    eer ugur 3
    eer ttq 3
    eer qqx 3
    eer ddrp 3
    eer ppq 3
    eer rbbr 3
    eer uurq 3
    eer ppro 3
    eer ddn 3
    eer owor 3
    eer mmxr 3
    eer xxbr 3
    eer sisr 3
    eer xuxr 3
    eer fccr 3
    eer sccr 3
    eer bbnr 3
    eer bbrr 3
    eer babr 3
    eer fsfr 3
    eer ccsr 3
    eer hhro 3
    eer yyrw 3
    eer ubbr 3
    eer cddr 3
    eer iiq 3
    eer oors 3
    eer yyt 3
    eer fxfr 3
    eer qllr 3
    eer llrb 3
    eer ppar 3
    eer vbvr 3
    eer iie 3
    eer cnnr 3
    eer hssr 3
    eer zhhr 3
    eer nnri 3
    eer tbbr 3
    eer mimr 3
    eer uurg 3
    eer bggr 3
    eer ccfr 3
    eer vvrn 3
    eer nnz 3
    eer ffm 3
    eer oorn 3
    eer wffr 3
    eer ffa 3
    eer qqzr 3
    eer hggr 3
    eer mymr 3
    eer cscr 3
    eer jjrf 3
    eer vzzr 3
    eer oqor 3
    eer iirg 3
    eer qqq 3
    eer aarh 3
    eer gaar 3
    eer sosr 3
    eer ppm 3
    eer zzp 3
    eer nnrf 3
    eer vvw 3
    eer wwrd 3
    eer vvc 3
    eer ffc 3
    eer www 3
    eer nnrb 3
    eer llpr 3
    eer bdbr 3
    eer lhlr 3
    eer mnnr 3
    eer gkkr 3
    eer jjlr 3
    eer uu 3
    eer fddr 3
    eer kvkr 3
    eer ddrn 3
    eer zzri 3
    eer mtmr 3

**Expected Results**
```CPP
eer eer 0
```

We have to allow single edits here because some two_edits will restore a single edit.

#### References
- Dan Jurafsky - Speech and Language Processing - Textbook
- This auto-correct explanation was first done by Peter Norvig in 2007