diff --git a/challenge_0/csharp/jfrancis2/README.md b/challenge_0/csharp/jfrancis2/README.md
new file mode 100644
index 000000000..4abe81fb9
--- /dev/null
+++ b/challenge_0/csharp/jfrancis2/README.md
@@ -0,0 +1,14 @@
+# Challenge 0 - Hello World
+###### C#
+
+### 1. Approach to Solving the problem
+
+Output text "Hello World"
+
+### 2. How to compile and run this code
+
+From the /src directory, use `csc.exe hello.cs`
+
+### 3. How this program works
+
+Read the text! Hi :)
\ No newline at end of file
diff --git a/challenge_0/csharp/jfrancis2/src/hello.cs b/challenge_0/csharp/jfrancis2/src/hello.cs
new file mode 100644
index 000000000..1e51c6e68
--- /dev/null
+++ b/challenge_0/csharp/jfrancis2/src/hello.cs
@@ -0,0 +1,13 @@
+using System;
+namespace HelloWorld
+{
+    class Hello 
+    {
+        static void Main() 
+        {
+            Console.WriteLine("Hello World!");
+            Console.WriteLine("Press any key to exit.");
+            Console.ReadKey();
+        }
+    }
+}
\ No newline at end of file
diff --git a/challenge_0/java/JakeBash/Challenge_0.java b/challenge_0/java/JakeBash/Challenge_0.java
new file mode 100644
index 000000000..256f36365
--- /dev/null
+++ b/challenge_0/java/JakeBash/Challenge_0.java
@@ -0,0 +1,16 @@
+/**
+ * This class holds the code needed to meet the requirements for Challenge 0 of
+ * the 2017 Year of Programming.
+ *
+ * @author Jake Bashaw
+ */
+public class Challenge_0
+{
+    /**
+     * Prints "Hello World" for the user to view
+     */
+    public static void main(String args[])
+    {
+        System.out.println("Hello World!");
+    }
+}
diff --git a/challenge_1/c/tyleroar/README.md b/challenge_1/c/tyleroar/README.md
new file mode 100644
index 000000000..16decb5f8
--- /dev/null
+++ b/challenge_1/c/tyleroar/README.md
@@ -0,0 +1 @@
+String reversing in C
diff --git a/challenge_1/c/tyleroar/src/strings.c b/challenge_1/c/tyleroar/src/strings.c
new file mode 100644
index 000000000..8bfb1d483
--- /dev/null
+++ b/challenge_1/c/tyleroar/src/strings.c
@@ -0,0 +1,33 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+char *readLine() {
+    int length = 1;
+    char *string = NULL;
+    char c;
+    while (EOF!=(c=getchar()) && '\r'!=c && '\n' != c) {
+        string=realloc(string,length);
+        string[length-1]=c;
+        length++;
+    }
+    string[length-1]='\0';
+    return string;
+}
+int main(int argc, char **argv) {
+    char *input = readLine();
+    char temp;
+    int length=0, i=0;
+    for (temp=input[length]; temp!='\0'; length++) temp=input[length];
+    length--;
+    char *output = (char*) malloc(sizeof(char)*(length+1));
+    if(length==0) {
+        output[0]='\0';
+    }
+    else {
+        for (i=0; i<length; i++) {
+            output[i]=input[length-i-1];
+        }
+        output[i]='\0';
+    }
+    printf("%s\n", output);
+}
diff --git a/challenge_1/c/xor-eax-eax/README.md b/challenge_1/c/xor-eax-eax/README.md
new file mode 100644
index 000000000..45b600631
--- /dev/null
+++ b/challenge_1/c/xor-eax-eax/README.md
@@ -0,0 +1,38 @@
+# Challenge_1
+###### C compiled with gcc 4.2.1
+
+### 1. Approch to Solving the problem
+
+Reversing strings in C is a little bit more challenging than
+higher level languages.  Since basically everything is a pointer
+to memory of a particular size, you must make sure that the variables
+you're creating have the approprate space.  In short, I created two
+character arrays and looped through them from opposite directions,
+the original's end filling the beginning of the reverse string.
+
+### 2. How to compile and run this code
+
+Make sure that you have gcc installed on your *nix machine.  To see if you have
+it installed you can type:
+
+```
+$ gcc --version
+```
+
+Compiling:
+```
+$ gcc -o challenge1 challenge1.c
+```
+Or optionally with symbols that aid in debugging.
+```
+$ gcc -g -o challenge0 challenge0.c
+```
+
+### 3. How this program works
+
+After the program has compiled with no errors:
+```
+$ ./challenge1
+olleH
+
+```
diff --git a/challenge_1/c/xor-eax-eax/src/challenge1.c b/challenge_1/c/xor-eax-eax/src/challenge1.c
new file mode 100644
index 000000000..e203cf584
--- /dev/null
+++ b/challenge_1/c/xor-eax-eax/src/challenge1.c
@@ -0,0 +1,28 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h> // for memset
+
+int main()
+{
+    // Initialize a character array with the string you want to reverse.
+    char helloString[] = "Hello";
+    // Get length of 0-indexed string, this will be used for index looping
+    int strSize = strlen(helloString);
+    // Instantiated character array equal to the size of the original
+    char revHelloStr[strSize];
+    // Set the values of the reverse character array to zero, this takes care of the null terminator at the end
+    memset(revHelloStr, 0, strSize*sizeof(char));
+    // subtracted one to disclude the null terminator.  That is taken care of in revHelloStr by the memset
+    int i = strSize-1;
+    int j = 0;
+    // Perform a count from the front to back of the character array for the reverse string
+    // while counting from the back of the hello string, skipping the null terminator
+    for (i,j ; i>=0 && j<=strSize-1 ; i--, j++)
+    {
+        revHelloStr[j] = helloString[i];
+
+    }
+    printf("%s",revHelloStr);
+
+    return 0;
+}
diff --git a/challenge_1/csharp/jfrancis2/README.md b/challenge_1/csharp/jfrancis2/README.md
new file mode 100644
index 000000000..42938f45c
--- /dev/null
+++ b/challenge_1/csharp/jfrancis2/README.md
@@ -0,0 +1,17 @@
+# Challenge 1 - Reverse a String
+###### C#
+
+### 1. Approach to Solving the problem
+
+I had to work out how to get a string, then make it backwards. Turns out there are inbuilt functions for this.
+
+### 2. How to compile and run this code
+
+From the /src directory, use `csc.exe program.cs`
+
+### 3. How this program works
+
+Takes a string from the console input
+Converts to a char array
+Uses the 'System.Reverse' function to change the order of the characters
+Displays the reversed string
\ No newline at end of file
diff --git a/challenge_1/csharp/jfrancis2/src/program.cs b/challenge_1/csharp/jfrancis2/src/program.cs
new file mode 100644
index 000000000..aded9040e
--- /dev/null
+++ b/challenge_1/csharp/jfrancis2/src/program.cs
@@ -0,0 +1,21 @@
+using System;
+namespace YOP2017
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            Console.WriteLine("Enter a string to reverse: ");
+            string input = Console.ReadLine();
+            Console.WriteLine("Your string in reverse: " + Program.reverseString(input));
+            Console.WriteLine("Press any key to exit.")
+            Console.ReadKey(true);
+        }
+        public static string reverseString(string input)
+        {
+            char[] arr = input.ToCharArray();
+            Array.Reverse(arr);
+            return new string(arr);
+        }
+    }
+}
diff --git a/challenge_1/java/JakeBash/Challenge_1.java b/challenge_1/java/JakeBash/Challenge_1.java
new file mode 100644
index 000000000..e44188bf4
--- /dev/null
+++ b/challenge_1/java/JakeBash/Challenge_1.java
@@ -0,0 +1,41 @@
+import java.util.Scanner;
+
+/**
+ * This class holds the code needed to meet the requirements for Challenge 1 of
+ * the 2017 Year of Programming.
+ *
+ * @author Jake Bashaw
+ */
+public class Challenge_1
+{
+    /**
+     * Prints the reversed version of the standard input supplied by the user
+     */
+    public static void main(String args[])
+    {
+        System.out.print("> ");
+        Scanner kb = new Scanner(System.in);
+        String input = kb.nextLine();
+        System.out.println(reverseString(input));
+    }
+
+    /**
+     * Reverses and returns a String
+     *
+     * @param input The String to be reversed
+     */
+    public static String reverseString(String input)
+    {
+        StringBuilder sb = new StringBuilder(input);
+        char forChar;
+        char revChar;
+        for(int i=0; i<sb.length()/2; i++)
+        {
+            forChar = sb.charAt(i);
+            revChar = sb.charAt(sb.length()-i-1);
+            sb.setCharAt(i, revChar);
+            sb.setCharAt(sb.length()-i-1, forChar);
+        }
+        return sb.toString();
+    }
+}
diff --git a/challenge_10/python/alexbotello/README.md b/challenge_10/python/alexbotello/README.md
new file mode 100644
index 000000000..d8292577a
--- /dev/null
+++ b/challenge_10/python/alexbotello/README.md
@@ -0,0 +1,24 @@
+# Valid Closers
+###### Language Version (Python 3.6.0)
+
+
+For this challenge we implement a list as a stack. As we iterate through the
+string input we add every opener found into the stack sequentially.
+
+As the iteration continues onto the closers, check the if closer matches the last
+element in our stack. If match is successful, pop the element off the stack and continue.
+If any pair fails to match then the string input contains an invalid closer and
+the function returns False.
+
+After iteration is complete if our stack is empty then every opener had a valid
+closer and the function returns True.
+
+
+Run ```test.py``` to test code against the unit test.
+```
+........
+----------------------------------------------------------------------
+Ran 8 tests in 0.001s
+
+OK
+```
diff --git a/challenge_10/python/alexbotello/src/closers.py b/challenge_10/python/alexbotello/src/closers.py
new file mode 100644
index 000000000..4eae34159
--- /dev/null
+++ b/challenge_10/python/alexbotello/src/closers.py
@@ -0,0 +1,35 @@
+# Valid Closers
+
+def is_valid_closer(string):
+    """
+    Returns True if every opener has a valid closer
+    """
+    openers = ['[', '(', '{']
+    closers = [']', ')', '}']
+    stack = []
+
+    for ch in string:
+        # If there is a closer, but no openers
+        if not stack and ch in closers:
+            return False
+
+        # Add any opener into the stack
+        elif ch in openers:
+            stack.append(ch)
+
+        # If the following closers do not pair with the opener popped from stack
+        # then the function will return False
+        elif ch == ']':
+            if stack.pop() != '[':
+                return False
+
+        elif ch == ')':
+            if stack.pop() != '(':
+                return False
+
+        elif ch == '}':
+            if stack.pop() != '{':
+                return False
+
+    # Nothing in our stack == True
+    return not stack
diff --git a/challenge_10/python/alexbotello/src/tests.py b/challenge_10/python/alexbotello/src/tests.py
new file mode 100644
index 000000000..a1707dc92
--- /dev/null
+++ b/challenge_10/python/alexbotello/src/tests.py
@@ -0,0 +1,33 @@
+import unittest
+
+from closers import is_valid_closer
+
+class Test(unittest.TestCase):
+
+    def test1(self):
+        self.assertEqual(is_valid_closer('{{{{{{{{{adfkjaefia}}}}}}}'), False)
+
+    def test2(self):
+        self.assertEqual(is_valid_closer('{{{{{{{{{[[[[[[kadfa{{{{{{{((({daljfdaf({{{[]}}kaldjfs})})))}}}}}}}]]]]]]}kjfela}}}}}}}}'), True)
+
+    def test3(self):
+        self.assertEqual(is_valid_closer('{{{[}}}}dafda'), False)
+
+    def test4(self):
+        self.assertEqual(is_valid_closer('{{{{{{{{{}}}}}}}}}'), True)
+
+    def test5(self):
+        self.assertEqual(is_valid_closer('[[[[[[[[[kafjalfeianfailfeja;fjai;efa;sfj]]]]]]]]]kjajdain'), True)
+
+    def test6(self):
+        self.assertEqual(is_valid_closer(''), True)
+
+    def test7(self):
+        self.assertEqual(is_valid_closer('((((((fjdalfeja((((alefjalisj(())))))))))))d'), True)
+
+    def test8(self):
+        self.assertEqual(is_valid_closer(')))(((d'), False)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/challenge_12/python/slandau3/.vscode/settings.json b/challenge_12/python/slandau3/.vscode/settings.json
new file mode 100644
index 000000000..9612230c7
--- /dev/null
+++ b/challenge_12/python/slandau3/.vscode/settings.json
@@ -0,0 +1,5 @@
+{
+    "python.linting.pylintEnabled": true,
+    "python.pythonPath": "python3",
+    "python.formatting.provider": "autopep8"
+}
\ No newline at end of file
diff --git a/challenge_12/python/slandau3/compression.py b/challenge_12/python/slandau3/compression.py
index 4253498f9..c5e470bcf 100644
--- a/challenge_12/python/slandau3/compression.py
+++ b/challenge_12/python/slandau3/compression.py
@@ -9,28 +9,34 @@ def compress(string_to_compress: str) -> str:
     output = ""  # The compressed string that will be outputted
     character = ""  # character the string_to_compress at blank
     occurrences = 0  # the number of occurrences of this letter
-    for index, char in enumerate(string_to_compress):  # goes through both the range and the characters at the same time
-        if char != character or index == len(string_to_compress)-1:  # if we spot a different character,
+    # goes through both the range and the characters at the same time
+    for index, char in enumerate(string_to_compress):
+        # if we spot a different character,
+        if char != character or index == len(string_to_compress) - 1:
             # or are at the end of the string_to_compress
             # go here
-            if index == len(string_to_compress)-1 and character == char:  # If we are at the end of
+            # If we are at the end of
+            if index == len(string_to_compress) - 1 and character == char:
                 # the string_to_compress
-                # but the last character is the same, add to the occurrences of the character
+                # but the last character is the same, add to the occurrences of
+                # the character
                 occurrences += 1
 
             if occurrences > COMPRESSION_CUTOFF:
-                # If we have more than three occurrences, add the compress format to the output
+                # If we have more than three occurrences, add the compress
+                # format to the output
                 output += character + '#' + str(occurrences)
             else:
-                # the next line puts 'occurrences' number of 'character' in the output
+                # the next line puts 'occurrences' number of 'character' in the
+                # output
                 output += character * occurrences
 
-            if index == len(string_to_compress)-1 and character != char:
+            if index == len(string_to_compress) - 1 and character != char:
                 # If we are at the end of the string_to_compress and the character
                 # is not the same as the last. Top it off
                 output += char
 
-            character = char # set char to character so we know the last character we looked at
+            character = char  # set char to character so we know the last character we looked at
             occurrences = 1
 
         else:
@@ -41,15 +47,18 @@ def compress(string_to_compress: str) -> str:
 
 def decompress(string_to_uncompress: str) -> str:
     # Using regular expressions to parse the string_to_uncompress
-    matches = re.findall(r'(.#\d+)', string_to_uncompress) # Looking for [anything]#[at least one number]
-    decompressed = string_to_uncompress # decompressed is the new string that we will output
-    for match in matches: # Scan through the matches and uncompress each of them
+    # Looking for [anything]#[at least one number]
+    matches = re.findall(r'(.#\d+)', string_to_uncompress)
+    # decompressed is the new string that we will output
+    decompressed = string_to_uncompress
+    for match in matches:  # Scan through the matches and uncompress each of them
         # match the character so we know what character we need to expand
         char = re.match(r'(.)#\d+', match)
         # Determine the number of times it occurred
         times = re.search(r'(\d+)', match)
 
-        replacement = char.group(1) * int(times.group(1)) # To get the matches specifically we need to access
+        # To get the matches specifically we need to access
+        replacement = char.group(1) * int(times.group(1))
         # them at group 1
         decompressed = decompressed.replace(match, replacement)
 
diff --git a/challenge_12/python/slandau3/tests.py b/challenge_12/python/slandau3/tests.py
index 5168ccf79..fc38db22b 100644
--- a/challenge_12/python/slandau3/tests.py
+++ b/challenge_12/python/slandau3/tests.py
@@ -4,6 +4,9 @@
 from compression import compress, decompress
 
 class Test(unittest.TestCase):
+    """
+    hello
+    """
 
     def test1(self):
         """
@@ -17,7 +20,8 @@ def test2(self):
         An arbitrarily long string
         :return:
         """
-        self.assertEqual(compress('abadbadsakdlfjieafnealfjiasfjaaaaanadddddddkkkjj'), "abadbadsakdlfjieafnealfjiasfja#5nad#7kkkjj")
+        self.assertEqual(compress('abadbadsakdlfjieafnealfjiasfjaaaaanadddddddkkkjj'), \
+            "abadbadsakdlfjieafnealfjiasfja#5nad#7kkkjj")
 
     def test3(self):
         """
@@ -38,7 +42,8 @@ def test5(self):
         Decompress a fairly large string without too many compressions in it.
         :return:
         """
-        self.assertEqual(decompress('abadbadsakdlfjieafnealfjiasfja#5nad#7kkkjj'), 'abadbadsakdlfjieafnealfjiasfjaaaaanadddddddkkkjj')
+        self.assertEqual(decompress('abadbadsakdlfjieafnealfjiasfja#5nad#7kkkjj'), \
+            'abadbadsakdlfjieafnealfjiasfjaaaaanadddddddkkkjj')
 
     def test6(self):
         """
diff --git a/challenge_13/c/karanchawla/README.md b/challenge_13/c/karanchawla/README.md
new file mode 100644
index 000000000..92d0d2c81
--- /dev/null
+++ b/challenge_13/c/karanchawla/README.md
@@ -0,0 +1,6 @@
+```
+Karan Chawla
+Challenge 13
+```
+
+The code just reverses the input number and checks if it is the same as the original number. The method returns ```true``` if the number is a palindrome, else it returns ```flase```.
diff --git a/challenge_13/c/karanchawla/challenge_13.c b/challenge_13/c/karanchawla/challenge_13.c
new file mode 100644
index 000000000..b130b0027
--- /dev/null
+++ b/challenge_13/c/karanchawla/challenge_13.c
@@ -0,0 +1,36 @@
+//Karan Chawla
+//Challenge 13
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int reverse(int x)
+{
+    int ans = 0;
+    while(x != 0)
+    {
+        ans = ans * 10;
+        ans = ans + x%10;
+        x = x/10;
+    }
+    
+    return ans;
+}
+
+
+//Driver Program
+int main(void)
+{
+    int num = 1234554321;
+
+    if(reverse(num)==num)
+    {
+        printf("True");
+    }
+    else
+    {
+        printf("False");
+    }
+
+    return 0;
+}
diff --git a/challenge_13/python/ning/README.md b/challenge_13/python/ning/README.md
new file mode 100644
index 000000000..6f5b18d00
--- /dev/null
+++ b/challenge_13/python/ning/README.md
@@ -0,0 +1,43 @@
+# Challenge #13, Integer Palindrome
+
+## Solution Logic
+
+1. We run through conditionals to check for non-palindromic integers. If they pass these tests, we assume them to be palindromic.
+2. Single-digit integers are by definition (of this challenge, anyway) palindromes. These skip the main `while` loop and the function returns True straight away. For the rest...
+3. First, we store the last digit (in the ones position) in the variable `ones`. In this process, the last digit of the given integer is also made to be zero.
+4. Assuming the given integer is palindromic, we subtract the first digit, hence removing it. Next, divide the integer by 10 to remove the last integer. Hence, two digits from each end of the given integer is stripped off. Following this, there are 4 cases to consider.
+
+_Case 1_: 514 -> 11
+In this non-palindromic case, we end up after step (4) with the integer 11. The first digit was not stripped as it was larger than the last digit. As such, only one digit was stripped. We test for this case where the difference in digits after step (4) is only 1, and return False.
+
+_Case 2_: 415 -> -90
+This is our second non-palindromic case. As the first digit is smaller than the last, we end up with a negative integer. Testing for this is easy: `if _int < 0`. Naturally, the function returns False in this case.
+
+_Case 3_: 515 -> 1
+The ideal scenario. We end up with 1, and a difference of two digits. Since there is only one digit, the function breaks out of the while loop and returns True.
+
+_Case 4_: 10101 -> 10
+Tricky. We remove the two digits at both ends to get `010`, but the program reads this as `10`. To rememdy this, we detect the extra difference in digits (three stripped instead of two), and divide by 10 for each starting zero, getting `1` instead of `10`.
+
+_Case 5_: 10111-> 11
+A subset of _Case 4_, we detect a three digit difference, and the program continues as in the previous case to divide an extra time by 10, giving us `1.1`. Hence we must include an `if _int % 1 != 0` to detect for this case.
+
+## Functions
+
+1. `get_int_len` takes an integer input and returns the number of digits in that integer by comparing it to powers of 10. A more mathematical way to do this would be with log of base 10, but this would violate rule #1 with its use of the `math` module.
+2. `check_palindrome` takes an integer input and returns True if it is an integer palindrome, and False if not.
+3. `check_palindrome_str `is a wrapper around the above `check_palindrome` function which takes a string input instead.
+
+
+## Unit Test
+
+The unit test `test.py` consists of the seven examples provided in the challenge README.md, as well as a test case for the above descripted _Case 5_.
+
+```
+........
+----------------------------------------------------------------------
+Ran 8 tests in 0.000s
+
+OK
+```
+
diff --git a/challenge_13/python/ning/challenge_13.py b/challenge_13/python/ning/challenge_13.py
new file mode 100644
index 000000000..5b4ef90b4
--- /dev/null
+++ b/challenge_13/python/ning/challenge_13.py
@@ -0,0 +1,54 @@
+def get_int_len(_int):
+    '''Find the number of digits of an int
+
+    Given an integer, finds the number of
+    digits in that integer in base 10
+    '''
+    power = 1
+    while True:
+        if _int == 0:
+            return 0
+        elif _int < 10**power:
+            return power
+        power += 1
+
+def check_palindrome(_int):
+    ones = 0
+    digits = get_int_len(_int)
+    while digits > 1:
+        if _int % 10 != 0:  # not end with 0
+            ones += 1
+            _int -= 1
+        else:
+            _int -= ones * 10**(digits-1)
+            _int /= 10
+            new_digits = get_int_len(_int)
+            diff_digits = digits - new_digits
+            if diff_digits == 1 or _int < 0:
+                # e.g. 514, 510, 110, 10
+                # e.g. 415, 410, -90, -9
+                return False
+            elif diff_digits > 2:
+                # e.g. 10101, 10100, 0010
+                extra_zeroes = diff_digits - 2
+                _int /= 10**(extra_zeroes)
+                if _int % 1 != 0:
+                    return False
+            digits = get_int_len(_int)
+            ones = 0
+
+    return True
+
+def check_palindrome_str(_str):
+    return check_palindrome(int(_str))
+
+if __name__ == '__main__':
+    while True:
+        print(check_palindrome_str(input(' >>> ')))
+
+'''
+# FOR REPL.IT
+while True:
+    print(check_palindrome_str(input(' >>> ')))
+'''
+
diff --git a/challenge_13/python/ning/test.py b/challenge_13/python/ning/test.py
new file mode 100644
index 000000000..3a4707310
--- /dev/null
+++ b/challenge_13/python/ning/test.py
@@ -0,0 +1,54 @@
+import unittest
+from challenge_13 import check_palindrome
+
+class Tests(unittest.TestCase):
+    def test_given_1(self):
+        self.assertEqual(
+                check_palindrome(1112111),
+                True
+                )
+
+    def test_given_2(self):
+        self.assertEqual(
+                check_palindrome(1),
+                True
+                )
+
+    def test_given_3(self):
+        self.assertEqual(
+                check_palindrome(59112),
+                False
+                )
+
+    def test_given_4(self):
+        self.assertEqual(
+                check_palindrome(1234554321),
+                True
+                )
+
+    def test_given_5(self):
+        self.assertEqual(
+                check_palindrome(22),
+                True
+                )
+
+    def test_given_6(self):
+        self.assertEqual(
+                check_palindrome(1010100101),
+                False
+                )
+
+    def test_given_7(self):
+        self.assertEqual(
+                check_palindrome(1010110101),
+                True
+                )
+
+    def test_10111(self):
+        self.assertEqual(
+                check_palindrome(10111),
+                False
+                )
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/challenge_14/README.md b/challenge_14/README.md
new file mode 100644
index 000000000..8de8eec6d
--- /dev/null
+++ b/challenge_14/README.md
@@ -0,0 +1,25 @@
+Reversing a linked list
+======
+Idea
+----
+Everyone should be somewhat familiar with the concept of a linked list by now. Today, you're job is to create a linked list and reverse it. Your program needs to be able to take strings from standard input, which will be used as each nodes data attribute. The strings in standard input will be space separated. Nodes are to be created and connected for these strings one after another (newest node is appended to the end of the linked list). 
+
+As for the "reverse" function. You need to implement a function to reverse the linked list. However, you may not touch the data on any of the nodes. The list must be reversed by manipulating the "next" attribute of each node. 
+
+The program should run in O(N) time.
+
+You should have another function that will print the linked list (simply loop through it and print the data at each node).  
+   
+Testing
+------
+In order to test the program, you may use the provided test files. Plug all strings from the test files into your program to create a node for each one. Print the list of nodes then reverse the list. After the list has been completely reversed output the list again (which should result in the reverse of what was previously printed). 
+
+The test inputs are also listed below.
+
+1. r e d r u m
+
+2. p a r k
+
+3. b o o b y t r a p
+
+4. l i v e
\ No newline at end of file
diff --git a/challenge_14/c/karanchawla/README.md b/challenge_14/c/karanchawla/README.md
new file mode 100644
index 000000000..05ed6e77b
--- /dev/null
+++ b/challenge_14/c/karanchawla/README.md
@@ -0,0 +1,6 @@
+```
+Karan Chawla
+Challenge 14
+```
+
+Approach: The aim here is to reverse a linked list. This is achieved by using three pointers - prev, current and next. Current moves along the linked list while the prev and next pointers are switched. Finally the head is set to the prev - completing the list reversal.
\ No newline at end of file
diff --git a/challenge_14/c/karanchawla/challenge_14.c b/challenge_14/c/karanchawla/challenge_14.c
new file mode 100644
index 000000000..fd8604208
--- /dev/null
+++ b/challenge_14/c/karanchawla/challenge_14.c
@@ -0,0 +1,88 @@
+//Karan Chawla
+//Challenge 14
+
+#include <stdio.h>
+#include <stdlib.h>
+
+//Linked list node definition
+typedef struct node
+{
+	char c;
+	struct node* next;
+}Node;
+
+
+//utility function to create a new node
+Node* newNode(char c)
+{
+	Node* new_node = (Node*)malloc(sizeof(Node));
+	new_node->c = c;
+	new_node->next = NULL;
+
+	return new_node;
+}
+
+//utility function to add a new node to the linked list
+void push(Node** head_ref, char c)
+{
+	Node* new_node = newNode(c);
+
+	new_node->next = *head_ref;
+
+	*head_ref = new_node;
+}
+
+
+//function to reverse the linked list
+//prev->curr->next
+//changes prev to next and moves current along the linked list until NULL
+void reverseLinkedList(Node** head_ref)
+{
+	if (*head_ref==NULL)
+		return;
+
+	Node* prev = NULL;
+	Node* current = *head_ref;
+	Node* next;
+	while(current!=NULL)
+	{
+		next = current->next;
+		current->next = prev;
+		prev = current;
+		current = next;
+	}
+	*head_ref = prev;
+}
+
+//utility function to print linked list
+void printLinkedList(Node* head)
+{
+	while(head!=NULL)
+	{
+		printf("%c->", head->c);
+		head = head->next;
+	}
+	printf("NULL\n");
+}
+
+//driver program
+int main(void)
+{
+	Node* head = NULL;
+	//create a linked list with chars from "murder"
+	push(&head,'r');
+	push(&head,'e');
+	push(&head,'d');
+	push(&head,'r');
+	push(&head,'u');
+	push(&head,'m');
+
+	//print the linked list
+	printLinkedList(head);
+	//reverse the linked list
+	reverseLinkedList(&head);
+	//print the reversed linked list
+	printLinkedList(head);
+
+	return 0;
+}
diff --git a/challenge_14/java/slandau3/src/Reverse.java b/challenge_14/java/slandau3/src/Reverse.java
new file mode 100644
index 000000000..19a4106d5
--- /dev/null
+++ b/challenge_14/java/slandau3/src/Reverse.java
@@ -0,0 +1,68 @@
+/**
+ * Created by slandau on 1/11/17.
+ */
+public class Reverse<T> {
+    public Node root = null;
+    public int size = 0;
+
+    private class Node {
+        public T data;
+        public Node next;
+
+        public Node(T data) {
+            this.data = data;
+        }
+    }
+
+    public void append(T data) {
+        if (size == 0) {
+            root = new Node(data);
+        } else {
+            Node temp = root;
+            while (temp.next != null) {
+                temp = temp.next;
+            }
+            temp.next = new Node(data);
+        }
+        size++;
+    }
+
+    public void reverse() {
+        if (size == 1) {
+            // do nothing
+        } else {
+            Node prev = null;
+            Node cur = root;
+            Node next = root.next;
+            while (next != null) {
+                cur.next = prev;
+                prev = cur;
+                cur = next;
+                next = next.next;
+            }
+            cur.next = prev;
+            root = cur;
+        }
+
+    }
+
+    public void print() {
+        Node temp = root;
+        while (temp != null) {
+            System.out.println(temp.data);
+            temp = temp.next;
+        }
+    }
+
+
+    public static void main(String[] args) {
+        Reverse<Integer> a = new Reverse<>();
+        a.append(1);
+        a.append(2);
+        a.append(3);
+        a.print();
+        a.reverse();
+        a.print();
+    }
+
+}
diff --git a/challenge_14/tests/test1 b/challenge_14/tests/test1
new file mode 100644
index 000000000..1895c812a
--- /dev/null
+++ b/challenge_14/tests/test1
@@ -0,0 +1 @@
+r e d r u m
diff --git a/challenge_14/tests/test2 b/challenge_14/tests/test2
new file mode 100644
index 000000000..e523bfa61
--- /dev/null
+++ b/challenge_14/tests/test2
@@ -0,0 +1 @@
+p a r k
diff --git a/challenge_14/tests/test3 b/challenge_14/tests/test3
new file mode 100644
index 000000000..73500607c
--- /dev/null
+++ b/challenge_14/tests/test3
@@ -0,0 +1 @@
+b o o b y t r a p
diff --git a/challenge_14/tests/test4 b/challenge_14/tests/test4
new file mode 100644
index 000000000..c80403e12
--- /dev/null
+++ b/challenge_14/tests/test4
@@ -0,0 +1 @@
+l i v e
diff --git a/challenge_2/Java/JakeBash/Challenge_2.java b/challenge_2/Java/JakeBash/Challenge_2.java
new file mode 100644
index 000000000..ffce465c4
--- /dev/null
+++ b/challenge_2/Java/JakeBash/Challenge_2.java
@@ -0,0 +1,62 @@
+import java.io.*;
+import java.util.*;
+import java.util.Scanner;
+
+/**
+ * This class holds the code needed to meet the requirements for Challenge 2 of
+ * the 2017 Year of Programming.
+ *
+ * @author Jake Bashaw
+ */
+public class Challenge_2
+{
+    /**
+     * Prompts the user for input and displays the non-repeated string from the
+     * input
+     */
+    public static void main(String[] args)
+    {
+        System.out.println("Please enter a series of space seperated characters");
+        Scanner kb = new Scanner(System.in);
+        String[] input = kb.nextLine().split(" ");
+        System.out.println(singleNumber(input));
+    }
+
+    /**
+     * Finds the only non-repeated String in an array of Strings
+     *
+     * @param input The String array that is to be searched
+     */
+    public static String singleNumber(String[] input)
+    {
+        HashMap<String, Integer> inputMap = new HashMap<>();
+
+        for(String str : input)
+        {
+            if(inputMap.containsKey(str))
+            {
+                int value = inputMap.get(str);
+                inputMap.remove(str);
+                inputMap.put(str, value+1);
+            }
+            else
+            {
+                inputMap.put(str, 1);
+            }
+        }
+
+        for (Map.Entry<String, Integer> entry : inputMap.entrySet())
+        {
+            String key = entry.getKey();
+            int value = entry.getValue();
+
+            if(value == 1)
+            {
+                return key;
+            }
+        }
+
+        // If there are no non repeating elements
+        return "No non-repeating elements were in the array";
+    }
+}
diff --git a/challenge_2/python/dfdx2/count.py b/challenge_2/python/dfdx2/count.py
new file mode 100644
index 000000000..9f925d12b
--- /dev/null
+++ b/challenge_2/python/dfdx2/count.py
@@ -0,0 +1,5 @@
+from collections import Counter
+
+print(Counter([2,3,4,2,3,5,4,6,4,6,9,10,9,8,7,8,10,7]).most_common()[:-2:-1])
+
+print(Counter([2,'a','l',3,'l',4,'k',2,3,4,'a',6,'c',4,'m',6,'m','k',9,10,9,8,7,8,10,7]).most_common()[:-2:-1])
\ No newline at end of file
diff --git a/challenge_2/python/sarcodian/README.md b/challenge_2/python/sarcodian/README.md
new file mode 100644
index 000000000..7c3f65d2e
--- /dev/null
+++ b/challenge_2/python/sarcodian/README.md
@@ -0,0 +1,3 @@
+Picking unique char from list assuming list is given as :
+
+pick_char([2,'a','l',3,'l',4,'k',2,3,4,'a',6,'c',4,'m',6,'m','k',9,10,9,8,7,8,10,7])
\ No newline at end of file
diff --git a/challenge_2/python/sarcodian/src/challenge_2.py b/challenge_2/python/sarcodian/src/challenge_2.py
new file mode 100644
index 000000000..3e9734e96
--- /dev/null
+++ b/challenge_2/python/sarcodian/src/challenge_2.py
@@ -0,0 +1,18 @@
+def pick_char(array0):
+    '''
+    array0: list, the array that is entered with one unique char
+    returns: char, a single element string or int that was unique in the array
+    '''
+    unique = []
+    duplicate = []
+    for i in array0:
+        if i in duplicate:
+            pass
+        elif i in unique:
+            duplicate.append(i)
+            unique.remove(i)
+        else:
+            unique.append(i)
+    return unique[0]
+
+print(pick_char([2,'a','l',3,'l',4,'k',2,3,4,'a',6,'c',4,'m',6,'m','k',9,10,9,8,7,8,10,7]))
\ No newline at end of file
diff --git a/challenge_2/rust/makernaren/Cargo.lock b/challenge_2/rust/makernaren/Cargo.lock
new file mode 100644
index 000000000..e2dd7ff3a
--- /dev/null
+++ b/challenge_2/rust/makernaren/Cargo.lock
@@ -0,0 +1,4 @@
+[root]
+name = "makernaren"
+version = "0.1.0"
+
diff --git a/challenge_2/rust/makernaren/Cargo.toml b/challenge_2/rust/makernaren/Cargo.toml
new file mode 100644
index 000000000..55e3673ab
--- /dev/null
+++ b/challenge_2/rust/makernaren/Cargo.toml
@@ -0,0 +1,6 @@
+[package]
+name = "makernaren"
+version = "0.1.0"
+authors = ["naren <makernaren@gmail.com>"]
+
+[dependencies]
diff --git a/challenge_2/rust/makernaren/README.md b/challenge_2/rust/makernaren/README.md
new file mode 100644
index 000000000..fb05e5ea6
--- /dev/null
+++ b/challenge_2/rust/makernaren/README.md
@@ -0,0 +1,18 @@
+## Single Number
+#### To run the code : 
+* Open this directory in terminal and run `cargo run` to compile and run the code.
+* To test the code just run, `cargo test` in same directory.
+```
+$ cargo run
+    Finished debug [unoptimized + debuginfo] target(s) in 0.62 secs
+     Running `target/debug/makernaren`
+Given array is [1, 1, 2, 2, 3, 3, 5] 
+Single occurance : 5
+
+$ cargo test
+    Finished debug [unoptimized + debuginfo] target(s) in 0.70 secs
+     Running target/debug/makernaren-bf4fafb462d1be5f
+running 1 test
+test single_number::tests::test_int ... ok
+
+test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured
\ No newline at end of file
diff --git a/challenge_2/rust/makernaren/src/main.rs b/challenge_2/rust/makernaren/src/main.rs
new file mode 100644
index 000000000..2513e123e
--- /dev/null
+++ b/challenge_2/rust/makernaren/src/main.rs
@@ -0,0 +1,7 @@
+mod single_number;
+fn main() {
+    // let input = vec!['a', 'a', 'b', 'b', 'c', 'c', 'd'];
+   	let input = vec![1, 1, 2, 2, 3, 3, 5];
+    println!("Given array is {:?} \n Single occurance : {}",input.clone(), single_number::find_single(input));
+    
+}
\ No newline at end of file
diff --git a/challenge_2/rust/makernaren/src/single_number.rs b/challenge_2/rust/makernaren/src/single_number.rs
new file mode 100644
index 000000000..0d73368b3
--- /dev/null
+++ b/challenge_2/rust/makernaren/src/single_number.rs
@@ -0,0 +1,30 @@
+use std::collections::HashMap;
+
+// Finds the unique character in given array
+pub fn find_single(input: Vec<i32>) -> i32 {
+	// Create hashmap, let the key be the element in input array
+	// and value be its count. Then return the key with count of 1.
+    let mut occurances: HashMap<i32, i32> = HashMap::new();
+    for key in input {
+    *occurances.entry(key).or_insert(0) += 1;
+    }
+   let mut result: i32 = 0;
+    for (key, val) in occurances.iter() {
+        if *val == 1 {
+            result = key.to_owned();
+        }
+    }
+    return result
+}
+
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	#[test] 
+	fn test_int() {
+		let expected = 5;
+		let input = vec![2, 3, 4, 2, 3, 5, 4, 6, 4, 6, 9, 10,9 ,8 ,7 ,8 ,10 ,7];
+		assert_eq!(expected.to_owned(), find_single(input));	
+	}
+}
\ No newline at end of file
diff --git a/challenge_3/cpp/rbrt/README.md b/challenge_3/cpp/rbrt/README.md
new file mode 100644
index 000000000..084268536
--- /dev/null
+++ b/challenge_3/cpp/rbrt/README.md
@@ -0,0 +1,3 @@
+In this code we accept as input an array. We read it counting checking each element and 
+increasing a counter for each element. 
+When a counter is > than n/2 we have found the element of interest.
\ No newline at end of file
diff --git a/challenge_3/cpp/rbrt/src/[cpp]Challenge_3.cpp b/challenge_3/cpp/rbrt/src/[cpp]Challenge_3.cpp
new file mode 100644
index 000000000..df345f7bd
--- /dev/null
+++ b/challenge_3/cpp/rbrt/src/[cpp]Challenge_3.cpp
@@ -0,0 +1,68 @@
+#include <iostream> 
+
+ 
+using namespace std;
+
+int find_max(int x[],int n); //This function read an array and give as output the maximum element in the array
+
+int main()
+{
+ 		int n; 
+		
+	 	//we accept as input a value representing the length of the array
+		// And the list of elements of the array.
+		// The maximum size of the array is 1000 elements, is an arbitrary size that I
+		// believe to be enough for the task at hand 
+
+
+		cout<< "Please insert the array length >> ";
+		cin>>n;
+		int x[1000]={0};
+
+		cout<< "Please insert an array >> ";
+		 
+		for(int i=0;i<n;i++){
+			cin>>x[i];
+		}
+		
+		
+		//we generate an array from 1 to the maximum value present in the input array.
+		//Every time that a value occurs in the input array we increment it in ctrl
+		//To know which element occur most of the time we check ctrl[i]>n/2
+ 
+		int *ctrl=new int[find_max(x,n)+1];
+ 
+		for(int  i=0;i<n;i++)
+		{
+		  
+			ctrl[x[i]]++; 
+	
+			if(ctrl[x[i]]>(n/2))
+			{
+				cout<<"The element that is present the majority of times is:"<<endl;
+				cout<<x[i]<<endl;
+				break;
+			}
+	 
+		}
+ 
+ 
+	return 0;
+}
+
+
+int find_max(int x[],int n){
+
+	int max=x[0];
+	int i=1;
+	while(i<n){
+		if(max<x[i])
+		{
+			max=x[i];
+		}
+		i++;
+	}
+	return(max);
+
+
+};
\ No newline at end of file
diff --git a/challenge_4/python/ajschrier/InvertTree.py b/challenge_4/python/ajschrier/InvertTree.py
new file mode 100644
index 000000000..a2ebaec23
--- /dev/null
+++ b/challenge_4/python/ajschrier/InvertTree.py
@@ -0,0 +1,64 @@
+class Node(object):
+    def __init__(self, value, left=None, right=None):
+        self.value = value
+        self.left = left
+        self.right = right
+
+
+def nodeDepth(root):
+    # Empty tree
+    if root is None:
+        return 0
+    # Node only
+    elif root.left is None and root.right is None:
+        return 1
+    # One sided trees
+    elif root.left is None:
+        return 1 + nodeDepth(root.right)
+    elif root.right is None:
+        return 1 + nodeDepth(root.left)
+    # Two sided trees
+    else:
+        return 1 + (max(nodeDepth(root.left), nodeDepth(root.right)))
+
+
+def flipTree(root):
+    # Return none if root is none
+    if root is None:
+        return None
+    # Return if there are no leaves
+    if root.left is None and root.right is None:
+        return root
+    # Perform the flip
+    root.left, root.right = root.right, root.left
+    # Recur for the leaves
+    flipTree(root.left)
+    flipTree(root.right)
+    return root
+
+
+def treePrint(root, level=0):
+    # Adds a prefix for indentation
+    prefix = '-' * level
+    if root is None:
+        return
+    print "{}{}".format(prefix, root.value)
+    treePrint(root.left, level + 1)
+    treePrint(root.right, level + 1)
+
+
+def main():
+    T = Node(4,
+             Node(2,
+                  Node(1),
+                  Node(3)),
+             Node(7,
+                  Node(6),
+                  Node(9)))
+    treePrint(T)
+    print "Here we goo......"
+    treePrint(flipTree(T))
+
+
+if __name__ == '__main__':
+    main()
diff --git a/challenge_4/python/ajschrier/InvertTreeTests.py b/challenge_4/python/ajschrier/InvertTreeTests.py
new file mode 100644
index 000000000..b9d6381cb
--- /dev/null
+++ b/challenge_4/python/ajschrier/InvertTreeTests.py
@@ -0,0 +1,34 @@
+from InvertTree import flipTree, Node
+import unittest
+
+
+class InvertTreeTests(unittest.TestCase):
+    """docstring for InvertTreeTests"""
+    def testFlipTreeGivenCase(self):
+        testTree = Node(4,
+                        Node(2,
+                             Node(1),
+                             Node(3)),
+                        Node(7,
+                             Node(6),
+                             Node(9)))
+        resultTree = Node(4,
+                          Node(7,
+                               Node(9),
+                               Node(6)),
+                          Node(2,
+                               Node(3),
+                               Node(1)))
+        self.assertEqual(flipTree(testTree), resultTree)
+
+    def testFlipTreeNone(self):
+        self.assertEqual(flipTree(None), None)
+
+    def testFlipTreeDepth1(self):
+        testTree = Node(1)
+        resultTree = Node(1)
+        self.assertEqual(flipTree(testTree), resultTree)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/challenge_4/python/ajschrier/README.md b/challenge_4/python/ajschrier/README.md
new file mode 100644
index 000000000..c414fbbb4
--- /dev/null
+++ b/challenge_4/python/ajschrier/README.md
@@ -0,0 +1,38 @@
+# Challenge 4 - Invert Binary Tree
+
+Takes the tree and flips it.
+
+## Objects 
+
+### Node
+
+###### Attributes
+
+* Value - value of the node
+* left - Node on the left branch
+* right - Node on the right branch
+
+## Functions
+
+### nodeDepth
+
+**Input:** Node
+**Output:** Integer
+
+Checks for the depth of a tree from a given node.
+
+### flipTree
+
+**Input:** Node
+**Output:** Node
+
+From a given node, flips the left and right pointers recursively for the remaining depth of the tree.
+
+### treePrint
+
+**Input:** Node
+**Output:** Text to STDOUT
+
+Influence from mindm's solution in this function.
+
+From a given node, prints the tree structure to standard out. Uses hyphens to visually demonstrate hierarchy.
diff --git a/challenge_4/python/sarcodian/README.md b/challenge_4/python/sarcodian/README.md
new file mode 100644
index 000000000..14373f118
--- /dev/null
+++ b/challenge_4/python/sarcodian/README.md
@@ -0,0 +1,14 @@
+So I took this out and after a nice long slack discussion, decided to put it back, 
+since what I lacked most was documentation, which was causing a missunderstanding.
+
+So, instead of building a Node class, and recursing my way down, I built each node in 
+list notation using the format tree = [head, [left, [], []], [right, [], []]]
+
+The empty lists are equvalent to None
+
+If you want to add left.left, you simply add tree[1][1] = [left.left, [], []]
+If you want to add left.right, you can add tree[1][2] = [left.right, [], []]
+Same notation if you want to retrieve a node or branch.
+
+TL:DR; I did not hard code a list and reverse it. You can build and manipulate the tree from
+scratch and the reverse fuction will recurse down until the null values and flip them for you.
\ No newline at end of file
diff --git a/challenge_4/python/sarcodian/src/challenge_4.py b/challenge_4/python/sarcodian/src/challenge_4.py
new file mode 100644
index 000000000..5fbbed770
--- /dev/null
+++ b/challenge_4/python/sarcodian/src/challenge_4.py
@@ -0,0 +1,72 @@
+"""
+Each root has two subtrees, each subtree may have a root
+Each tree has the format ['parent',
+                          ['child1',
+                           ['child1.1'],['child1.2']],
+                          ['child2',
+                           ['child2.1'],['child2.2']]]
+"""
+
+import itertools
+
+def reverse(tree):
+    subtree = tree.copy()
+    if len(subtree[1]) < 2 and len(subtree[2]) < 2:
+        return [subtree[0], subtree[2], subtree[1]]
+    elif len(subtree[1]) < 2:
+        return [subtree[0], [reverse(subtree[2])], subtree[1]]
+    elif len(subtree[2]) < 2:
+        return [subtree[0], subtree[2], [reverse(subtree[1])]]
+    else:
+        return [subtree[0], reverse(subtree[2]), reverse(subtree[1])]
+
+
+test = [4,
+        [2,
+         [1], [3]],
+        [7,
+         [6], [9]]
+       ]
+
+def create_large_tree():
+    """
+    Create a tree with up to 4 levels of nodes to show that implementation scales, enter less then 15
+    """
+    value_of_nodes = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 'a', 'b', 'c', 'd', 'e']
+    tree = ''
+    depth = 0
+    count = 0
+
+    while depth < 4:
+        if depth == 0:
+            tree = [value_of_nodes[0], [], []]
+            depth += 1
+            count += 1
+        elif depth == 1:
+            for i in [1,2]:
+                tree[i] = [value_of_nodes[count], [], []]
+                count += 1
+            depth += 1
+        elif depth == 2:
+            for i,j in itertools.product([1,2], repeat=depth):
+                tree[i][j] = [value_of_nodes[count], [], []]
+                count += 1
+            depth += 1
+        elif depth == 3:
+            for i, j, k in itertools.product([1,2], repeat=depth):
+                tree[i][j][k] = [value_of_nodes[count], [], []]
+                count += 1
+            depth += 1
+    return tree
+
+
+print(test)
+test_rev = reverse(test)
+print(test_rev)
+print(reverse(test_rev))
+
+test2 = create_large_tree()
+print(test2)
+test_rev2 = reverse(test2)
+print(test_rev2)
+print(reverse(test_rev2))
\ No newline at end of file
diff --git a/challenge_5/python/ajschrier/FindTheDifference.py b/challenge_5/python/ajschrier/FindTheDifference.py
new file mode 100644
index 000000000..d40d91cc4
--- /dev/null
+++ b/challenge_5/python/ajschrier/FindTheDifference.py
@@ -0,0 +1,21 @@
+from collections import Counter
+
+
+class Solution():
+    def findTheDifference(self, s, t):
+        sCounter = Counter(s)
+        tCounter = Counter(t)
+        for i in tCounter:
+            if tCounter[i] > sCounter[i]:
+                return i
+
+
+def main():
+    s = "abcd"
+    t = "abcde"
+    a = Solution()
+    print a.findTheDifference(s, t)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/challenge_5/python/ajschrier/README.md b/challenge_5/python/ajschrier/README.md
new file mode 100644
index 000000000..ab397f0cb
--- /dev/null
+++ b/challenge_5/python/ajschrier/README.md
@@ -0,0 +1,9 @@
+# Challenge 5 - Find the Difference
+
+Counts all the characters in a string and finds the added letter
+
+## Functions
+
+### FindTheDifference
+
+Creates a counter from each of the strings, and compares the character count. The one that doesn't match gets returned.
\ No newline at end of file
diff --git a/challenge_5/python/ajschrier/test.py b/challenge_5/python/ajschrier/test.py
new file mode 100644
index 000000000..c46f34379
--- /dev/null
+++ b/challenge_5/python/ajschrier/test.py
@@ -0,0 +1,95 @@
+import unittest
+import time
+import random
+from FindTheDifference import Solution
+
+
+class OutcomesTest(unittest.TestCase):
+
+    # Simple test cases for this problem
+
+    def test_case1(self):
+        case1in = Solution()
+        t1 = time.time()
+        case1out = case1in.findTheDifference("abcd", "abcde")
+        t2 = time.time()
+        print ('Runtime of Case1: ' + str(t2-t1) + ' seconds')
+        self.assertEqual(case1out, 'e')
+
+    def test_case2(self):
+        case2in = Solution()
+        t1 = time.time()
+        case2out = case2in.findTheDifference("abcd", "dcabe")
+        t2 = time.time()
+        print ('Runtime of Case2: ' + str(t2-t1) + ' seconds')
+        self.assertEqual(case2out, 'e')
+
+    def test_case3(self):
+        case3in = Solution()
+        t1 = time.time()
+        case3out = case3in.findTheDifference("abcdefghijklmno",
+                                             "abcdefghijklmnop")
+        t2 = time.time()
+        print ('Runtime of Case3: ' + str(t2-t1) + ' seconds')
+        self.assertEqual(case3out, 'p')
+
+    def test_case4(self):
+        case4in = Solution()
+        t1 = time.time()
+        case4out = case4in.findTheDifference(" ", " ")
+        t2 = time.time()
+        print ('Runtime of Case4: ' + str(t2-t1) + ' seconds')
+        self.assertEqual(case4out, None)
+
+    def test_case5(self):
+        finalTestStringS = 'yipsqffxmqafnrlnkwrnvspeekejbsuuvuhanlxmg' \
+                           'kyjlgmloxmpyxuvqeabmycqycwkzvhyviaavwryyh' \
+                           'tepqacfuzggcoctviibhbcwzmkbsivtjywienaojk' \
+                           'cekvgsyylliasczuzoivipcsqknbshavzwyufkeax' \
+                           'jiunbyiuvxvpfokrfphcxbaljktkiygrboihqczhx' \
+                           'nreigzhsinustzzrzstbpkfrqsenhrnkrfbekfwao' \
+                           'zenxqabbhhsaxyrubmtzmvtclatncfkkvplvuwzfg' \
+                           'gfnprinyjblutbovtmxxvacouiwgrkgjvszkwswvn' \
+                           'waggsiwzymixwmhmujmuckgyiwcwrigtshqeuguyt' \
+                           'pjjsrmijmxikeraqqgjymbvmvcugxubuxmlzoiqzf' \
+                           'jwpzpqnwalcxczzxaitpmjsorwzmwzgjcgpztaynu' \
+                           'jqqmhvyscupqjflrnjqseeapavmakvexuvkntgcvk' \
+                           'vonjqoivimybahutpjtzubamihhbyhspgtmjwexyl' \
+                           'kqqjvmtpxxcjnlpbkaiiekjlxkrewthipzhfljcfy' \
+                           'uclowlptfhksrngxpzijabhfjhwtlbfuouqskheyb' \
+                           'goqinmhnjzciqvscvneokfqrghekuzkahlyosemcg' \
+                           'qipimjaypxkkwvtqztcexlhogjqfxvfihqqcriaim' \
+                           'ioaezfrbaxwfuwbiylpztmxovutxwhqrlrxfwpfcp' \
+                           'pazjsztewupvarsqcizlneiomljrbufbuhljmgnlq' \
+                           'kofsersqhfucsvfswqxnmqlthjcopeaseqmsghvqp' \
+                           'nmxmuvuoteoqsaneknirsjrleslfsiceoypypbijh' \
+                           'mtmesxpxcurnxjzwjclcesyfmffbcsxvnlhtnmwgx' \
+                           'aywahyhqqfuevmwhhovxrqsslemlpxeiuqipmtqme' \
+                           'qosghyvgyexblvnsbofvtjqfhcowmfvhyyerktinh' \
+                           'ggqamtykvntxyywn'
+        finalTestStringT = ''.join(random.sample(finalTestStringS,
+                                   len(finalTestStringS)))
+        finalTestStringT += 'p'
+        case5in = Solution()
+        t1 = time.time()
+        case5out = case5in.findTheDifference(finalTestStringS,
+                                             finalTestStringT)
+        t2 = time.time()
+        print ('Runtime of Case5: ' + str(t2-t1) + ' seconds')
+        self.assertEqual(case5out, 'p')
+
+    def test_case6(self):
+        finalTestStringS = 'gxtjprzwtvcouwkeiolonsrijhsajpohwkusigzntvwgpqxppqrvxmzieqvfemiakfuakrfevgvjbfssenotnhmigkvrkjizsncfcbcmkynavxtiuhkoinsyocreohxmgrbmilazqxpxthemhvfvafcbbtpweivittjvvomfewmiznohflukxptwuikouwcufjyjbhqfibpttsznrmernupssimsineiuabomsfmygpkmluynxyormlenupaxryjykfmhahuxmmhclrkomfkeqmjqponrgrhqnpvlxelsnftojwyvsqzegfaxupylqaqfabgramcaqfcmolmicollputqyhqwkxbnaqalfqckxrkhxkkvnyhuozytojtabcxtjbmuuqpjzbpaozrmrpoohwjyhisirbrsgorunsxsaimangvqxcszuuettxiwcnripmtykijopatsrusjupolrmacravejotqlglzmbrvzuymjwhzxruvjrxqlpvjcubagcmabgpschaiswwoaqstpwiirnyurebooubwzqgitfallsiomjcrpientnzzjafaxschxnbbslovootsbzykygvypycfkalsjsocmxhztolfebjfqbnzemkflfeymzlpgwpocrbpruqmjhjmewlzrcfgxhvzqcomppgiuhhoaxxyrmksyrsqsjwiqxtfzegboelnptvacgxpvlvmljgkkmzjvjltqraszmesmtawlarritbbhazyjtqgmnarlorbekxnglpetmmgttnjhmnrcjlwrgscwjifgoocmqjznzzkjxxrkqnhvewljibtfgeefyzmgomhieoqcawmxzeqvbcgxjubqsnbwlozjewnwwftktkwkgxqzsuwvnvefferivjabmqxurbfwtgegmewsbhzojntjhibxqbisealvhukhuvpmuqplwrsseixcmrkgmkglcrazgniivsxkkambpeyetsmzznbyosojvqpcztcphbowvtetxrlghcgfbwannqxlplcalvgynjnqftwfwgnhkuveucroefmeoqzqevzqkgerccoeluavrelbtprvwotxmbkojhlabftuxvlrtyvcrrnnixwxgasfquhzyuyfgtttcauzijkylgvsvevlmujrwqwijuiqphgpoaxgspcqnrnnretuskbguzvjzyivwseaopzzxrnqinefzoebgrzenlrqtkilswsijzfazokeuxazaqqsrelkvbgnhcgquotchkncyipnhmistuutvqbawbyitxcufpzjlnvrxxjholqkzgcejbtngwopixehkfewkkallshkbrtczwvqoahopctftugflkepapqvwaetguscutsjvhkpeiniiewobokpmhpileyualjkvgnnssljkvrxzfjvpaegntfrczjgkuttwwnfuejbltsnbfbgirlgrficztljaffzqvicbhinqqhlfurnjwisqeymilgkyacsibwysxzufksqapppoehurffiutjnccgeyoyeneworcaxkbofscougvrpkvecyrqeyysjnhvxkcsmzjcivwimlowzyacjqujkszpxkxgjglqweftqrasucfjeczqhocgylcwfnrqbttsnheaxhhmsfgzntcgrgcefmcbbkowqvlbbbhwsinhlxjiiisujfzagueaksuhwfejivgboylinskougvepmtknrqlfzhxaeinivrprwzxxoigmpqyxuvszpailszflollfholfvfmbjouiiurpmfpbbgejhehunjzrjalycnopljfvbuolevzwttqbgunwxklppccltmllwevtqjvzmqabhcnyyurgtkqbwwbgpnvzpzxfpcomqckvqqqicgowgiphapavyqqambfgowgnzfejrqavgqyvetgjsnkfqzrqfysmjvknfwcrcuhjmsqakilakqutmxcgyziutqikmhytanprafvohbizebmepztqpgeqrfpxvxrsjecibkbrcogrkqulyvgfjgjaypgfthqrbnnirojztbsosxktovrxzrrtlmbprhcelclrsphetxfussztlguxtyrbnnyfgiprtfncpmemebxobblmbrwnmaxzyhxijjizsiwoltmkwzqnlbrbrhopoaahvtljnanzymriqklyerzysrujkjoutuuvmnnwnywcreeguflrsufucvrjycpqastrmqhixzoatmqcvbiqexxbefkjssqiphgyrlhtjgmsusbnypbjqfbpljhrqjvvzhfmpuyoyenaumjnuszcoxyzgchrvfaejieoevvbimypyaamnilxtbkvmzfnofoqwhymjjjxeoyfvxqmlyangzualsjogsfrwxpwixuptklbzkukarnscuxaesnjrhuwuqrtlolgzorhgznbvobgchrmtfcgqqkeylqbnqzmuesgbjmfaozfhhfoysxlroqlvpgaaoxmlrousscutkuznylmciqhbatmrytjfaetfxgcxwshhmzpghsokqncorukrfpwyhhcztckzuwctoqxjbycyflexslqpilevypgczfvyxbvqpjsrnsylzjiffpzzvqfvxonbeqlblsfhqxpzehzlssuzyecvkkewjbrabsikictffakpyiwtwztmwotlwugupbsmzkajelhrsmceclacpxupvfbgbbrfthkfbloyumujcutgrfptmuwhcpxlwmtpjccbrfkhsysytztzgtfeonyzayaqzmybbqpuxkojavgjxxeabgnmqwphkhuwpysvyuhvoykaemycpzlwwabnrxxkwcgplknfyxhowllxbjjuhfjkfzmpgglauksazjfqlomluqqzecnugatghnygrlfalynqblzunlhetgugimqvffbcwfvbwtitclbgnpbcpaqfyexjeicsqsqfqqfirlopapbsigekbklyblxojsecgbewpmtggqcetitsrxvozosphjxcllgmfanmuszevrrnsaixrofaipjnhielexxhxysfzyohetglscczymspgvvbceebuijhgshqjfnnmsxxtggrrnzwkcpgkyjyqevxvwyuymomzmkhqoqwzkeljoxzjgzttiqsgraybkygzupapeetcemwviksiqlitgshccucawgjtmntmynflrsmasbxcuvahkstufveatvmmbbagmvuphqnughpnffztrrewjvxnsfhjugmxwfefrapffgazmtoecpltrvnapvkwsxtnrqlgzqymfycpkmwtgkkothuquafbxovwxtreeoinjlgoavebstbkesajlujvcmprucobjljpbhzxtkqkiwaggurgijtwvhgsebchbaweahjchbmmouzpahnbopvlalxaxxyfyiwtpnrvytgjazpgtgfblnytecyvknxuuzgoyowboqqtgubjweiyrwgfbeukoaptblvzbvihmuulpbaxeagqthbegquxliuasxapmperaqtyafvttevvasizqzctepjbpavmlycqonrahfursavytirzlyjvpvmpeioaeebwtgxunmnlmuscgcqgmpklwkabrotxfveomimhaylmrqmyotzymikqfnhpfetlaronvtyvfwqmjtywqzwyqvqkvkpcopzkefctbxfvqpnnacfgafvmvbwugyznkafygpubjmmqhujkvvbotlebykytjfjrjhwrstliribbkzcqiexgxysfxnieqwcorgrcwqcyvkulbcnceusrekfqwetxybxktriaabbjhzhflluabaklpckujegptbafpogbtebkcjofmkhvjufarwujcfgzvfmgriyithveypbjnivvfzvymptzcolquszvqvpubamasieobgcywywyunfqfgcqtifvvczmhelnyltkjimevntuuyplqecxhzzkbbjmtiqncmbnxvtpmjkearpthnvwuwxfyteiyezqixuzhlhlbfcwhwsnuubwzfmeaepjamfrennflngbyfggstuzigitytfrtmqaorhuoiqtwntzotgofbfashibvxwvwbnmbgxrwqayfsmmvqhqjoskmahthopsznxuejrmfejuhhnbiugkczpapqchoglpsggixkzysnxfpmvpkzezntygfmbenqwkejluefphmjmbbqzunzpfbxnvmraexbpuzvotaqbukirigxcuohqlvovmlkcrqchfbmtsxcqvwaojlwlcsmeviyqexwvprenyssssowvaqfcrqbhhibbjozagrnqzoushkocsctnylepotxbubzrcjhmapzfakbrrewbscgubaqvofwnbfvmsylfwheueyobaiwgvzwkknqsylnfufszmzmpefyxenfksxoizjkfkffnkbvvmyopolaqorycvtvacckcwyejfcxezugwbpbiywkyqttzjttqanuoxsgwnfrnmowhrrgpmyvngrzfnytcnuscontonjwmflhxhgfzrhtpiooghsmhgkataofisoajsquqqqcwovnzfvhjimecxwinzphxfcfcwlckmyscxiqczbeohzhtqsozntyqfneriucaoukbwncuoggnmicsnjttajzyyblftpnhzzhhqfnwtleiaqmwawlvivczmutkfqkumqsqrusmcoxotwarvpibofwqqshwrzlrwvsqxpbrijfipbpazrjojxfenirxigqmsetxcxtkxwukqkawmjqryypjvgkzeixmoetumhtrxtbhgkigxfrrwgtirlpemtmenlrokkosmuouhqwbmxtvsqljtszbzqryfkpvnkjrgpucotbepwoaksvlmwpfzfxxcpkomqhrotrzwjhslyktynfbaxuihvmqktlurcbhueewpkhpjissxqghegqonissltqxknbwtnuhbzwsmrpgtwuuvosibgpjohcuygaarjcjzhkkcrxzjkinsjgoepnctltetjhzoqeeopywgczemmsoxtbhlorlqrzzxqqutwwuowelulptixwgwczrbvbszjwawjntmbvhyvpuotgeoucjhzwmzfmltpnswptohqwjzbvfyzlllpanorcazemhqqsnocevmuuzchsaccvithqbsagmxsjhkhhkylgycnujabelrpavsehppbmcsnshvikompigameprrqmfrqnmirkjvfqzpwsuegceeaqjnmiyvpgjtntnlmfzlgtkkrcgzwlxnevxnkwnovmjthvzohzqykxjubtgbajepkjoiyrlzljqyxoxxsigagzylvgtsaufftoslvlhtbfxcxeopuoiwqsicbmwpyagiqlagzjewntpguthluvrjflalxrugfwikiutawxpweivgalupynqmzbwexorjyylqhwcqynnyielfofjgmmufxybkgiqzyozjufpohawxlcpfiltsbsairsyeiuuofhywahklwolnwgiupnsyasizaaiqwexpbetjzzzjmeatjfehqgkxkknuoekhszlljktkubuzskiwebzbinccyxgcrqrnxncngjlovsolvhwgupkiyuenplkgwkerqnsastpgthcyzgtqunyxczjyatwtibnwntefnftyjeojmfchashlziqftbkfpqqqszraywioaypaogxnrcjnmporvcnhpopyoutziuushmtfzzpofahcsvjypmuprgyiavxmpcmjkbitfazgcaorrmphhjtgxxllwnukwbhgwhxxbpqshezegribzipssvqgzysqvwtuznrjomvusxyguqjnkvrscftaawqhtjwsesoqsvbxypkccvmzvhonhihspbgsghbqqfrwvxlihjlsiczesxwgzsfkkugirecymmweqyofyxffmgxtgxpqwykgqcfjtijjzuxktxjeeyinpvvsuzxtfrqobtnyabgfpvjqrkyxhvchnijjgyesvjawtcwqacatkeegzftzahjthtqruzjpwjzcbfgsiqzipurmxvjswktbgixwokbmuinessabfjmlklxnrorzvaobehzfacijmbjwruiwkgmbzkpnuebgpiaslvybipgnoibnvqqzulamagsrcnnvgeaaolpnfmfflqumsxarflgmsgbicaposvaoafyalpelemwwhmisvblxzvuvtbfwwupgeeiamwrklgbjwhqmpqyfvbaktybtpasgkzslbkhjvmyfahngnolqpofzhgriljtptczmhefrhrhjwuqsiqozolnncpigwrlxtrimlgyzfysfechllzuiwqoojfbicghhimqlhlczzueybbpcojsnitejuqtlgzfplhmxghzptelrhmforskzrpkqofqbwwobznarimmmzfzffrpsimrlghviuilyryaqmqjimqelzzmzoooiwbimjlqarkymbtasvwxorrbxybwueqqxgklvoysktvflmfgsxwnxbyopocsimqhpzwaaxxxlokxpmfbgjaifcevoulqngntbrulpxazfyoqvpugzscjunprbzjyupsosnxyavhzsmztcozqxcygrpemhxniqrcuvoymmflovqgwpljtpxryksjnqgljokbrkppxmtrajselzqsmkyefseieujusxgkcgsbaatuwtpynbeufqpzjyzylhrswmyzczmigeywpxqkamohbvvrspqmymkbrnocmbtfisreavlqoozpkfgtaecanehptsmpfhomspwgcafvaupebqvqwaznvviiafahgtqtajjhyywgirsalratcksijfhaxxwrmfkxvvmtrysozmnayjxcjaiolokeovslolffmcqynjagucakkktiowsnmzjnkhkjbthzpeuhsivgskmtyrgxfnsriarpokpsycktbikzyulsshkzwixebkajleceysjqoqgoluirbvbkbwbhnletnkuooyryemogkxeeycfhjpmxumhevpxlxapjjbfbkqqeilfgjmzntzbhmqrezbltwjbpnfighwyovcjrltgoqzzfxawhsranwuhlcvjwiiykuleqlafyoqlsgcxqymiflcgigmcghkywreyjvvqscctzmbvvurwcmgxokpmmkurkgfxjcfazqfxcqtrosnhaguwmztghejohjcpbtrgkvyanrbqbglvqmovqqvnnalbyawvbvpbulflcmlknvyoctylxiajurkhsrqvsxcvapuerrtyjfjpzyyyfqvjfghbsllpgaashngbnrphhesbycpubhzvpfakfotqhcpkkqufsfgfvxmfapgmntzlpoyimjjhnqmeigeaglbcwivwnapgpthxikspupxkbsvrakgchahhwsaphupfgcmxizqvzltzufkceifureuyoiglrcpvaipthzzrgctbokkkzqkiuegbqioymrupltmmotbcorpfccbnzewoeuauoqcxajliuzxwjgplqkoojumlawyzqqiastsbqlahrlhpvczgfuygqggaijeswtkrayrlsvvnlvzqggpukreffncjcarvzwbhpqpvqxbhukmwtyrbbefmeryzoqvcithqxrpwkwbnggbinnbkhgpjlpcjubhelotgwvatlcjqlufbgpaxgrlewfxgrmjmuophcyglgjugjwtvscfahbiqxksbwjukikprtfjmixcwzpjbfigfhknitniismvclzixihzpkjcrheqvvipktxfbpeuqpkuxrcenxlotlhknipysntkscggplkfiumtqzagcfpxzvwqqagijmwvapuwkapczxtynkygtvhxjzwiotvqqlkiyntvqlumgrqpfjacimgnehnfjetnleqlwoxlbppvsxxyzwxqabzfxamlnnlpsktlazwnztqfqfnfcqpnscyisrvqzhofrwrujtorvjfjnjnsiezgmmuyghpclzxrmkqfhvppbvnoueqcjlqklepqjcvsblxoetpexexiggwhojtxqxanreryfeajaqzcicqpvktwqwgtkrhqvplkojqbnkohkevnsgbivnppjmbjrgiwwzhcptcqjbgmsxrklqtwojpeqyjvfxvtxhtkghghjygvqegsxnfzviimjhpgjcmwuwrsiwjgtqyunwpofnomapbwcezenvzpopphlmtpeznfaeqynietolvktcgqiyfvttfgleshbvjqabyxcvftifqgkulsubezyuvhwlxxvrjlfvsxreueycblnoxjwjsayubhktkjugzlspxtkvawcziikurwfilmiolcsbrhxjlfrqyjaquglnnhtmehizcqpakicoqefjuyixxmwyvmwfinvlwylsibnauphgcsmwykhcyipteqqkyrhxswvahubgvoyjulboetbzgotesxwuomrqyjmkiqnrcgshrwoaporeqroihubygptuatigizacsbqpxcoyiiffecjnflmewhxrzjjovqzohlpsigmxnvhvlhurfergnflwlbmhrkgkwtmwioxwfqqnmcbrqeacfzqtcphuhfzhxeaocbavlrbumqpmkyhncepsccwbbpoaarnarzapaofgykvzastvagferryzmvekpmxcosiezilyebvovgfyefleokwsqwnrbjlpraisumoymxytjcfjnhsbscfggnkqjvteeitoceefkfqfqsbhsgifxhrhqbkblvrinncfktfjcccghyclofixvjifckrzvsewrbzsjimuazjpqctjcnuqbwtvugpghwkisohxqwtmoqoxyfnhxwibvysblamlbjpfwrivawxvmtqkjzwolhyscmqxoecvqpohmbjsrtvqwmquyqtpwbwsngzzgglyhtmfzpkevuokfvjxgfgykyybqpkelkwhicbnmiikxhzixsirvihxbswcyycgozgrfpnbxvgwlgjivvbiwrqjgiyrabhomnrstetqioglbpgfwgrhxbsrieqjblqyrpbjyunzotjvmvqowxmotexkqembxfjnpowxtgwxpbnsjlsqjbujewbwxvjbppjlvyfxggujtbkhmfxjzhsrjlnqyizizyjttvtwsjtxbtrsgxyqqeakcajuebqsjjazpebszlsmrlkxmoyuuztbbrrqfprhkksphgggnpahrhnmznbhozcrqkurmftxzrbmqobuvuvwpguulkbmmcgvqobcbilljumbhrtzjtswjswauqnnhrrzkjnihwriercowmeshahkoqzrunkeeexpchmgbcuphhlukjzyrvcvtaesbneetreyaytqvtwqxrkquzqoqvmgghtmhnvvywjsrbvoviquwrmqjappxmzqbkvscvqayhvpxkvjgusajnslwqhoknvgooycmxpbjuuyxvpocazvgwkrxkllwuwhkxqibasesksstyelhnpvvqfajxklgyuceanbnnrnjvtyoiwkyqlgaenlugrltsvokmunkgrxjmgazaapzzqlxwsacyicpjcoonykztrtskzjaqxouhmzmwgfivjzigrncwoyjwwpjxwasewegqjlxcsmblpkbjeqplqutiartlgnekqkjenhvyowalymzlknqoguryyqogbgkfoshsbqyergszgjrmiynqfpghkvnzoxygbwmgvafxeaqpmstbzpkcfhnsxrfuaeqybtufesajkbyfqctjfjrxxoiwuqxrrgtyieqegneaqlztxihlqtbtmujyvjpsyekuojqiugsjqogvjbamxescbtngjwehgyomnrmcqwhvqgmmzxvfkrhliuobubwpueaefpfmpnieiszytavsbsrlnergfkeesalokmnyouwqrybmerhylbyfpwoirwkzqcxllbbjvlxoukkkleiehowtftjronnzewxyrykayzuvopevcvqyrbifcoqlbcnrevyopyzcwqhnjhequmkbjameqviwkovjyuqryjpveqjteeztouxctmtmirtsfuthgfewlflglzosapgtwaznjwypgrigntkmammcryrxvhnehcbipzfyfqsaqmukcejzivvjcfvsqetoxhkmkltinuwnwmpejvvxohczpgzeyvxhfbmarxjtzlvarbvryhyxyliwobtcbogubfyqflowebjwwkyflstgayuvaizkmfjusgefuvgtulqshbagemunuttviyecgvnqzwthffyctjmjzunyylipaxjpmmsucmcbmwiwhfuigwbvmztvorprzbhknoqkbwowebcjwagpbspibmqupiyfyiyvwjqkejrqowfmklbbsarwysbkwueueiuqhtfgfjgphnfkmpscuhsewwtorcxfqrvixlwwlhxxkcaajtfirjlrxnlvfxjlwvfhxhpxsebjuejbzhsaploxxlnentataugvwlzfxhjhtjgwjibsrvqfiftxgoylqyahrsyekippflwncwqhlpgrbhprxvhmeltuqxpilzcmjinxqmovoryhuxtopsyvfztvkinguicgjhmowcanqtwocjvotuvnbnsaiifnxtvywyjxeqwttmimmezwlkfxntbbgfcazfwtmxmnacmsrxxjczokbmiwhlhltohizkmnsehowbknjsjooxppsyvucpjvxljhreejcjczfsyaxzvbuckbauojacaxqjurchjscwyafjofyklbexmjqmrjqnfglatgisrgfwshhvczzpwrbklrgynkauwbrxhokpstuxrviruastkzchxetwgtcaieugkgjmbikbinemicwshsiweevvlmgcvkjtoyqukswmneecxiwiuvkorxkqwulofesqvsmsesoonskbnbzlnbcuwtanrxsmfspmeenuazjitknjpppubsyrqjmgksttbeoyheigbbaoqvmiprqrfwbgjzsviroexabvriozxjajnrkalqwuzcfvzjnyifmfaqvinvhhwoaryrsuzihkskibcrxjjqxjxaaypaoatptmwkozhnbagpgyijwftobpxmznnfecsrvgryhfgcgxwfmmxlmybaetfesvpfpzfaehpzhmcyltsxoavcmwzkukooktkiahpufbsisnmsozmmcrapisujfljfszkucgxxurhhmrivssmjcfeefgnaxencnqwcbqeqezqwtthcersurhcqsrljnfwvmkpgstbfarqlvmgrhthlqgximbgackltxwhofojvspsuwhzqfxteqfxbgfnoobusugwfxcnhaixrtskqslmquowssqcewqehhaqfiogrkaxjifmyglpzpesxvrhgrtbouelgxlmsxntsthfmvrbawanfkrbcbzztnsezggyxmkgmvaglovyzkiyustucmcrjlhspfygokuvoauizbbguafwejbxhlkvlmxpteswajpjhofchlcwaklxsfpghmynpjlxxeqgafpvnqmctriwtarknjhlcopkayzosjztmvyxbrkpxvewhwlhscjvmbazmkmeaqjfakfbwffgyxfukwpsqiookzpxubwpnfuzriprwaoeophvitwqxwukecjotoewpgvflfkrraaqjbkkrkgkfzitchvljokxarcnfxgwaqpjcevcmzkiywjeoqigeaqrxnjqhgnnhgknwwxkthbphjpqxkzlnewxwkwlqghbryqkcsfzikayrfkbojjzywkvfsxicmuijlppjgugbvyncwuembzjvhqovffcizkpezvgkzpstrgubmicexnqsxzvjtpujxbfgititqxghfblvzygbgsfuakvleopixhbphjgjauhomfsgvpxcyvnnoghiyovrzfgmrxuwyrrkmunjfatcbbinbexjcxzwqnpeenshupugswaghsfyrbaofpxraxgzkxhfulbtkwqxtejkcrzazbptmuilqqyxczzpgmntyfekswsnbfzafayzantclwfzkmtkbbormhfehznfghklvipkrcrlsqxkhtabbqthwljyfbveamvwioehqrtecqfhqfnrzvepjuyexxrbnxsazmwvormbsreexvknxwpbmpnuqjppxebtnkbsrmtzycvsgccliwszyqmwrirolmzuvsnhzabhhsejcjqlhnrkktfmsogfhtveclmvznansvwcbwiozfaobryqxjitkxnwozqkusuajnvnpbfntumlbvzacuouigpggcabjszrrotcqxqhjbouusrkxcctzawignvfrfhoyocnfrlsssufnqucebvxwvqlgctopcjqmkhxzwukinwzuwwjuwhlghbzfsfbunfuzuiwsfpvkewfuhmomrskvhwgnwtbivggtjmwugpfhshogsijcekisyiatnywfoleagjwanwysqyoccvrbojopomzzcktigikakwxsxeawjokykwynilnijbirsvywmswcjnwbitagmfxpeifcggzxohkhtovhwxcqjqtcbtuurxrfgocylfxvtomcunkycyyfzgotzulsuemunyqahpomkkpocxrnkavuvcvofguermjblpbttxmggucputynunqnfptnarnytgnhqrcjesfbkylmkhyluhavxpajethrgixonnckxqzjbkqoxirhmtvhjhlgytcaznfxtawizlcfuhrkbecznjwpzshqweppjmchwyzviyfoamucsfhftnpkjohktygyfvkhzqraeiprtxoyllbhtejjxisilqqpbmagnxnapeztxleoltvwyhxnffnbhahumykqssikgoezrrcmgrslukvkhplbyacpqknskrsueekpcqhivmzjyxippbpgzcpikqoarbbrfecfrwxhvufeinptzcyztuhosmsfasbxoxauzmzkqhvqqenqpqycakbqplykqsrbxniopyyxqetjnrkjghngmqnsknurrcgjuuxsgzcsipnjhbbstswrlkjvxbhclwnyhvymookwyhsuvxsszzupbeikwzoycbrwymyrxhlvxmpvyikfhypmgklrgiwsbuapqlezwkjeokwsaqokeovvzxpzwthvnqnyyaayrnxsfigtxqirovnkhsniqnmyretbjonowazninmmhksfwyarvlxquwwkgfkoccseehvlfqgolpibcmpehlmjrafemlzsysflzysoieoryqofeekxqjefglajlltwshejaylssqwwltmwjhkqjlzqyhetzwcbiwrlmqzcceyjircvhzffknycwjegbspxhybejjowhchhbgpejewtwohcjtwgcirmvjemwckqzltugfqaxkovuqnucwcygoynhkaeanaxhetiaozmgepiczaklyqvnaejaaariqnhyelmykhimrllcztlwsstaqynwlawsnjznfbwclawqjvlypsrbznisqwczmmumtjtmunibohykgktpnmwrxxfpzwxwmotbcvfiqkjrqcouanfztmzqbqcnatfpgxszilncvyhziinbaeczjxlggjmzlholksorfhlywbiuwzvkkssatvjxfjpcubwkvuwzjzqsrfzscgwsrvuinwafwsppturcyxpwttifroemvsupggwfqqtxiivgnvykzerxnujkujjiecbzvuamlmejasvnlavksuelnbhpsblhaxbcfiwzflaqieecbavrmhsvjvluoqyfyvwhhacyevcikyeqmpxekkvscqkwkrkjlynfzufacmfyczbfbwmtarxnuxvwnwqmnyypjckgnktsfybcrmlsqpvxwomkbxawkypebzwthxitlnjaeaolvjxqkfnlglbhopnpnmactsbfqsiczqjvbpxwemncozjuebveanmzrgkpqvcshvrcvjvrkeqewyqzsoevcepleyiwepvvlgqyqynjsmkjrmcgtfbspueylqzrtstetkxitpkwpxkvipwzzlmwexmvzzchyrighsitozquyvzhjezplhgtlvwkhwjhmxcckiqsricehgsocxjgauyxarihrbjlxoojvcmtnyktpzktaniuaapcsoaevctbmzoeccstgktewpolkcensazvojompzbkpfopmxefhjazjkznoyuqcyshbnzitckvrnvupvisjzcqanvweujvraycltxgszwaniaycxmfmpfeurbhtqxnvjwjhpybvekqvrqsoqwllxopxxunaqmsnmxvobfowhkwhclfrxkneloagmajqqnoazkskfhrfhsfwjkiwapatqplhpynocbrzernegvubpqeqfmxojyszmlvqgcgqhamjwwyihpuqjvfmrzyifqqsvmxnfixtvumepwavywqaabxxangnelpaqeyaqtjibfwampitnqbwoaipoicpkaemzyeeaqvhbbrbaipivuapocxnfhxvvxtakoqvrcvoavugaazqoushvyoebzinngtljtlfwaqrscvrahyirlmmfyehzyichmwhlqnqzxfmoawtgvomckjuaobjpsqpxuobvejccaubyxqhvvlcpvysoaexwfnpariwltcmbywffnuklpxlilspqkwzbavywonlvlvoxaqkelizoiutfgmlegfhsnuamaeglnpztgonlknxpyjskmrpqkafahwowoikazbvssqskgnlcbrovvgfctfowphrjkwrirpgurpyizkjrhoqqqqzhmsjqmymfvhtulysokyhwcjpextokahazvrpwbbvhmojpsqtocvrtruzflpmjwpxauirlpomwcncpsstmnsecpygxekqrkiaipvmkvjeiggeseaeyscwlrhhffgflxlxumefutnwkinrkwvjqynoqrjrqbpcxxpiswpujvcqyvfolznlgzrbmvtpravkmuwfabylkajajxtebkzqhnkwlpmsxumiytekuksitxbtfffcozruhlkfcjaqztgtaotnphgibacpxtwsisvmlervzkktoxsnmqcijosscvnnjkgfjmxozmcpiqglxtvmcxejceqnihneukkfamntpmxskxecomhatyvmvsnygikugetbrrvofjckbjbpbllhyyhabeeelpsteghrijjtkvlbsrcgfvlabtlgkiatmfouiykamwjqprvrmhjqpwtkxgfpyenipgtqbolunzcwkvtvilzaqzxqamiqwgbptasisyxpmhesmykvfjmchynktmvgozwckqsovsyrgugsgzjavcwozcsqfjeyzithpfoklmwfemitpwjphcluysoigwqoyfwalowlfhijxeykazqgemevkuvqbkfhjwofzhmwlpyaomczucmbamujionacizanrkogwoscsokmxjexvakipcmghzyemgizgosziqrfatvzzngzxoilzxrutkocfxyfnhpxksubbtohuvenryiqagrfqhzxklnayslfeveehhqknaegcxmylvtwnilvogoppsxchhghvjboblqomvqkrslgyvhrpvceivxvejnawfeywyspejaqtzprlevuntjuohzzgngobmwlvtvrneuymnyiobytfpasrrpselsrcqwoysavcetcnotjycpparvptyyqznpkbhatpunbkywojwwsgqllqjktmzclrjrvhoihkguxmhecpaxbwuxbkuislowtcxmjlgxaixwfqiocrrtqjjhtognhgusmatmkisyejnjjqftbtjmicoffjoyyegutppgcizwncygjgsphobpblpgixqtavgreueryebzqcpjoprfpuqiuaecfvjgrfnizqhtsqiwcucggkobxszlzomxhyhoamvakisnqlhiogouobgpwuvtlhlyosywpnpuahehyyqkkpcxayjlicxypqcwlknyrenfzwrocjeytzecmgzcktrehygzpjepqwjkgmmezweucvarfccwwnohxvnngmlcaompgimcgfzrazsympazzrichuvsrkeklnbbgymvmiszmvvtrjwfzjocovngzcrgtffjlkizxvvmhtnrqbuppfoaynkfryvakurqvblrzhpneucnyflcvacnierfzujfyonpqmwqnvsytlzhrfmlfncyyurpliuacacbvuyqeragtjxvppeiuvvqyiovvhmqxgoonxrzgnhkyzwewnokirinnaeqjhpeknmnegbzqpecsmapjgcbwcsefnvsosmugjxlmnnnnnsesxxhuujmwkhczemewzbpplzanlfltguymxjiqnfuxmagppwpvhhuenyeinozuaqaqqxcezscfmwlxusylqwpgmlurxcytereaazlplcyhaxfcmhwwzcahietrepewfthlpqfpbbfbynxlenszejyfgekkyyajkxofhqxtakcmqtfzwtyptcclxpuyenxlixjfnpmyqjmoaghupxngfapmegwqsrjxpbhkpurwcmrtmelwzobnwecznfavnotmezpnnuhrqtchzrfthkwptiycramgbzczqrerfyheefhkypsnpmrtyztihwesonwqsghyuvyaplvzguonyqlbpqkifeopjuuvqqsygwthfevobanjyrsegnxpawbphulwixiukunppwxevbvgugntvyrulrcherhazmejwwhjjqnjgwqijblvexisamyraxhhflgpehwpxyraxkmialboegsszshiewanlxggfnniwpoogzgqwpcscejyptwltzsrtoyfkshvzguawoyhmccaqjwskxbcbnmzgoubnvvciilyncmrkcynslpewiwzemcpsjkxcqiuzlwxsquaegcfnskbllmrrqzhrvtbwjjyunxflcrsaxjsocsefkqzqbzuoapgnoxtbygkhpvatjciirrvcytppjbgklvxjpyexhofegxumuroiriwofmzejjbblfxhxifhxubimsatjcqvrhoegcfinajpkrbglowujyzeeoaivqfguzjxhhuyazhpjobfojrexmnvxvglptcokuojluknixlihzkisxqutgtayonlocmwzbhlsxnimllmmncvybmalwbakerucnbgbsenawjlyoaqmstaxrwnplyeitmekhczyqgcvutjiztmpqkmxhmhqxnrjkpljvyzjwnioqpxnwfmyqmgcnzlskvvtaewnlkllqeaygpctrspqoxtfrqmgfesekrsrmnxqollqibbmyuzpecunvcifwpykllrttmiibulohryaorjnzhcjgnrfjlgapunrfgjnnrywqpakoqbpcrymyoiqcltalesxpiquhspwxoyngyhepwtarerukyxjoxwawwvijbckvznxqrltrybhpwhijyubucrxsghxfnovewcyuklmxmhwcnqbkavvbavgpwahtpsphyckihfzquckzoggbsbyovfteyghyrvmefsusuymyrqvucpnsavsucujljeutqgcusfclytaofbrohejquqaworhtvabmstsghgbnwryneccppbvsfrkmejzoccitzifqjrbmamwppsgazexbeibzzikmnyppkxsnzcibukwrqxuptksbhcwrkmnefmxiqpctkkfelwciafgnqomonrzehkhrgxvjwgmfyxzwtjjayegvkohvizmthsgvaskkihtuulyflvafjppblfiuszauwlftubozsptvcamrxqvjgrovzphnqamqmkeoptjencpsxoyhggzpzqplxwwrcajekwwklqgixfjvaktfshoelpqgrckcvfvmuxaerjikinjugygstfyxzwitkqukftgjicynzacazyavqfmojlrmfsvtmbmsszrqpahajilvjunmqconelrjrszukytozlbecjecoquhmpzebciquylmmmlfflrzxbqmqofxmytpzjjbbelxofoygikgcypmvpxpaowwyekqgfktumofscwqwqcslpesvyttjiyihxgibekwamirzjyoqbvurgqwwcrbzukslmhjtfxbsiyzwaufgsrppjwfgscrwijyoymsrzbpphxazasjgeorgpxzxuecnznenzwkxkikmworrtmtyqxftwibcwnjmizslomexrlbqgbystjuupsmzwacsewqtekmrkofhawqlbysqlaspzcvofyrfswriafjqacnmvrlgvvelntbkyiufrknjzsurbvkftwqmfbnzmiftlgsxvwyxvlekkksrgeaqbwhrmhikbowuppeqaaulcbiibcscziiwaxfqsxoyerkqwbezozgwvcumawnnpfrruxtklrkzmnzrsbnaotvpihhlfraaogrsifcaxtfjjeunlbknknarfinsztvboqgvoznojetexpusbzkyaigwovuukvwpvkkiziizpqauhsvtjrtjaxliepozeiuhcgvietnqnojacbtuohesmoyazckoccqhuwcpvxobytkmcxlianzfzbinwglimlytqcpjybvpxfjkmmpgpioyweapwpumlxfkbixhgxswfamjsbwofeffprqmknrllhhfbblhmmgwpcslceinaegrfkoenekoeggsfjxawibsuvnzubfnvenztcjmaezlagrkxlkeikejpbvirbqjhzvyepxjyoztkiejlhutxylxqzfseiogbfzotfbhcfaqcwlbplzvfqxkxahnpftphteahlzbjfqthhynuzucbcbjnjkcfwzalborobueimogzybfjmizhwccsrjicukreuoahjkbwccjwkwfuimrqgaixsobvrfoufhvukcumupwxreeplfezxjmihvppminvkyzkxeprwhtpmjhqgtvleormpvaksltevtbexraqqzwfsfkhjwusjiaxcnrwxkbvlnueqjbbmzoluwqrharexymrvbbbybxitpyuqqwqwpfbwgngjopysrxnzajkzcxitucrlnilhgqhefgjgkpgrzfeeumcvfvoynyjjuotsenoevyeltzlmqqyxmkjhktrqyfzsljzoqhtumjlwinwkkoruamprupnasvcvsvfclffybmnshxmbiyfesnalvwrspnlvsxrhbbjbymaptukahgbecfkplbpomumbyzhiruxmrgfvflmekpjsasycysqgowytszrwvsrlmasuwbjhpxucfgkrcbvvoyclctgsqxpnwzfijfyywisojlmkafnonpkxswptuafzxcskltuyaicjyhjjfwmhoxxvvayjsbocxrlxfjizzqlplpuybbsixxmvoiqhxfjcgcbuhvajzqzatjfavyzxsojgyytazzglrrvxoahlvisnmyrnaejqfpwhqyiujsprkzwjyktvmwtaqiofsmbplyqetbcmjmmgaowtepwcgwwsfqoimllwshklxonnybqohckkisfcowlioqjqzqxrcllujwlyqgpqqlxftsapbbbkiovhmaofkvtgkmyfmhsrawksumublyktuiztaxkyczjvzkpfyqqyifqqhjrujeqvpkkuygekaqxanxkffghvecbtgmsqtrfyvwsezriyjsgcubromscttxpmvmmbcifehuohbxivwfommrfcqalzcpzggattiijvwbyqatgxnounvmyjgyvejkazsbgbqafocxhrkkukvszqwqurphmalxsngzyerfmfhoqszggpsjhitmzgjyuwrfvwcngpcgtngyegltxkxryrbwebvseoerjjfmogmornwwcbbwqaayrohkcjlafzrzzvefioxjzlpnjizvibsqysiucaqzxtelaucslxxtnyikkaxoaffzagxqgzyvejabklliqwgtertzksubgwrjocmyaraujaqyefjnkoaezjekolqmnrxffihftuywogylbainaomlbnqzjythrtceqzfqenxnqxwgpzrqihsswwteqhwhttbfgopkzqqeokagrewzzmimphgqqpfjtzjtgrhzcihxnxfiqoycaqbizssbicuiuaishjroiapfkkgtyqhtxgvsfowhvbbujibajklqkhsttylvynphiaghabenkoxlrfzhnwmxmuwpboaghhnubnirmtquohajwhixaairwikxfqyixaffijewqgcosiocnplzkemlesnpuiihfwxqvpwkmrjrsvcjcngighlhbexemsayifcowyqyqhkyxhryukinkahyetovozogjkyhwzjqmxxjobxrxptupaktyhzgkjysuruzgzuubfpqiffyrjkbgvtwuziccjplufssqfnsuokatuaspefamzpkjevolzbochmpgzheusysguqwozexubkwoiphrafvgvmiehfeztoxaymsctqxxkzuxcmzziipghlslylgelzmxxwyuqjmnbcwleghhmlektynfpcrxttjcxjbeynvgnelyspripzqsxyybrpmbjcfnvawrjexrzfgeetnbbwxnijfjgicwfsnxuvnxtqqveeeffeniqvzcntqevrxssxycrtncvibcmgkxuzfexacgxtrkrgefaczrzfspneaemokcutmqfpmhjqnnjpvowsmypyqjrlhkjmmerynstpbncyflmcioaovmerpjrhbkhxmeummqohmoaevkzwxzmtcqingaofxixtampefeztvpjzhklgrgsclmpvhlixqkeahgystorpuzrhagscppcirfpyrycpljtiowsqphktlzkugvfbziozptjwugrlecqcotbzvnbtphzbyukecovzyqsjywkjlltmvskfxyojbimwihgfhpkwjamtprmqtwiqxxirguqtzkotgrlmhklvkpbarqmfmwspahpxipwfqjbyjaeaqapljhextzolvkkenwfmslgnjbmqqcpllurqabutqxgzsglocresulkpxgxnlhrlyzpbofepgymmthngbpzxofxyolxayfniplqhkqtntlswgooybhgfilrtepbqnayfpocerxhpotpzbhqjcgcjmioifaxviozojhpvypyrywghqzhwobhhxtzyxhumoefmanesogbzpyltvipknyhrbsmzhgwnmxyjkgkqpaxfqcipgcryrwziveuisaqaleziqzhtfhteyfqqmcsjrbiojyqvttumulczwaqlrjilcchpqxqfqenkrioryrjhexvcntrizqolqjoecqztacozuezqeihtnbbhlfmicyhariqjjfeuafoicrvlcvxrnsoquwcwsfpxnatrvylnsjugilihoaiuvjxuahqbcjycggeiemiwxtswigtkjplnsgurznhysbecelbrmxpoknmxspzmgvtvtkbsrkzyokokezglxqfokxayyepmtxmuyawzquvnqeuxlrpxaltommjxtnxptiiukkuxoeiixuppmswzowzplzpnslkbqihftkxswgsbhiziplyvlhihpfvnczovmvarwxhfrnjujxpnhisgqspfkjheqcrioeltjxzjvcjvttcwhzwtsczgrznmjnjfjbpnkryaiyfmkppihyzzxayjcnxzalyskyrgpqnjpgnojyhfqavlumitxfpziyecnfewsaywvmtteryfvzeaaehhpoqutbyxuauoemexjtzjmpxwjqntnacohjoucezxchxylxuuuuobwzywvuauogzmkgychwlcrazktnwwmohtssaqqlxsrnopghxkuhylrjnafomnjkmqmxpfbxaycjnenmvjywwsojjqjyfzyrimfoqjopgvmaeepmfhciegyalfkxxxiuclimamrgcnrihktsqiiauxxwnaehrjkeacfjwlfjtfuatrzrmcmpxkzvayqkzqnsrjnrlbhowyjyviahcnuqozfirbevcjtuxvaqhyizafzpqainmxmtrsknifuyallgrteagnkwnmwzvbbjvmqrsnepmfknacwuhpgzezkqepcwognqkhyzcgihjrbjlshnctmrzvuexuozlxgcmuiarxztebvsqcezyogoyrqxwesuwhgxtlfeabgjjtuwrhzgvixseletkklqktlijiyrgfzyemtzvtvmavibsozvfnfugknsxjwyxtoyiyccwekgiiuxggioorhavcrhsjmjzuyuzlpnrmfbiuxtaipoqbhkrngfzsfqcpuflxabergkbtrgmambvwpmnnpnyapumqfpjycwjwrxwpqpfathlelyffllkkkmkrcrwnllrrnovzqqyygfrnqzkptcihppmojfnrwwhxjviixisuhkpzbrhvbokqpzyytiebtoueigkvxnxnhwgpycrzfrrmknslpxghqhgzsnxbepulteirqafsuilxoaxpwhfzzgciglmuzcktmwpiafjeyfryehshccfgvfjvpzgmzrnxhriojpbwwecqzhrllhmfbqlagxihztxfvapgpmkkgevsnbiuemypwljtjfayvglxxucpjrkoeeeutsycxcvlpggvvhqvozphpmgllcfyrfcjrwbmmwknhbfstnrjfosibtkxzkheskfffocfznjvnrktyfuoxjofrmejluzbmzlufnfpkfygprqqnybegjnirirwleyqxpkusuelivfvrknlsspuwlwjukqujalxpqbkstlbqaejatjumkvvvkbjjvaavwfjmjlrrpizalpcgvwvqafoonutsppczzvybvuaabtboecrnjnscrctjsvtjkkvffcjflxijsaaipqnfgksrkaezpsxqetzhkzkesrzinmejrnluearhgvqsrbztwkcijznpzrpauyqhkqrxisivexjbuljxujhmvuuvbfsgobxtnwqxoruyuuviityehjyriqyhkgtywxqmffffhinszmlyverosrsqaolgfjempkwceniceysoyrifjaouslzkuekqrzxoupcgrztftrmjcijxooxnzvfeuxnqzxqkhghqmqjhrethxvvcvvtskbxkzvccqufuuwsgpkzigtbggguoxolwrkezokcgiftscpwgsiwfmkgykwwyxnvkhpbajvqucwormzqymqvqeknzuklamwrwxsuagkqebxhymvmrulxeqwfupowszkoomnxgwwtlbsejbiaigbvykcyaearuiazrkmacespyobzilnlrpbgvshjcybsmwfxcooxqznmjjhjewtlhqoblaajfjeicrinbgyjergpteafsimjvjhpqybnpxcsoizyrqloyoeerjvkstpnnmvbcalwoqgshoktlytcsvxenkvtzltqsqjapkunhslwtykeejizmniifwjeorlajayqpwvpkouegejzblapmnququurmnaykplvobpqqkumxzbtfqxiucpquxnqfjlngojrkmwmnnvjwbbpjwpqyrkqasxnyqylkwljaxfonqhflxhbkqsfeoassxiycrmhtxckhxbxejppunrilfspzvauivmbirfmtwrjnbmnhebfrnwtnbiswoyirujapswnjqquxolqbfacsyrvtptvjpsxtgbkwlryoxnjlfpqcynrokyjjgeryyanoopcpfvmtzgcevxncjocyykqpvpjpugbbbrzrbtwsxtnywwkqfwepbvmhxtptjnjewqlwamgnjjmsxrwypaogilinynfbwbboqgjnblnkfggoxrlwamagqituwlcoiiiwtousboqtfevenbjskmupxonqlivoizvwvorxbvuyizmmqwupruwktipzlexstbjslpgfjvfqnvowcutgemewzvmrilyujbsglnfgjwibpneezywcvfnhrnuphshnslofgrjlgbbkvehzabwyaygfxnvgqlztywqnooyakhnilqjuqzkieaeecoaxuseiqkzbkqyrvrowakjkieqpaecqcoxzeoqnyypatlynilcvamykspgpncrffyfnsulwywamuxienhhutvfumfomnmrztufgofkekysnhlpkojcvmsjzkabnjuuymsqunglnctewatcobyrccrrrwyrhtmbkqhgtyrulcfsuchhlglrbcanzwtbnxsnbagnsnkbgubmutuuukeacxctyjgvixhveifqvlhxoewleumoioeiigihpjlbggznxpiyvtbsphoxfntbhrlijyjcbvobgzztqvuzruwnkhiljlirmpiwrbcnfiebkqnletqqcvanwfmwyblkxlqusaiqtgjpwcasxcygjpsqsmgqapcqiofmjmturztlppjuiwgiybnaypvaynymfyxbsigbtvrwyewuvmoaofecymrkiuoykxaqregjkurvvgkwvtfhiijiiblkqbrfrqucheaezpganfhmgazofymkmzstiiactsfvstfnrstnnskzoyiojmabjlphznnkrcmcnfozmhfhhbggpyljqxkgcnuqqspztcnhbevtbmsytytjjezwhyxsbtbzjjxhlpxeughavjzzgvltiyovsezfvrokaeamjstllcwptrfaitzqoabqhtzihkwvqofxtfjswyzfrseezgknknhlpqwzbsfftxzcspkacqhaopkftponujruwnnsjczujruzzfwcvghzgnysranxcqssmzbrvjcbryqcygbkoxrheoybcxjazbnnihamjfavyhpjgbgcxpgqcustsbjhoqboaucwpzpkksxrjjqzqrrqyxmhfavbyuciamwzskhmcujeakuokgwjucrwsoimwaoowcvfsezakprkbmuoftuzlllxcxtnmnjegnzbyyuytehztwrwenttibwazwqctpfpbicumlvhsthyljqabgqnkhkyrpotuwzuqxevwfqwgvuuvxcafkpvqvrfqqppygruezbwztgovnskepwhtwicowsvwvjicesukalgqxeyliimmakweataktencanomfgomyjxoioieigzybuhxauylfsmwvibfohrnxoaalrnfoigqcxajucpcxhrfrolttqfkwxgtjbqlseocfgsofghgxkpsgqtmwvxvspvhizqufrgpqxupmcmxogftltawlwnwhrrzamrxzngglnsfyvyqooujevzubnphmwtjarufyfzxqcsjpzaafacjcuslbhyjupevnxhzileqgpugwneqomfrcnmcchwegkmfitjwrfequlkxawvslpuyfiecixxchjjyqvfsmhznlhfbvqhmufskchatisaowmvwwmsganucbqtpogzbrlnyivmtowzmucpzbijtgohaxyiewulbcwouebmsxaijfuykknztqunbqmlxbylnvgkiwlmxwcxhmmaqkpqfvbllcpsltynwoiszpzgzmwqfwzhjxiwhznturtzbuqznrgnxfqpascalhctgjxqzykkpocuspfjhpzkcqigupxljmkncowghflvaavtzjfyeyynijhvxmfltjmfqazayilyhcriwajwrpxmexrbucszacebvxbweaelqqfgyfugnibfebqwjlngkckpseolxvghxrrbaofnptkhejhrthzzibpzlqwritbznqrkvhaxkkjoyjurcvsyijtmmifffpmyzshjxtqgrmgkzrhzgnucaacthqgpcpvctwryenfgszsqqbgeusimyowyxmbvbnftloxulxrzzxvgglcrwyftkkjsxgkmnamesagngmjicrgrfyzuikkutjzclmkrvgrewitwfxotueebnwjcruspbaijapxhuvxierrnkvcfwhkemzvcheiawcqiesyogoyfiwuwxnkhnnkrkosckpnzwzllolxlumervfimbvcutqiyrplqewmrcqboscwezpqfbtcwzzgrbjwiyalokylejbazgvlozyzonupnxwyqeuttylurvhqvfqtrfblbannuvfjixwjirzyjfvhfrlsparxnlnirwrenymswaqiiozmtgipyukuuqyvkamuzuqnlzzmngawaekftcicksyqmekzacrtyinzyxsuihqifkkgqctzsbqzsmjcplpohcjkjvgwllheorsrlkloaeevmsowxrvwfnknbvrzqlkxoeovoatrronmnvtaaesmhhpqnktvvmzgbotxrjwfavtwgibormcoyspcgawtpzfykyfqlhxijomunxzgtfkqvegftwayyhjhwkybuttzymxmjtaaxewvlwftnspfuqknwullpnuklzknpckoaxufvwjhezubzlliuiuymvmbccmeqnkwzhjfumlqlgqsiclyhjrsrblxigoqiomxztnqvqvhckpgcwmaobjrrubgrbqlcaozcxmajbsvznesstilgwamsyolhoswszpicxevrbwitocyvtoleavkpxsiptlchliwvhrfaftvpwlsuizexriyklptkmyeyofaetpivqjmolrzmffuticujevbxxfvkwhrruvnmhhlqzanwlcfebthwfawaqknitugzkppfjeeyciqrmullhkcxczzmistpxqzzkkhjnbxxxxphmpwyjbwkyferxahryoeakiplxofnfhvphrpjolfhlfgbkgrgijzqwtowejfimsvooevqlzpujlhlbczkbbjtmnwqhgmarrpgmhfvvwnkuowtlrwfofckxuajsezjbzxqjxgktwktfzhcjusrykmxpxxysfihbbghkonzogcjkalcfkgejyjemgxqpcgmpmlststsgcyibmbzqcpksmbppkooeklzhcgwsokpwtothymlsqsnwrpqeahvbaceuecrlvobnwussksbftqepwissftvzpucbifnhmbyegysvrhqumwcjhzbtpyoglhlovplkvpjsisuomhrztctjynghkzjskycjzbykyvrejmnwywnovnacvsntqoffsvewuxewxvcbgfrvksticnnikjyngffvjwltwokfhfhmnksanewyuzppckgvvqiuhgqvpszeyuflsmfhhjwypiljvqyuiqcpmttsmyeecjjvmwvxrzontuliwjutrojvpfeocmhsrrgoyxiequevcvbjsjqcfmmkbqlrwmpgubjafqgfeaueymitrzbqmjnhusufalgbgyytxhvwbahfwngqqmwacwfivwythexiqnkppervmrsmosyutbepxapxbnbhfrzwmlanqivzcsbnhqbzptqscxavczffsxfflzblvptyhcigenuoasnbrzeqkxltggqmisgkjfwzyjtcjjihjphvflwkxioulajqnwujwtwzjlmelkbulimcovnylmptikuglrbzhqjggislikfwnreohnpecseglxiohejbknrrvxajixqvjirbpalwrfpfftpihggemwyaooerulaeosbevoclisyqlrwoyopcabtkbeoevwqhoalqaxoeawpmqjebyfgptngfqnonocmqgmaipbwpkunyegumhjnknzinwzrfscxurwstcmevjcioojrhztxtpluyocygqjteatxtyzbuzpyenlhzxgyqurrksiyuwtfmsnablsfbtausbajlxqocchrqeuejctyplkzsnzkmmjjusgouynlnflleaebzxeizufwtjeerymwrperaqqlhyyskcevauvychahxshbkqbasmvbgplttkbkslvujrwpzhhjkizqtpyngjenffeqnlkjyrfbufkbvctiljqtvyhhrognhqnpwnbtzjosvuzhwgaytatrwxijhulvriuncozymyxzgalagvzljsgvoymrkektifpppptcifayicrzssksiexkfovjyiafosicrzmyblormlirwnfybphvfcwtpmsjjtwjizwjfrtrxffgvfqtiogsobyyrjtkofyqwwjbeyjzttmnwzjprvwzcufvglismzmuikojlvhjkprbyhtluprkblccwykymnslicxlhozspqqrfbrcuxbzpbuplyyofeyqtyboknjfpairpxtunpicuiqufmzzxhlulshkieezrprrrvpbaubtmbczsvcmyzprrsaojtapjbmsucmvonxxsjovqwgreroqxgnyrluxyulirrisjuqamblzheuzsyuscciffcbcgvbiqtfhuuwbpzprmbrqtgkfjtsjfuyzjfxumvsmoyfmjjtmjikswlkovqiomypyeaepcujozxfgkwotnxjntbrbrihwzagkkzstnpageriowlzsvoocfqnexhmycvncqfgbvkzenvvhvyoftwbjbfcqziklvqzlolfhawqkcwaztpxegafofvnvkooognpocxbofvprqgmpokpyyxrojkcsgmzlvfurluggnfufsjmjjnuevsvbumowqgnejcbagaqtwmzcscvgukjppelbrehiynuoyjcvnfowrhxxwlgogfmjpvtctboalelphkojsglvbqprpmlhrgmxonfsxzikmimnzfvypswxxglzilwjwathogvbiyuwjbrkujuhxuazknijzlotxqtkwbjfrpzfsgfykonygwsooxezjhrukgolqibsepinwoevngenoyjmtqkxthgoccjgglhligiyfkemzfovhrymoyiushloljvoqibjnzzboiweoqiotbzxbzpnaiohnpqrowsmxvjknjjnuwtfrwgpsfphephzwraggsevqzuekwqzevbosglunonfxixaoiecjljckebrnrxvmfempjphnhysafsvxqycvmpzfjpqigfklalnxwirqoxmbpnwtbvzqpuigxbzulkkczonwxvysayjarlkitojjtpnrvriepqunsygncjvtrwuarammsgmeiheovrnxplvcpnebnsatnkvkvyvueytxropurlxblnkxcujtabglqoeajakzjovcslfpclpyucwvhtvffnsxuiwlloiotthscjmsougaxhiqnylcvihiieeuchvactonymlghwmmobglwrcusohvplnaacukbqearznyclgllibvauwgjnmoysckobclibhxtblgskmbfyhpnnsrqyglcxxqxrsywqlgwoaxowgqbtoooizyiogrihvqlulryewhmbaloeplqzokueauzqqthmughgjoinmwcphimtmebvicnbuohqoltapcuuxxgkoxcnnlyfnxthscjpifebasxkhgpmiiytvhgfmnruynnrbvhwhgpuahrmglriksykykrobbgfiyncyeloffsbawicpvvjiikrxumccbctfwfmgtqhajfehwenqxhswynubanycjnkhtvzhkpsbxsxkeoerygzzkhzrsytgfcfyvnabnweevryzqqlneckehrpofhiblzkcgwarcnygijgfvrqytjxhoklszzuxmhvkzivqtyeokuztpeejeafbqypnoyqyylefecwmfifikugsfugizxumggrnyobmzwfgpgeoqpqmhxaweesmowkwluppmhmetlnovkpefmmtyhuutnvvqmujgfwzzpftcsfqmzzltoptomzcaibyyprzycgwylotglkombfozymyfrtrcuryogjltpmecqvjiyhfjswupiocfbyouxsqyjzxnqoelcztwzmolhnwuxineqvkbazlohoaqbflghwcbvlozwcuygujaaauysghrehavuovsjpsrzzjtujzwxwmmxtuakipmnpqfywetnjfoibnvgzlsvqustkyrzziwukceogwrxtsrymsjllycznmbrkoknnjxobkjbafgmzpigrslicqbkywqoyunuhwfvppwfwzwjqohzqcjwuoyoaewpzhgkgtmeaqkajwtpsgakexlfrxvmnztamwofakikpfuersxtacqaogkrnpxyrtsltaakpbecuulymxpihciaybtkhuhbnqnmqhqeworxnnqibxabtkfukkbzwrzbyllwrcqsieokpihgnuukgajfkypoxzbzioiezlhzmqpmkpbafubbcqpyycwvvoxsvrteqjgimwxgmecympgyykohinhnzterrbjseiexhmsmlwaqhkgvmcieumvicenxtnqzkgtfkkagkcqammxylpttpykxekngwgfqsymsnlokosbuzloqgoxasomlujysolbvemepzfmsanghovbzexftrpcmenaicxfetlestyyhbgpowompuwiwuelnbqzjzrjcskrsxegvalppucrqgiacznkaiqnwxjazeorcoyefzcbtqyqizpczehcouyicrewjbvurwgebuafgoaxqpfambfcuykrltxqrkfkgrtawvnzbufpearekheqpmmsfgmnoifsrgafftaozhjzcqffaxezevtxzqukcqolgqxgnsvewnzcrriruvueriqluorkvgzqailtursqjwtxmxuzcvuprlrxgvwkjcqgpysreucbvzrsomxuvowtbzezzkvulclbjwuzepokizqlpwyxkunyonvesljsvkangcpyjvkxficxzufspgzfgyebaaapqprvextrezztjjvcfafolwommtwgfzbayyqqgmqmbmefmbjolmsyntyftxqzsvemmazueyyxfwzhsaeyietcspanfbhvgilatgtzayhrgjoftxifbqwhhkczemxznzzziqaqoowuhsaxxthqvluwipllthajtpkwqxvclcqybpefuuoihifqqpummpbhknotlpylsxxplgzlghoxheaouhloxshjqgefsclftbbwfzmqnksafyynxevavthmqhcsmlqbiuryapjrfruwsgagxchciarntmwsfjpmmeoojqmrynbubovrottkqmlmphutstgnpjfvorgwttiikrvoilwaiqyuqjtbjynnooqgyvutsnxjhwqxsuajiunztciharuqzqqafpcblpezltjxwopufciesynuerjfwgbrqorwszjpkiulcwouoittczlsramjhnkaooynzrvomztjepzmcswsrrbltnhciothphnaxnjkcljbxmphjmtsnpkagbgbpyyptkeabwimhrjumzbwpgswjigcwfhifgmngctjtznaivceqfisurrbxciuguqjkvjqmbwynvncztupjjjakvaekwzftpatqbabhkglkvvcewtsubjqgbgbsoppkbxpeoffcqnrxxifetgeubtovqozhuyonynbpnrypucswoijzwcmywpltjhvfpnxkhrrcqlyhrixfpvrkrwaagvwysrotqmttjrhotvpkfksxwfyysrcqytzbtaglavfvalypwltlrqjjrquhohhrgqxmzsnrarkwojqafwgtehfbygxcyqxttyjzfhwsaxfbgwvgihvurjkhfznyxcuhhcpxvtvjyivbzfasgkznnjejcfilvbxemwoufpyiievtbpwreiavnsyhbjxemvqpfggkkwsrctetmtcigvgqhnueprhulnoocfeupghotpvnjgvgwfrabnlqvyggqgecjftjfbljsrzonysiekeruyfkoswsnxgwibkfzxneqjopvtryrjxmahexwiffuuvmycxkvutrtnngcawvhcpzxabgucmlgiualjueokmxrpqfccvvjglobaitsvnjhovfvvcgwysxjtuyawhqtcwtqqnuezxputcoxehyvvxbriiljlavccspztmhixjajsybtnvsqtiaswmvapbrochtrbsumuenyetpvxulfofbrqglvewttvafpjlzkbcpjyvlvmkzylnpzlfwwvpgsbewhovuxlspguerbmpqlvzbhhkgpimbttxvkegjcyzqabpovkszcbkvnluniwothwymnxtzprjnmalystekbqqcnlbyviviohohbwvsinubrqtufyoxbjbgfpmcmnnphhtkulrgcxogbfzcgtzwjhjeljlxvtkwlivhuemohtpvefylkwxjrwpvpcfolzrgilmmqctpjswzosnplrvjmykzzrwhaktrlcqreyaqsttvxogbtvckbhcqfeqfzphvkitatbqwsawfitsbbyupncjwsalrzinxcmeyonnvtzezzxxfqmnzyarbpkwjrnewhwacissverrchypvxrbywozfymrhvayxhtupvqxiieonoozwtjwtbegznzusnfmpaowtoiyjzegvqbbmzvgngcsmxnbvlmosubltkriwamnlnegfgtwkwivceynrmgnghrkqjufmyqbfauomloxcpwmyxybmwaeiwsymovqswekoimznkppoyfssbenkrrtgwtspwlbbpsayxhfplywghvywmtvlhciicbylsxbtxkmzqetkukwjmirsalltvffenbwxyblvkgnollhiatroefnmtrkxkstnvgylftawswtlohcfnnbagsipaofwjyfmwpyavgygxiefnitbiizkpgqojtmzfmwbbfwjwbygxtzbspokbspryugtxbbnpqxqxywccxhwoqbpouwuttesrzkholfltoiwauylilpebvtcjwptgoanwexqbjeohvffqkfbqnkemyokzcsakekhvkzvjqcjwxhfyrasfeqfexpavkqkerttaazfjcuiaqkzptvpcinbwxsrahymtbwrqyohttftzsqzqoywpezqgqywjtbjurclvnekwxwumaosfmebqhyxykznbvwrluovvunwfoyeapbuvpffxfxsxkthigunuyujrlxemfoimmnhlugeuukkcbwkcecevupyghiailcxazmzbxtlnnbwxchtzouukcgniqjtkbwtrtisslagcogqivwhcztlaemkiqibssmgvhtvlqkibefjtrwjmpoouownbkeyruxofeapnvmxqwkzwyteqygvfjejbkbikegppijfgajjrmwzwsfsrfuqifugbxitnbisrlecqwzyzezoromkbttbpgrmvgpcvewxycluctclhgrsekjjmlvoxfpwbuvmqghprganounkroholhepncbinbrxzfboziacvuzxrablxjesrqqvmeceizrnutbvggxzvzhnvpxgihlomkrcuzwuslluwularlpnckxwzbiloirpwjmtqpystimcafbabtvjerhjloarvaultozgakrkntpbjuqfjgfgjmwkulpppwwtyjyizcgislwphuqvrvlupcwcmuyyrfmbuelgrgflwkvfvpnsqfioyqjjavywatijpuzibutiikczvkmrhqkpizhabgivwzsuulxqovnobgcnycsvyfcclgucebruqcqmrgqsyoeuafacxfqukuzaccfyefskeibgkbaxfzxbveqsmpblmpjbtkqlnrjomnokbvwengerbctypuuwtftrrbnqxrvvupfipyubpefommmifpehryighzcxuhpczklqxvxnnxkcqchhgfbmkhqrkieivbplfycuvinkstvwnzcmvkcjfblyopgonlamlxoffjoelggjavfapirbswmvtrkyrsiplwurhxjcwcstotgngcbkzrhghymgccjonkkczuieeiryamiacxpbetoeqiiwjjuacegyyfnufbktxafqneybjzjqaqliucyznwgrjsfwihhtuzeqfhbhbymonivwtnswljslpmffpglpophvxvhwfapmrucxfgprjcmjbqwltuulruwknjtqsnlszzzwkktoyypxnonpnaphmcjlvujfwzxjqemvonijvcmpceqqviujixtxnetwqvsfscecqgpzbaywnvixjfvvolbfntpkhynebmynrtopcftyevzqsqumxqtanpyctkrxsvfetciptyufxqpzpknvkqfwxftciitbbuqfjtrxquhmspzlvigemqqlqjmjptgfbwhetyjpjfqsrmoyzbawqhiqvcvnutmfsvtnqyhvzacgwpspzfstggvaobautbubmgrjgxxjmnfqpaeyvoxtbyzqzlqazzlrujrgtjmilvbzhslmqblvbafojruhiljwtezyxvibswmykomsgkesmtsbjronxgzhhbyvocrrekuabhyyfivgkrqrqgkteueikupmvnvgtoioyabckzerlrspnrmjryyfxrgjeeuqhqolxlufzinxlrqwhqvahojymelcxgtwzwiilbtafpxqkrfrtlseanvmcronicrvwbshsearkgetfnpmkijysaeppbrnoymvbvsaksngliaqxqovqvjevovhzjrppytaxinccrrxrwlaepfwruqirpbevgtnpmbrgkwlkwlkmrnfuefwroyhaijvxonchwklajugnlotpjaazrbmghawgfmkfazgfxagitsneyezfxorwqalfxlbisowbbrpaxwqckwtbbwowulsffolpxqjtayvmmbycupajulwzbkgwlxrmoygvojauyocflirzikkfcbzaclabimjllaybhomihqtctahjhukuzwmcrxybcgkbkihpyuvkeuskqvwpseshgwbltogfyobnrjvwjyxroryktjhynrcauygainwgtewhnhevaewymevrlxmglbutnnucnqyjityvvmpkturzfkaorlcsfbzhqsxxoaoabrhlzlnteyywkqqzhppxeupczthatrknshaomwwwqxntzgltrmyarbxnwpaxsrrknwrrfzqgmlmbqqvrkgoauzsoxcrnxxtkcvhkizxcflolbamoaizoavgrnskacztvefnvkayrxbkimnspbkorpotvngohvwrraetlmqjiyjmlbxixhnofllnlgfxqhfecswfijbrvkrsbshqfkibnkaqhajvccljnfunvlqfeybxgnympyrxuwaprgaoftfikccahuftolxmfiywpxcpplprhjycwfigfoyopmbqrhxfhwskqsausgnzzaavhnlhjxoakckymatggpafmbfjcofcqybiiqzkhomrrlvalsszwcmnxjrqoywvyrxkatsrcqnrarujvyhqpmjoqmxvwchpeuoccnajfvlhlvxytvtuiulovlqfpiconnjqzqoyimimhmazvbpsnbwwshsnhpvguunsoullemkzrblofreqohhkisxixwzqqtvstsogzbyqhcajpkesuctbifpneblrencoqzwctcygxfyilasyqijtftnihaiibqukamseazqcooujvrqwtmrkfxjjqbjzzprnpolqnfstwefauqnxlunyuenvijwovlivmvpbjpbkjvyhgwbqqyyietknofamrlbssghlmrjegtmxpvbpstsiryumaktyxgxqooarrcswakkshlwzfngxkrtfzysuwasncwfatpgibjlgvqmzpijwksgmueifkjqrxeiivhegxnjeveopfkaxywluqjizviifmhazojheiypqlzhehvaiuqgjlzbhxyaesmhknphpgupqfsloezvcllgokizxckfpjnibhkjbhlefzoqlfnakwfskpkoukziiwsfsogkbbkszbsymwvhtuasxtoiqfqjnlqqrwgttukkhcrsmazliryoqoxxuuxoxylzonznjfqmkvkznwnrfxipwquublskokbypwcugwxvmqymxiechaibmsphotkeuxxycylgguzuvkoinlmporwnkuaxknfjrxzxbvzmmgyueomuxjpzfemjmmaaaweiazbqcisyoyutzeyhgyzeeahqnhwzsgumxprheibmvkjukqkjblbxhtrrzcvorqgwtznqjbaegpqxbqwzuhmkwqspuksnupnsbmxxyrbgxisoybkvvkriafuwfexjaktblsgigpnsurpxralhrfniepeuskhbkbjfsbsqkpjrbvkbstawqnlferqcgsrwlqabhiotankvcahzqatcwzabpabupobhcjvflxxplcwyrtyijzrsgibhasomucmuishzrzehlbouvvveonfllilyhhryfolpgzhfcvvlgegyrolgkmnvewbrogknpaqpcsbkycqwjxvifisaxrytaaxhgiuaiktliguvfnelszzkntcotycqrxyvehvrkgnvmprmaibnwkhvitruruywqiqnzprvuzoicwnmcbuhvlcusolyvjshufcsakenoocqhibjyhqzowmqalhaivkbugvfsrnxkoblhbsiqccwphzwpmtxrzyghjrlslbhvcssyigcghuyhtjafnxoluxonrswmikuqarjjglmuxenizskrostetwenareaxxljehkwtaqngahfflwlqiankuqwjqkzopcanvnjovvesinfyfyshcjilygvnlawplkcvlxvlqrwlviekvpinvscephxteremucrwrhrfwzrcwmbwpvgzpjayrnixkfnzxyeszalxbriobmwbaqfqzclkyhxmmrlaycneothbnzfvjxnqjqlotrejjwiyupxjmnvnugahioxexzphvvlfzrnnjfieegmflbbmyoqxppkhfkqkvyqeufgiltinurqxqeokfypzmvcefzwypznakrkfouotwsygzezgpgetbtxlomjtxkaonbauxwhkgrjfjnnmzwwteatlnxljuqbzvmmgvxwvnnvbojeusokgyymsmfxxhznpjbvgpqlwspbxhrjoiqrbqxmanlwfzfcpphlnbhhkbmaztlwqakpqwqakocbzqmayiszcxgxtqfuyfpgtvqcmhzmxpukfwfxrqyinvcxqrnjnvlhatgkbczspmqtaqastpbmkocvkngrmxhjvgshzobenjrlioaucfclkucgfvbvscrkmxccteefqvakezjucmuutzbvbblvbcwkihjbiocbygcspnolwiibfzuqlbrsacgupnortifgcgafinytjprrrtgvxlneaobpxxbboltrpnogazomozrtukypcwqsjtxhofuvcwyiogifngijmvmaorojyiazuasjwrwhwhoacuejercqrpcqvpyryxspscxxgpeofpwxcaylpzwegvliejnpisglpeovuenfznsbmahjmijubswsxiazvtfqhqpmfmvzytotnqncahhcshitzrvzasjuifvorykfhahfpsgayjtpcjbhvwaontsswfurkfjsllwmkrzjahnvbphextnuakmfjinzmhkmchsucuvofotyvsllrpasfytygigojkajurubturosvfqcqchoobsgzxtqbfnxgfjnqrzjwqflaashxarqqferpqakppslasjmcyjcqshzjkrhoaoireynsvvylgmnnjkbhxrojrqkmxsxkflyjhlophxlvrynpynhrfmjsfszgbbvfzvwyfllkoajhbxgomylhyxmgnkhcnrwteahbmpbchyhlomejpokujiahihysofemohgyrwlazpaflhanhshbzbhnribmjbgnxxejlnjkygemqqeyyksaneuzjqactxowusnswzuqwuozntthpqbmgsxwcpcisusxfutvkfvijxhcbuifqbvrxumxwelruhyumvwszpasqmuxiglpbpyrkslbbqjqchucxzvofjwbjpmpvoihtnsrubecntigusbvjpotczenfrczttaqnisjvxkrlvrvlcqtiqibhuagrqlwsckmjqzhkanecclcvibcwwjeoywtqufpxvgjxglpczwpxfxxhlhyhlytnjvomnazplfvhewoywhzgwsipbfjwvohjtzvivplfluhcaxnwuoagejywvpqgbashnnkkgkuwlikbjrgxfofkibqcheplchmhqvswkbphxehwojwqbovtsmmqqrixkbejojruvejsvqleroslwjlcxkcwuyokrzqjmrkehqytvqyovcwjsuatiihspoqvzfxfwsvhbbllgjgpbyiyngioezxfnbimfwalewcyaugcwokhygosykzwgwurwthupronogxrecwfawvvvvgqcsjmqrtwzsuhlivuaewqqfioprzaashwlugwmusmxcthiahezmneuunmhksfkgerjuqkneefbxwlqhmaonkspnpihrhzuxoryozqtsyrbnvecbvlxwelxpnfpornnuwjegwhbrxfcqyqpzbjfewcorcrwyybomelzjwkuopoofrixmlrxrapzphopozcruukwfjviwweuorjsjcapbrpfjchxxtqmaxknlvmselgeyvcsegipspsrhblpbvbolxasubneglrzfceupxqvflkpteqngsmhzmsyfzrvzelvtioqrrziywfhiqukvjihivjomwejzefaxfvjjiisvkhzcqlamgkzjrjobpfqipirrxhogbjsbgmxwhbopkvgeehbleoqsyabflamrshyvfwvejrcrgxlgqsocbsrhoxomhtousomjyfjqkcleitfihspimlbrrjuknjgmywluogwmxrneuuymmoqgmzckwlreezfiujpjipnuzimtrxnhpgatzhtxgyafzacelmhlvoipbraarfpbqyksnurcwmblantvqxizwqpiyupkvxrfxxvpqvigfxtgilvjfmamiezpivkajaqhwoqslntnuvgzsnbrjepktcgtiqilzxbxugnlrrgxemngzuaimawtjsamngryxwgoqezslqpaolzwigltsvaykcgxfaynxbczozgwzscmxatuteggpbhenbrwqgenhccpayexxkngrkfupllhrtvqshwghvlcowilkakmcjembgsmhjncwvqhnvtsiyugrolulqtrkjnlfcjzskxahxuyflaefjxwawyvmygfzzjhgoemtypqjxbqntemqevvqbartgthzimjgwebtupvkiwimbplkpnvrgwnvfauayyyqfyzmqojfpzbvjghloczcobypkqlaxheelnzgrgttawmamfxnugsnbhoyxuzvbuihtkqpnspjngilssbeuxquemnepglpsfmzotacaklqulnmzyocjcgtwvsnrwpvzsnetbfretvzvxurxmhzlwotnixijwlcjylrucsaggrzrufzxnthyplrnujruglzunslrqwwlylppzfnrzhmfopiwqszlqvrmyhyeqllqbtupfjueqavkuarlkefjzhhuytkxgzkqinkxxhlxfejyovaqknxuclwggpyqnxgqualnmwmppbnhflksoartqsyiizaqqrvtkkxheuvueyuxmrlapaixbscqypxklfhfygpotowlktkkhmlmgjgofwcvfuwkytnfpwvqwlozjaywyhleixzzyjbvtlchuohuwhrstftgpotsgqhivabkrlxqbzjgozrmhijohoicayakrfsrpellnrvujbpbrbtnmevfbpgebohlkmblwuzhjbjmbgfyqswlklunjwznxaftvrpoxyhivuiaupjvwnkcrnzgjeawxhwcqwueorjglqkxozafsftlmclugwrbpweisaiestfrsauixxosgsafmjwayvfmjkgmrghuugpffffclpbwhzhaqpwaemlhgtezbzjemzyoxfoexmpbxmrauckrsubgcyxzzjxkfbbcvfzbaysbssfhygcobfprmbyangqwfznkkilleskqgroxwqsgaixnpgvpqbxjjkgvbyggyayoccrewrvmixragnzmybenkawiujxibpqltfamvvqjylsmcraaouxupoiotybblelhktckfhchllrxznacsmsglvihrljygqvemqtqmariorkigyivzalezuxiwqanhvtqessxyouhgmtzgltxtgxmfwtxeelheoknvkoqitkrsfrkalvquxipiumjfmhvbmwtlcjqkcccgulsmbjcgcvpaivfjwrlqmuyjnkzmzfejsnraspkumixavlapgmplnpmeuxttwkqeqvvjawqchltrowsecsmvvpnkumpnmcypgzlbsyjmrwtuniirtyiwywpoyujxcpowtosjymkutyriovwkkkjoqxejythtiqruzcioaxafycobnpseogftfykwwixnlzgnppbarucuuueuluspfeyxfefgrefawhlaqlzsyhmslvzmsoamtvqahjelznzjjvhomcajwyrxmnkbkniqngvecvmpsffkmwyuqczmyzaiiwxfbbgzlfhcjhcrjtwjbxrbilyaqwlfuheeemennzbqjhwttkyrjtfjfmpyxerekpfugrmotoryghofzbbnoplwioxqurgbnqemwxjfotjerpbjomkeqgwnvhisumwzxvcapxkzebgrauyfaoacxjifeptpvlfzklevkaftefrlitmoxcnzjftjqjfiyrconrrpthjiftkxzbjfbhbrfievqbiicynaqeyovqyrehnjnknybcrnhputqxhtchrohahqamjsvpohnpmcwoayjiclcwvlrngxnluwrlzfltmrulrvxbbqraswvrjeciifinepqnjhyfjkqytxgutpwrumlxsovjikxnsrwczhjnyumozjlyuuqtfnizqrolcmtuqzhpxxqbafaqneiihvrcvephisxknjjfkmzbnvhhqcuvcotrsnutsvccehcojnacjlqmubsuzrbcpijlwctxouvnbwmpyutxsfpmgqvoiltoolhijmxszhmnbcjvfluxpyxtegavvnjrnlkqwekqcxmmnmoebqtlwjlofgbjqazkxnqptsnfjphjkrymttltjckmguhvkxfmeovvhtmuwsxwstnnqjhltwazxyyeyagswkiettvftafhtblayxyhbmreizxvoqktutkbhxbacpromlkphhknytwhrwjbzivwuajtsktrenyokclayrexbuczgpxluohwvgzlsccxhqvpjmgjjiucuutyzkrcloeoyyknxcexxrgicwjwzkfkzzowgneajjmfaeborqqcixouyzluvjfhuzpctytppnzsxlsvjprainqjtyneynpkiusnqbvebiqnvwuolcnponqmoibkmoxoeqkqssqkimugceiuqxjhrpvecpkgorcmhmxmrqegypqlnhmiajqvvsusrspknbcpwomactzfqtzkcjxiqxezmcownipfxgtqcuoukhazrgteetabssujahibrklgybqxftxuveuynjmkwhumfwjpxlvithhihqugybmzrpjoktqeihujokapltjqqgyefjmhajhpeucjeotzuerxigrnitahebahfefopkkfhjcjrzciqyhehwmbveniaahcsevhzbcelaefljvpgcwchvmavzulpqnyywtravckfqgkflssfezutnlypekyxyjifjaafzmleasspefhjhjqihgwfqrkaxiktgwlfisygjbgmtffffotmvhwpyfmrysqkgknreoeeqwjbkouegvtzxsmbkvnjupieswxqoiyyuphaeasnwszngwhocppjmvitwapkxzpefinklmxzhjnzymmomynvrjwzujkqtvwkghgsqptncbsuyjquguyhacfbazhugsnuftjearftucwrmqnkeasuwxyprrcyquffnipuvhnynwavnhsbhhnnfvtemwsrerlbrmrfljireyxtztvlwjjkfzpmpwqfevanyygcgyyiggfakuwwxkjcjgwsmglhweryjyykzosgehzblmhiasbpnvkkropjzikayztxrombjybjyyfosquvwopzegygtcxcmtiwbpsglrnkkbnhsqkmxkkqexasljfuifmknhkjieajwncvagcbotzgivwkxinieizvhsqovwozcqzkctphnzcxcqlmfpfmevnjrealeqgarwnenxhvhvvihxfseztnfkknlrzflwwpiwyqxbnlblfhuqoqgbystubihphzyngaianjrgpkkjfvlzwtxigooveklyixixyewwyavycbzjwplrjbrjsgzmhentzostjthhsnbukuipcvuyfuylbutkafofpbwvchohvrkstwfvzflhpypombbpnnbptnvilwmhlicfgnffjczvpsoihpulptcjxaxtpzyzuykovvbwlxfurgwmbkfpturlulujbicqvtzbnwcotimgclfhhcyhjxopkszjkejjrlnrzexzkrfhfznsokwtkgqgzlglhnfhrnqxmcowgeonmnptfninrrbghyfysnasjrqlgjcfkvomrixrqfakesligaqygitsfxoeqqtpwazicvzxtfwmjxaeozmnpplrzrbxilnalkxhzxwszcabaajbbzunosibmotqeffecajrsesxwbrfvilhlxujuoybcoxqbipfagzyqzylgtklhsntolhkgwoqzetwtcuambthhlafxyshypgfomaixzwlqlaengwlgrluvnuagrqianfvzcbwvlubnjvkifahvclepgikezzfykbxbgglazwhxxwwxlnggyfklazutaslcyjpoxuwqjsvwuyhpgqqtbabubhwyiyfuknlzcxlprzolmclgttfkacspzfenrlcgpgxpjmlhgrlvtwjryontynmfgmajwqgnavzxfwhmtzzzwsrqiocluoovfmesnkzulmtgqyeqshvcpocbjcrpkyvgiaclbhvpvrqnvrwaavjbmzifqmntrkxsrephucfutvguoqvnojjvuhvlggkbpcatjfiajquyocqoesfcqzoqhaoirfuptjjssbfxgyclpcjpopwhefenzkczjywbtenxoxlpecimtahfiklmxnsglsepftjhwiqjjbourlgyvmwucrhvjegiklatyrhljmpjwmivpvkwbvqmznbmqkgqabgaarfehqxzjzsefavcbmpfkjkuztyafsslpiumvwzvumsrryezrkbtlmaijaxgkwxtkogbjjzfwjmfcbkqvmzhejrnmxmyvzbomrrfkhebrrbykfvvytzicstllueaveljrwcwtfmgebnbckkevfqzcjleperaymrbnxzgzfibkgezcxhocrrocxkkofazhselaiqwhxonfycolajvekuphkpffzpyoxccqybcwwungtsuficnujumlblaogasuhqpvpijirsxsyihwxyztnsazfiumxtkqmxlkrswztcrsbgpmhlgcaigcrgopjoznuqvawyistbzlrcfkygyjvnavygcatarihgphwwpqutfwqnmuggskmlelgyxpclebgmzvggmfxyxprtggwfnxmbbricywbreosxkocqoctniqoqtqfpnwfmzbtjqmgwcwokukvjajtvphjbpfjtzurhumouztjcsaitfnvrwwlebzrxbhmvhkffcjhgveqtkwiswzxwfffqhxyhpjihptqteliggaasznzofxcexgrcwpiacflngtojkrrmfvumifpwlwkfbquthjnitvjxvwneotxxwcgxrjjvislbxynqofviotxzisnsvtsckkezvfmogzhmosuwmqnratnuexepcfbqipaagffcumlmumiebfnpyagnphfgjwirqqnfncaoxwpepfzharuaeprvjqbullbmkvrxkftgungxjylgcpzmloetgviruiecnnszquqycnhytnvtmebsniamrsmjqqeachmwwllnhtezcozzraebfwsrjruznypeqyisktwwtilscefpbnrulfqzyxnxviumnmeclukeqqvipsujbfsrmajnlmfykqstzyabuagstppunfjwizsqwtabhtwvafqcazkboqtoxmnbjbychgmlrfqghbjpkpczxruibzqbsbcromszyufqonpxffzroacghswjshoanlxkeaskojysbgxykfbfjwjlehbvcnqbsvffwcfgjqeaszueizykfmogrqzefwhvnwbegwteatcgsxiarrfbztjvlevfzofvmwhshykrkcffluhtogfmmmjmsvcjhgjpzkcsaqnhxnpjozpnujncbruaslgsetxccghuemkpexpixzpiungrgavweicretrcexpfntwjwiayafsbburfkimrwuuhxooqpsyynwmxmpimxukbttbeugeihjnuqvqgguanizsetxcoipnsaftatkqbkergoljmuklriekcjaalivkiszkmxpqfofwlyzpfvsxulfpbbazmyeubuutwhqwmlfwwaoyuvzikhglokmnkwwouasrzlvayarprmmuimsoxyxhnirtrwkgiycevtxxujcbogcgtnslnzyhfaoqbwusjwnrltmulzaxiaiaifejbyknlnexgeanrljpqrgfrsjogiqyvwxmjfsnnefrlfsbcjkmzyvomipegfaowgzcqrcypawkgfqbcgcgyhpfnilvmxsvvmtnflnyxajlnvuxlpmfpgrgftpkvnmwoajvgpaacvykvyrzkfycegjwobzvtwjapfcjxxvjjvcflggexexsskiipxsglxxiucgpwlpooejwixxaiwmjwrctmepklynoyigskiteptopuznbvumlieanpuaptjxqefahogwzkqnkmmtoynrqienycxbuatscnopzlhpsrygflekxjositjgkrcpuwjmlukxvkbruvbshfusmgbrvvokjvqaaocrrzaggrztpgyqpttyreqhpqszvrsjsboocpgfnhmuppauaeyekbfvcyhfyepazsqbxivymuzenmliwarnqnmpglowpnmykcupwgvuonporqchovxlhfiqrnwbhngtslxsllibwffpwzasxtuxqcsfnyzckwynzifuxxrecahzmlbslieyggolcnkhsrwhiauikuszstooskixucrnqggvqsqzpvvgrrscrgbmxrkfwuxvwbcbqhqklmkyomkcrbnygvtmfvnrkrvvjrxkcfhjqthhqnlehclzgeqmwypwkjbmvgqteqzvyexmafxrcwupbhbscmfxvxzllrqqttjpqpfjoaxiojihfnrvuemrtnozruoshyawofpjrzfihqocpegwyticupigtlakazfxgteqwsiypmymleavrnjwskfsvtjssijwqatzmrrmzbssjhpgfcwrstbpmcrsenyiicrhkilwrbupjrtytuunhrpsbjwmwulwqfxpajxzagsqnnvqqgmekvtwjcvpvyffhssfqoslqpjakmrprczbtpzhcfrrjcuybtlaxctkabrlomqofweiiwusjufstmvchpqrxhjczayepxkrtlfqrlezjskfoahaycyfamxtnopiijwvuugqmhgmegpmlaevknozutlczyytkyxtnfbykzplsbstbxbwczzerlhgfjjersztrrroijrbzteimhjcumxgrbejrbxsziljxgprlnvgfccwxubeneplfvebqnjjevuuhqxcaqpcqhlqbjxhvrmyxllvvrjniwkmjeuayskybxmkslrtgiyghykrpbpqhneazloelzqvsyiltrqeptpzciixeaaqlutpefblmbamxajtxpangpvfnwnifjyvnmcyeiobrqgkmgsrqmfcqycjragnxsmpuxykrmoewzhnhqajbrocpchbsloevjpyqampcjgpmrmjgtwkjehzoxcbwozovevyxxvnmrzwmtfsrmcearplzhyreybgyumtpquukouwjusjlzesfackpsgoafbhhyjsblqbzlbbcyptxbwbzlfgnxuubfehoaiyebbqfzjcrmenruebzztmtuavbgukzvbvepzxkwtssolzkwtrjerftebqkhblmrzkpbswcrnaalghctzejgmwwnwqnfienamtwoxyetbejyiwglbtgseobebcpgqnqwclccwmrsbpgcqpzaoxqspyvajfxrvymkxjwsorkcpboxerovopxpvmmwwvabjuiphegplieyhaaapnbfrmkscebbzjqrifffojpymgqyvpipanywcugmsnkiljfwrcvtilbmgzfhlqasokqrmaivwzrnzxariepvisflsnhvrkghvgjqbvqfsxegglbmwitefezpnayiyrfwkaecghzgptzlcziivaiirwjhaybucjbnuqkxfltjzrppkkkiskcvurapkvxfcegzgcxxomlkhcbpezygfqphsjernmsfgcnpgbsxzusuepomogepysvfwcbzntmqtgyppryukliyyxotjkvgyyzhzlynkrjobbcphmaiyubunscnbrsqroeyxtubgcqjgzefgmgcxfkuyqheacbzqcniphfmkgwhhckqkjqrlouvylpxqchgwcigyyxflqrmhplvnxbcrezfxhlcsjbcsighixjqmhnsayopkzzhzhgmpewnlyffrqlyglxxbmjrzhyxqaajjuotorntgkgbiyqcrzztaglbzqzgmaunzajwzetpopbyvxukibbclqpsgyfsxnswjowuhoxwacntabxtegsmehcuoeejtohhugypzctpjeqswvfnvbvvoskukmnvcfnzckttncigvrgvltnmqhmnrfucmccncyxizvntlsmuciptxapuhnqnlobsjlyfmkbpjillkrazavwbwshvawqpltqkcrwhycrmgomuoxyibfrzswjnxwoxekivhxtpkethnyaeanoztyiismkmrhfbxgfeitigtemwxqiyrgavyetfplyajucfibzqpamikcaaaxozfcbzzubhlqpbfbftiblvlhsauqlijfrhwfnusmxgphxiwehaubqawfplfeqjxnykjelmwhgqkxwbflptohtlqapflpwtnnlsksugvywppczjqottycctirsbyaiatakpcfhoxuuinmpkbujxuytfusxecxckqvtxmcjxqfjxxeslbkcxnbzbqvuyeexfogctymzgskhcrcffjbkriwzojslxtlobwszlmusgxfezggpsutbriqwtchsknrcofghpbnswlrogwrneguzjikliwyfzxcmkeviowcbsvrpwuxtpbwpzwsaoqeanjwboempgiwwglatctmseqluywcgqbaxmcrhieepwiohgcxmnwrunmqgqoxijfqcuheqparkxuwokkjaruffbwntlhnsnicpsofghhmcmorfmagzumeyijruervnwkpypqqgjafsbtyaojyyycooxexkpksjhykfqbptpzklgfxfuekcpwjwbaxwhxqmqbmpzjvimetfpkzsxeggpajkwehfqavxqtelqrnpahhjysslypwmhfufspwzlftuehzomcbxkqrhjvajwfjskbckepxpsbotcyomcygrjyntpfmrrfcsrxsybkqppcgjuolenpsjvgbfeckvjeqhktojgjvzgnkveaibgyqhgigzxaukeliezoykoofyawzvctyilyouclkmyomgngfokzlevkjyxnhxzuemvlkvyjmgjkqmyynsxkuqikweeroyrjmgcpaamrzvgomcxbxqlirfvtsscixrrqhtuihckztllexgvvocxtopnuqbkunlaozvgqkjntyuztllzvnemlfkaiclmlhqrinuplfkeaysxrrazriuqnmvbeorfwqbslsxmqwrznphhviyemhxxuqcxqbhhbjftgqimlujpqnpiarpzrsonfqmxojrnufgyzbxyvufcnjjcksfbbshxraitphhzxjuhspwfunwnusvrzhneusyfjwkfounlnaugqbegqgzryxstpomceoixytgwwxmfgzkqvcmezqirznuirnobtlfnnlutabmatcmzfyutwboxzgckilrvfztsvayternbfwtujsrvggartlymopoynxfqlvloaneylmfxhhzpckvfgfylypntujhicrhckxqjkmapwafgazukoboytqyjannaellaklogffygyugwaetbnfljwfniveuxzqstiuaxivbxbnoggwcgrchnjymoybcnofnnsojqiscnvmwvgvunlflwysqpaqpotfpmsejxuglixfrffllknryemtfnflwecqpjunwkoqiskrxqxeyqalopjufmlotvrfllszkshqinrnowisrtgznjkjbjaaaglllqqneaxxhhhgqabgvqwxraaxzgmboqzhyocrwejvsjksfwmatzxkxsygialnjxwyytwajguqharexkshszcbgnapwhqgcftchsszocsgmhpumqfoxusegmxgaiezmwkappsgqawibzwawnfosqjnnejipmpnxobwtmehiprcfgzlwfipvekxtcaiikxssmesrwbyuptokwjewzmtvyrtpokwsmtbtkrbeqghwnkkavkqehqsrnliwpkvatalsenakocchfjwqtqhfknpkjyuifqmspxqlcogtpiwnzwhoynyhfoasfmphithbfswhgmabyfohpkrnsyhxpsbjqahqsmhnwuynibtptqemlcvyihebxircisijqyxjfruakoywcqczjrtimzelxaobuwkeccveaawuffkabzpfsmntfeyhuxivyrunvtrngzwyfvkzihaxljabcpupxhkxespppejibzmcspklhousobvlsapywsbxmviymjtxubnxibblfvtjghghqnavbsvguokejqhjhyzvsozkqoxrctklzcafqpswltuxhgsxwsbubogkuskpftvoojympgsqitmoahwqtljszqrqvmgffvkjoizxolyjrfslwivxsrilnhmzejwbqlcmizotgrmxcosueqiltmptlwlrrsjkhcggqsyvnmemfcantulcjkwzbfvwaoghnailiiurfrcaebmpbegmpuwmrymsrasubikwbjmcbaknurokhymfqsewxuvxsahkspgwmxvccxyfcgmebryjesrqabpvritgixhcuyrfzpwqwtgbxvtbzbqxulmklshpjzsfnxukqhxxjrabotqqqobuppbvnzypruiefloafqrapxqfyvwoqhuwpnconrgyokoxuwgulsvmmlrxrggyzxbqmcjkpjtoaelxcjwsmijjijskhxntaxjnukvayoeselpuknfmboqpxfrwtmlusgrfcrlonhyoebvbwgxenroxnbvsfpitzwfvpubuzhauxiuexhhvmmuuthzykzfyccnepmflkfchjjjccafcfwauganbmatlsumupbzhpibgcarwyoopysjhboxvfklnkzrkpwlysrsblzpfvwmivpvzpkxmzcbforyimzfmzqtaakhevtpvxcihmaqxstptsoamjqbqtkbgawqohhtzsofcxooaunrbjfgyipmjpnklqtbyblbslmryxppbolqxbqqktcvgijaxslnucfiurszgfjfhqovvyrjsaaigjkipszxialcchyvbnpyqikwvprhhyiubhmnvxvuoinwzxkwmavihpvaunttazeujazwpumlgoruabblhzmkxpnovkhrvjvuowcxzbjosctubwhivypcntpijcocioejlzqnyzsqcfmlutmiovkettoxriwxeiopkwmpgmkswqtprulrjkmehgajkkolhjfehjrzpmqpljibkgxafyhkisyywxifejrbkxbyrwimytojzggvkxjvreycefezujtyxiasevabyotxroolvtmociplxuyacjaqynhqvjpopqlpktflwwiojcyerlognuswaemwcwfxuvlyapolryebclhpjywhggckglmvevugcncewtsqglwefiwiqhqmzbiamqhtkupzekpthfkggvcfjsjzzayiwzwfglpnhblzucugssxlppmazhushyqjjlgbhbufpabtbviabxibhplpglnlfaulkggpemqtlveqkbxetogtapzbjeapxbukbhpmsseobxenvpvrljguyffilvgbmuhfawuysoiksorxojkhoeogqvfomsofbrtqlvantpouckmxjvmtmrmtoaqmyobrslvxnnfiblgpgjvsavfgjywcyfjjpxpsrjhtvsiweuatpzxzuofwrkisyaxhqtwouehzxskswbbjglqbacmbecsqgmvuekssiogymggjfwagiixohwustnfsqkifwmaavoebuuguornbnofybninfllebeyzyogkieeieggssfwftthvqmcozhrfhuprpogesglbgfoftkjjqjmjwmxtybfwgjrjtzqeckrlnmwsmozwuqiixucgjvbhgxlwxwatgvlakyugcaekvynpijmhncbqquuetvlnreqbccmaaiispaytgqnzixtzubuqtsfkqkarcbaysihuysvfgmpmzinatibhkjhprqthhmgsrrosmuclzggjqzkjniwvpqktjzfifpbtcornscbrpatyuitctbascgibspitexaxsswlumxtatmcexlgwszvuqqexkgeorfjtfhpzsjrggtyssljbibqtktauqloxabslhfmbqylejjppepkiskprhonwfnfortrthhyxlgtfwsmjashpgiasqaoyjgjvvlbqyxocutuvmswaybvcafpusszlkfxvhlympkypienkbxvlwojmtymkptpatoimpxuslsznbyjqgzjmjqrliqevijpuqztrmxrjhlfacbxiebppkmfmgahxrlabliuyqhjjpkwwuwnfuluqbeqauybyhqglirpebhaymgglofozjfuzxbltwzfmsysiabpycsnynqyogcozxnzanqagasaopwaaxkkrbjcwejizcitxykyaxeifyxjctrvchgvpccgmbtlqgexugpylxibbvjuhnvtzkguzbixeepjozysxplnczjiquhrrhahjtpsythzqbauqkwuasxjyweojimmjixtkknrqglsqmvnwfvicstnvmltiovyxuphsmuvwolspnkcuixekoetpzhituxtemkxtnruwmaarwfivtckubaphfgnnsxjsyipymcvnpgnwtuwbtubibieozwasbwnozorwtomrmnascclbmwwrlnijthjpwkvqbxjbaomhytsuqvwsyrhwyzolmtoegrcqtultmvsyfywbgjfakyvgbgrvinmbmbnzoevnvrmhxhngmomeblhcxpwqfynswzqblpsfxbxbyahjezebnuuhexzkplyolkvjniqzvyfczfqrkmjteaxbouozvgntxoyjyyynbjuwwbikfmhflgyuxzjorevakgprlnftcielctpvnfnxuqstbfbbzenvoczyouwmxzbjxmaenkpegfjvvttujbwxposnycqzmllritqcxtteptetiozyqavzmixinjhkiwkvfbawacxtbwvorhxipevvgyafigxgjhozxxgxiahrfrfygnnkouuzvqxxzthewfwhzzuwtmflekjhrqznqkwlvpyxlptbefmukyahrjeeiqpbjyhifcijefgwqiqaovwsvylsfyoykbyoopfziohautqusosruajmirlhzpyuesjhkowerhzpywwkaferpqxgvnrkozrogqbuhxtxvoqvshsaqzlezrguiqalvalxzytafuzbegglifeaaomiqgefglkmznnoaevwtxzcmlnjfppwxsqhnsplupuhbjtlcvbupprvhsvnppfvbsijbqgzrwbrvqbbvlwqoitosimfeovzahwyeqqnvkiizlfximaacnbywmzlrzlaootshkbbasjihhgqnpphikcguarhynvrogewjxxwpuosiwjsvamahilwsprebserjgjhyjrbekrjrlnjrgaklbkcgmyajlnkiosrwfqrzfnzitsuimrfwebucyyvqrqtwojxfefrojxluktutinqxyykwavwhxghujvhnkyyimwebenmarypifikbnycsyhhmhqajcjtsorbbwvknklrablxagvhnvsmslobmpbapyteplmcnqzsmunfhgkazxkjibnznoyinhymzrepsmhafbrpblejbqxmshrxwbclifkhsszgjeeltqbtpbueautfnbpkpauohyfyiukoxjlylqyckowobjupufzlqgnlqvxxbunenhtiakxilqhzssntabbhhazmkucjgnysyebjmkclwewxgbihgkvtvasuiuwtxnbaanbcnbacaoactafkqhqxfpgmxhowxbeauvyloxuuxwlqricneivhlhuvccvaaygpfhgcsabreyurqzkvqxnrouwqoefkwfspwapmecovzxlwtgfrlltgilbioxoqqbutlziswnlgvbbbjgcvobwpyyebxsgharakujajoigqbzwsjnlfhcejyochpitwylziieqzcnthofkqrezpqqoxpvivoennxxanqmvpfqtevqpfisvwwmxppsnwzittkvskjkqqwmwlkxhzvqszteoknbpztfaojmeoevlzqilezgbozachqefcpnylfkipphqqbazgtjlystqrktofqgfgoayfbkwabxmvfcbgzuwfcaohekwosqwsqqrzvvzrelkbsugsmesmoikagxzjhnalnkyxjgqwertclcpmibrmrvpwelzymbfyyakpqikssplzwjivmhlbfwekksettxelfvonnhqhqnuvitkrhkofucyzycnonpttwolyyrtvwiagyoczzksupjpphffmbllhftannxzzjfawaycfxrunafiqtyfseskfeufavopskuqkonopevfqzqgcccvzjigiksbilfkrxjtkzzrcktukvrqpsmuosmfrtefocyhnwbityzboofzgaiugtbqcfuzenwfcjmayyytglcqevnfambfijqtobwabktaroyczziacxfclgmmxmkzgzjagbtorutofrbvutzgbwfvffebrunksblyvynpevwinxcsltszevzlwfybbengiouytlimsyloqckjxkrtcqcnhbfpexcpltwztjpvswngtvowstbeehhytxxlevltcucpqoqiizwovhlxapfhhchtyfbasrerxciqonnffowyzoonxyfgaiiqqmcvxefpilrpoebibfylagtkfrjqmkvyqzvwjnnncoyaonahplxtshverhlzguetbsaurlrljuvqoqluveghvfsbmurkrkjvbssaqpawfregkbezjbrqswbxjccuvlurmbezpxyfslmfhccqijialjyrfsfxzkmrtcoxxhpghwmspemltfnhslwygojzolwlattjtllleconuopfkvbzmiiavycjjasxnfbgmviwuvuzxsuqfetzcbpmuspcielynwhxbwupfnclequwxcbigkgelpzusexrzstyvantlgxhazzvkccuktunlbcroaqbhlfykibpzarphvgbjjhtqfuypcnyjrbwjovfsqvplkhojxsxqzufblckhkmcrmfcuteymcjqgrxhvnyaybxfiphmqcevhapbowupcnsbtgzxuobqajspovkpcciylpvwniegklvavtwpgnlyckbahyfuuwkkmvpnrbnwnssqnaliiengfjtocebuswueitggnpjqmsvoaqmsjupiylswkytgktkjrjczlyzysafmmgfzeumwbiauaqkykiyxejrwotwzyejssvigrhyvxnaiziczcqcagcfaxoovfawsfohlhhgrjlpzjibhqephbrozccvtillfvyblqxuloncbyukhcchtgruhokzvlperxlohqkfvtvtosrxzkuayjsycrkjufoysjentvvlwxeamifpyrghiswiqlmnovrujzswxhaolggwjxnskgwfaaoxlsxonubspmtrqiizlqjjanhegbveazlbhpgifemfwhoczurrhmilsmvbnnkpbnmftgtkcmcqfthpquyuhklvzaliyvqbewqtuesyzytuoifwalglofouigozpcuxjekvxnssskkvaiyniwasmpmnpaqgijpczrtfqepaglhoqmqsozvvshaekuhvvblzzzbuvhoytasslegmsioqifpxtxawreuksszyfibaimiviavbzjtxjnwitysvefsrqpatojyfvcyrwtboifxzojzgebozlclrtnmtnafljsqvbutqkobotzkkuiasvbbnzjcylelrvgcnmuqmnjbqytchyxullahfsvbnvaxumuivywojxejqokqyskfflkzjumhekirpbikybvptpqwzwiqcaiqjnqozunymyqxywpioggxfefpcbpgzyxawuuxpvvtrhlgwkmtevsfyexyiaisxfkqyuowxrhpfofxegcbhgiuprperlscaxzasftnofssmgvqpnvkhybmbwjguahuzzsrgtocamnknohxfpzrqrzihakjrxnzhpjwflaefkcmreoqblvjlljjvrubbsypiezygveqqynrimpbauwrmzohwfcqvmogefxupcjalbylrhwwsnmpawrkszehfngpnrikvnshykmohslcyfbxqkkzjywevurbofagwhbuiguztavuefzhhumyxlnjfxunjqzcnqxjgymoggyhgtgxztbcpfjelgywifrzyrantycrctrpsmemqxttcxvwlynspomrvmkivhhaphirmwlhxckgknqeqtsslaprxslhmzwjbgwgmofejafcvknbfujuejziuubwpsclqqhgpmqibkxxsbitgejxmzbclwyvhghuzeazqenubchepxpmwhwflqigbwpwnogryvlucwglcxphrqhsbhbrzhxhqaqayllesbjrulrgpxcjignvcercztptvjmbbpatffpoqpvexvxcpngjrzbapqkeukznixhyywmtljsclxrbktipcxvmxmqorffprauxofsxhkrmzllezmmpaunpnmkjhbtuzkzcwriyqknpkvymbogvkkxfipgupbtralxkfjvmgowapcvqrhghhhrquqvlxfsugvazbmfsxspykkwjcpwwjwlbyqvsetiykpnernkrutcbphvibtelkrarbmuplygjmpwnmggqwhmbcytwirzcumiymylvxvrrmfyklybjqlmbatkbjoevutkqgbyeixljvijbxxwbilifmeknlexlxetcvcctzyacirkpuxpvzrqhmjeyqxqeztorujfjhupebxcymfzxzicqxuwvioeonsixiqijyvilhubwimmoqzsmruhmufyjzbxbfttvusgtmgqeyjvwrvokvuishlsplfenkngsblphbhzuwtkzabfkbboysylwykiaeufiilxmezjvthuhvmuwsxcmneomfbxmxbxtoblxowxnbvamlqyelxslqvrhwbzgkjoqofamzkbiubfjlathklwhbimlngmfyuecbttvpngeryanbehszijsqhypepisqngojmsvkxonvojrqkvkomowknsjkastranjfliqvrtbhzfzaxzqklfaabvvffuhmqlazvrlwysbmhirpqktpnhxrxyusvohzrogmvqbkcixcnulchwjcteifswijqkpkceixbcuoipsfuoziuurwwraguracctpctnqcnulhrbsxubtiuelsajhbaxmtmnjgwoxeqwvirruavepfqjsmywfmxhoqfxawxvrvavqbhmqmysyippgkccqoeeqxigjrieaopmbisvawztuwkwecrwmjlmomaiicoqottrtwuxputfrbknisexfsheiztibxnkpbubgamicibjlvtahksrmlvnvtfjppgvsrmjtxgwhcfjiksytfiopujoiiskkzqynxuhxuakfxablvpyomsozyxtuhrsntbfwilkakaerivigplrkvkgluukxmpvfubpivofjkmzjparbahxtkloplyotphckoqqxxylcnhxcnwlhgogjuorslifgvchfybjzatcapssurahheieoqzeiivnbwjacongsfiyeuxypcugbmhfygputhieymncabkgtbzxesgnwysriixarwgmtywhjsgmirespiekjwnqosflucmasxzkvkaivkixlclymquizoujwiaqgxkcowxuqqgieeeslqguywpuvsavostzmrrnrqyxcvmssiqcxrciguboztqpyryfgbtyoemzqssypexthqlgohregfnozfpltrqygpivytkpvoxtgbvrjrfirxsrpwktqrsaniaselhhpgmizrxcqxigtstzrcrtwvvlewnsxozapnnaocmhreyaqfulepuswijennzuhqlzittkqvbnczlowirzbagztazfvcbrehihwvmgugeslwukzpxkepxonkmugfxvcpfghzqzzpxtikbnakkshnmfxjvgxqvibyajhupwmlqaeqhbrivmxjbwkwrhzcwnyaavtbuqffilvkrloeivocbyxcoosopnorghfozuhcescxliniibgrxubynwoyxihfqrzzszsnifarbhvvkosfihgzeezsjrxisoohlowmqyhzytczmqheouhwcnqxjzyaxmphqyibtjfzvhrhuzmfjqwwepbqhoamtmexyeisacprtbqlyaonxcxuvcsnhgyufaiucmshkuotzsqfyklqmalhmienzanlvzkayqqpebkfxyurztxrhvhufpweekngcrmiqkgfbunqhnnbelrhlpgphcpwbwitosnjvweeprtjbxogoaslimbmnesmtohelzyrlvarheogihwibvcnbyizuklgucczpbrfzcwmlquaqekesqyxulpzoewwtqeiyexqgocgpgzvlwpbmezbjaxhbenhrismgrahllmhyypvcglwfhzpvsnqcpllkioxllnnvxxxjnlfqqpjjhyolzstklxjczwucinfhpelssyzwaxovmfnbjssmprfsavuanhtkmfjfqtvyqjxqnwjortbzokholckjknwbwhrojrqluhhcofvwfufrogharrhjwjtgcqqqyrppwztzptucgpgubrflbovhbsqesjhmvbiwrhpnkxkikxyumayfnqssleziwarkanpbnetixvnqsgwglzbrxxmqjytgytxcqjuyfhknrtikeofcnmzfvaqvrxbjkzfeevyjszcifagghtkcqnvflwvljolmqqgukjyfzhoxgtkxwnmyumulsbprvbpturmthjkfwjcfaswhszlavbavvekyyokljhnoyktkxnfebmeqylhbpjfhzzniozbaypknmajsqbcebbistjoaumctzlzkgyfjtvrompxoihplwtngxoaizwwjrokxtvnwvjprqnmokrxozpxpyreyjecqtlktqsavvoprqnwvisoieftuuobpcjwfumhpcgqkvfykspptxgwkcazwycpqfifyalvhjffsgigcnqewglzvzpsmahvqhwttqayhtgtwwybatchlewrvzazavbpxzvgwuvuzpjazpzykeozxglohgmwyhmgouyeqjaypamfesypugonbisholmvynrpwmvrqckqcxfxoshgywxtslswbwvtfwyvpqcwlbkwskmkzunycvucthjtuybauabjcbuozmgkygyregrcjbjnfloirimuytgagqfbbwpfujgimatykkappfakruwsnkyitcmlvpuhbckhifitkgjhotpfpzvjpzbbrjuuxugziyokbuzkpomnqkhwhvnskophypgkrvkcescpxknyvgngvugkzprnngrvpcunjwalplxjxtuweqzzhypjxwvtniucjkomjzvsbticccswlaugvpuilzlniwssyjmtfhvyiycugjwemgwqbbrkuyrjweibnjotvwqihyzixbhufpylgauvnrclfpsqhlzfiffpozhbwyynckrwlbexaclbisxumvpnmnqvkzlznbuzthaojmpzbijyxqngtkswjxjjhhhkilaxrspepmokspeltasejivltnvlqysiwfnwvahikwtmspyjfxwequkestjefpsfviqgumanacqchruqhevqwbsfftacioycxwgyqxzmgbjesjplcaueezxpembkewehpgvrtwantxarazaaypyfcxsoacnayjxstroegxshhzvtpjioyablxwhlauiscmvivhofecagjfygtlqxcyeavviohzlhohqpphxajjmfwjxpmyvlsnmurapkelbkfuplrgbhsliewhttliogtcfgvzkuqlbebyozrfwlevpssjyfynfonkoxfxzjzefvzzrpcwkaiukpfgscolnvhveyelararmmtkkauugyhkigjfpeysbivfbvmfwsyupnzyfrrghhpsvlzvsvpwvhearxrhlfzfswajsizpqeowkmazsxmeripkihbbjofjhitmlcppgyzwilelsyrwolrcuiyeizmuxxfwenwafzvnvlrfsisgvxentatobwkogbuvqohazkzvlegqwteylztijgfvearfoqlqqzuxibbsorfqchnhjumopximamjecpzmqvhaukjgqtrccsocsfwczcytpqtfysexyythqelbvthneaeakgpxfylyerxocjmiohfcgflgkqpvrjfnswzpsbqjxblastpuigxmghaprphgtmapofhffgtltxjypbystwjeobrlhhgqgzxbyfhffgbbxjutrngsmoyyebhyrujyoxlgangiswqywqjizqzqkplzwnwxspcffhqszcchizhikgouzngetkcxzvicfqyrsnfbfispeyvyiicxzjwsigyaiwpimjfblqappqiyfeslyffjuvuirjfwuyxbjvuhchcwvpjsqomcvheawvqmfiultxuctoogqfwmergyymamflrmpvatypivexgzpfkiloxivugamkzkslurponmtyutqucqekzosuwyokrkjryzfezajbiaavierlkcsxnltqufivleqebmghwuzicyutvqhzgkzezahztvioxnrgfsliysgkyoxeqqthjrungbabezgzwoatyseibxcqrfskjjnkweajawbmfzfxrblowgptosiakliabtkyhvcprlyufpojecpzxuvommsvfasmfxgbnqqkziabiguvbiuhycrpswbqxjuamiihiwlecvhgtqxixtfxvqnopshrylfiinzgkxiljuzneswswzeuawuxewflzlrtxateghhnwxblbftlusnkyammajxbwtenxkruzmwkjyvaacahjguwwgiqcnikhblgbuklrettorvpwfetampiuvknmitixteqmgstyajophjjrtqoxiebpuwwyttvxpmoazhwfrrgsomlzyglfikiiqhpnewkxghwijwxlxnyitomafaknfczjrxmbailtvyhuttjlbxmwxercjoziugyfzvvwussqhygxosmtckqmlowwmexlbpiuzhfegjuzycgwoyhslxsbpnozxgiaowqsvuhninqrctlchoclicqrjzafvkhgsfpcazkbpirsjjatxtxypasaxbuwxaxlsvzbinrvongyhgkmhsttlkirxyubmzinwfmfezvukptebjvatjmroygeknfcoqjsosormpsgnfaazhkmhiujruobcjksvnhyxjusnkwhcjffmwazuaxvqjunqyelyoxtpqhkpagzustkxxlzvkwsbjtzjuiybrcewiwhwlzufxtxxgkgncavcxmbajgzvrgavjeeshclcmwleizscbnzcaaulfjrxjrfqblyitsguugbnbctciwzyahbgcbrccxgrzfulkbinqasqiomlzlfpeyyizywmkxfwhksblfhbocengvtkgzrmzhhzcyjqqqyyaeihfjsqayvhyaabftykqzfcejfrbmvzlqybxhoozsevmknpxhpmmfibmnligtuisopbqllaqmsrsxxtehujykzvwhjffmtmffgokwvoucuxpekkqphtybowfcnawuotakvnsvmusugbrsqlrxcgfemkjkjwsflxvgsvcmmjbubzaiguztuhikphnuvoozpurimqlrjslstbhwwepvxzqowqlvawplszgrcavtlqiyxqtajfjoeaugpcejslbiijgqxoemmaxabkfj' # noqa
+        finalTestStringT = ''.join(random.sample(finalTestStringS,
+                                   len(finalTestStringS)))
+        finalTestStringT += 'l'
+        case6in = Solution()
+        t1 = time.time()
+        case6out = case6in.findTheDifference(finalTestStringS,
+                                             finalTestStringT)
+        t2 = time.time()
+        print ('Runtime of Case6: ' + str(t2-t1) + ' seconds')
+        self.assertEqual(case6out, 'l')
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/challenge_7/python/ajschrier/MissingNumber.py b/challenge_7/python/ajschrier/MissingNumber.py
new file mode 100644
index 000000000..54552a704
--- /dev/null
+++ b/challenge_7/python/ajschrier/MissingNumber.py
@@ -0,0 +1,23 @@
+def builtInMethod(inputList):
+    for i in xrange(len(inputList)):
+        # Check if i is in list
+        if i not in inputList:
+            # Return number
+            return i
+    # Return 0 if none of the numbers meet the condition
+    return 0
+
+
+def sumMethod(inputList):
+    # find (n*n+1)/2
+    fullSum = (len(inputList) * (len(inputList) + 1)) / 2
+    # subtract sum of full range from supplied range
+    return fullSum - sum(inputList)
+
+
+def main():
+    pass
+
+
+if __name__ == '__main__':
+    main()
diff --git a/challenge_7/python/ajschrier/README.md b/challenge_7/python/ajschrier/README.md
new file mode 100644
index 000000000..07327870b
--- /dev/null
+++ b/challenge_7/python/ajschrier/README.md
@@ -0,0 +1,23 @@
+# Challenge 7 - Find the Missing Number
+
+*Python Version:* 2.7
+
+In a list 0..N, find which digit is missing.
+
+# Functions
+
+## builtInMethod
+
+**Input:** List
+**Output:** Integer
+
+Finds the integer 0 < x < N not present in list. The 'not in' syntax performs at O(N) according to [the Python Wiki](https://wiki.python.org/moin/TimeComplexity), so that is used to check the list for the value in the range. 
+
+**UPDATE**: 'not in' syntax is O(N), but the fact that it's in another loop makes the solution O(N^2). Thanks erocs.
+
+## sumMethod
+
+**Input:** List
+**Output:** Integer
+
+Uses the principle of sequential ranges (n*n+1)/2 to find the missing element. The sum of the input list is subtracted from the sum of the full range, exposing the missing element.
\ No newline at end of file
diff --git a/challenge_7/python/ajschrier/Test_MissingNumber.py b/challenge_7/python/ajschrier/Test_MissingNumber.py
new file mode 100644
index 000000000..2b4681d3e
--- /dev/null
+++ b/challenge_7/python/ajschrier/Test_MissingNumber.py
@@ -0,0 +1,108 @@
+import MissingNumber
+import unittest
+
+
+class BuiltInTests(unittest.TestCase):
+    """tests for builtInMethod"""
+
+    def testMissing3(self):
+        self.assertEqual(MissingNumber.
+                         builtInMethod([0, 1, 2, 4]), 3)
+
+    def testMissing2(self):
+        self.assertEqual(MissingNumber.
+                         builtInMethod([1, 3, 4, 0]), 2)
+
+    def testNoMissingNumber(self):
+        self.assertEqual(MissingNumber.
+                         builtInMethod([1, 2, 3]), 0)
+
+    def testLongerList(self):
+        self.assertEqual(MissingNumber.
+                         builtInMethod([0, 1, 2, 3, 4, 5, 6, 8, 9, 10, 11,
+                                        12, 13, 14, 15, 16, 17, 18, 19,
+                                        20, 21, 22, 23, 24]), 7)
+
+    def testEvenLongerRandomList(self):
+        self.assertEqual(MissingNumber.
+                         builtInMethod([78, 53, 118, 99, 154, 5, 52, 184,
+                                       73, 17, 92, 107, 34, 159, 101, 30,
+                                       171, 95, 100, 54, 63, 169, 37, 45,
+                                       174, 158, 57, 0, 89, 61, 71, 188,
+                                       83, 18, 133, 149, 62, 151, 90, 3,
+                                       141, 126, 165, 179, 103, 166, 68,
+                                       177, 163, 190, 77, 55, 31, 187, 16,
+                                       91, 47, 93, 146, 147, 74, 185, 135,
+                                       102, 41, 125, 164, 12, 19, 168, 96,
+                                       23, 86, 194, 9, 132, 104, 122, 24,
+                                       144, 161, 117, 183, 196, 176, 155,
+                                       108, 172, 120, 160, 182, 50, 75, 22,
+                                       15, 49, 80, 127, 106, 20, 148, 139,
+                                       38, 134, 67, 123, 56, 88, 40, 186,
+                                       131, 76, 59, 21, 43, 4, 14, 115,
+                                       162, 199, 48, 128, 81, 39, 11, 97,
+                                       137, 153, 10, 65, 138, 114, 79, 6,
+                                       195, 156, 180, 8, 28, 60, 192, 42,
+                                       119, 64, 2, 200, 116, 129, 51, 178,
+                                       191, 121, 82, 143, 26, 110, 33, 136,
+                                       32, 175, 27, 150, 111, 105, 70, 157,
+                                       44, 13, 46, 170, 58, 69, 198, 193,
+                                       167, 25, 29, 181, 66, 72, 36, 87, 7,
+                                       98, 130, 152, 94, 189, 1, 84, 109,
+                                       113, 197, 145, 35, 124, 112, 173,
+                                       140, 142]), 85)
+
+
+class SumMethodTests(unittest.TestCase):
+    """tests for sumMethod"""
+
+    def testMissing3(self):
+        self.assertEqual(MissingNumber.
+                         sumMethod([0, 1, 2, 4]), 3)
+
+    def testMissing2(self):
+        self.assertEqual(MissingNumber.
+                         sumMethod([1, 3, 4, 0]), 2)
+
+    def testNoMissingNumber(self):
+        self.assertEqual(MissingNumber.
+                         sumMethod([1, 2, 3]), 0)
+
+    def testLongerList(self):
+        self.assertEqual(MissingNumber.
+                         sumMethod([0, 1, 2, 3, 4, 5, 6, 8, 9, 10, 11,
+                                    12, 13, 14, 15, 16, 17, 18, 19,
+                                    20, 21, 22, 23, 24]), 7)
+
+    def testEvenLongerRandomList(self):
+        self.assertEqual(MissingNumber.
+                         sumMethod([78, 53, 118, 99, 154, 5, 52, 184,
+                                    73, 17, 92, 107, 34, 159, 101, 30,
+                                    171, 95, 100, 54, 63, 169, 37, 45,
+                                    174, 158, 57, 0, 89, 61, 71, 188,
+                                    83, 18, 133, 149, 62, 151, 90, 3,
+                                    141, 126, 165, 179, 103, 166, 68,
+                                    177, 163, 190, 77, 55, 31, 187, 16,
+                                    91, 47, 93, 146, 147, 74, 185, 135,
+                                    102, 41, 125, 164, 12, 19, 168, 96,
+                                    23, 86, 194, 9, 132, 104, 122, 24,
+                                    144, 161, 117, 183, 196, 176, 155,
+                                    108, 172, 120, 160, 182, 50, 75, 22,
+                                    15, 49, 80, 127, 106, 20, 148, 139,
+                                    38, 134, 67, 123, 56, 88, 40, 186,
+                                    131, 76, 59, 21, 43, 4, 14, 115,
+                                    162, 199, 48, 128, 81, 39, 11, 97,
+                                    137, 153, 10, 65, 138, 114, 79, 6,
+                                    195, 156, 180, 8, 28, 60, 192, 42,
+                                    119, 64, 2, 200, 116, 129, 51, 178,
+                                    191, 121, 82, 143, 26, 110, 33, 136,
+                                    32, 175, 27, 150, 111, 105, 70, 157,
+                                    44, 13, 46, 170, 58, 69, 198, 193,
+                                    167, 25, 29, 181, 66, 72, 36, 87, 7,
+                                    98, 130, 152, 94, 189, 1, 84, 109,
+                                    113, 197, 145, 35, 124, 112, 173,
+                                    140, 142]), 85)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/challenge_9/python/ning/README.md b/challenge_9/python/ning/README.md
new file mode 100644
index 000000000..87fc3276d
--- /dev/null
+++ b/challenge_9/python/ning/README.md
@@ -0,0 +1,30 @@
+# Challenge #9, Squares
+
+This solution makes use of `Counter` from the in-built `collections` library. The creation of the Counter object, `abs_counter` is an O(n) operation as can be seen from the [source code](https://hg.python.org/cpython/file/2.7/Lib/collections.py#l528).
+
+1. To start off, we create an empty `output_list` which we will append our output.
+2. Next, we create a Counter object `abs_counter` from the input list with the absolute values of each element within. 
+3. The lowest and highest absolute values, `max_abs` and `min_abs` are found.
+4. This allows us to iterate through all absolute values in ascending order, eliminating the need for any form of sorting after we square the elements. 
+5. Put into practice: we iterate through from `min_abs` to `max_abs+1`, appending the squares accordingly (taking into account elements that occur more than once as well) into the output, `output_list`.
+
+The unit test covers,
+
+1. Positive integers
+2. Negative integers
+3. Zeroes
+4. Repeat elements
+
+```
+......
+----------------------------------------------------------------------
+Ran 6 tests in 8.258s
+
+OK
+test_all completed 100000 reps with 1.8796267224919547s
+test_negatives completed 100000 reps with 1.0380016055644727s
+test_positives completed 100000 reps with 1.0510455415440965s
+test_repeats completed 100000 reps with 2.041641256050432s
+test_zeroes_negatives completed 100000 reps with 1.102484358268124s
+test_zeroes_positives completed 100000 reps with 1.1347802273483003s
+```
diff --git a/challenge_9/python/ning/challenge_9.py b/challenge_9/python/ning/challenge_9.py
new file mode 100644
index 000000000..4ab62eaa8
--- /dev/null
+++ b/challenge_9/python/ning/challenge_9.py
@@ -0,0 +1,14 @@
+from collections import Counter
+
+def square_sort(input_list):
+    output_list = []
+    abs_counter = Counter([abs(i) for i in input_list])  # O(n)
+    max_abs, min_abs = max(abs_counter.keys()), min(abs_counter.keys())  # O(n)
+
+    for i in range(min_abs, max_abs+1):  # O(m), where m is unique ints, then...
+        if i in abs_counter:
+            for iters in range(abs_counter[i]): # O(m) -> O(n), for all ints now
+                output_list.append(i**2)
+
+    return output_list
+
diff --git a/challenge_9/python/ning/test.py b/challenge_9/python/ning/test.py
new file mode 100644
index 000000000..d1ac4ee9b
--- /dev/null
+++ b/challenge_9/python/ning/test.py
@@ -0,0 +1,83 @@
+import unittest, timeit
+from challenge_9 import square_sort
+
+class Tests(unittest.TestCase):
+    reps = 100000
+
+    def test_positives(self):
+        self.assertEqual(
+                square_sort([1, 2, 3, 4]),
+                [1, 4, 9, 16]
+                )
+        time = timeit.timeit(
+                'square_sort([1, 2, 3, 4])',
+                setup='from __main__ import square_sort',
+                number=Tests.reps
+                )
+        print('test_positives completed {} reps with {}s'.format(Tests.reps, time))
+
+
+    def test_negatives(self):
+        self.assertEqual(
+                square_sort([-1, -2, -3, -4]),
+                [1, 4, 9, 16]
+                )
+        time = timeit.timeit(
+                'square_sort([-1, -2, -3, -4])',
+                setup='from __main__ import square_sort',
+                number=Tests.reps
+                )
+        print('test_negatives completed {} reps with {}s'.format(Tests.reps, time))
+
+    def test_zeroes_positives(self):
+        self.assertEqual(
+                square_sort([0, 0, 1, 3, 5]),
+                [0, 0, 1, 9, 25]
+                )
+        time = timeit.timeit(
+                'square_sort([0, 0, 1, 3, 5])',
+                setup='from __main__ import square_sort',
+                number=Tests.reps
+                )
+        print('test_zeroes_positives completed {} reps with {}s'.format(Tests.reps, time))
+
+    def test_zeroes_negatives(self):
+        self.assertEqual(
+                square_sort([-6, -4, -2, 0, 0]),
+                [0, 0, 4, 16, 36]
+                )
+        time = timeit.timeit(
+                'square_sort([-6, -4, -2, 0, 0])',
+                setup='from __main__ import square_sort',
+                number=Tests.reps
+                )
+        print('test_zeroes_negatives completed {} reps with {}s'.format(Tests.reps, time))
+
+    def test_all(self):
+        self.assertEqual(
+                square_sort([-10, -8, -5, -3, -1, 0, 2, 4, 6, 7, 9]),
+                [0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
+                )
+        time = timeit.timeit(
+                'square_sort([-10, -8, -5, -3, -1, 0, 2, 4, 6, 7, 9])',
+                setup='from __main__ import square_sort',
+                number=Tests.reps
+                )
+        print('test_all completed {} reps with {}s'.format(Tests.reps, time))
+
+    def test_repeats(self):
+        self.assertEqual(
+                square_sort([-10, -8, -5, -3, -2, -1, 0, 0, 2, 4, 5, 6, 7, 9, 10]),
+                [0, 0, 1, 4, 4, 9, 16, 25, 25, 36, 49, 64, 81, 100, 100]
+                )
+        time = timeit.timeit(
+                'square_sort([-10, -8, -5, -3, -2, -1, 0, 0, 2, 4, 5, 6, 7, 9, 10])',
+                setup='from __main__ import square_sort',
+                number=Tests.reps
+                )
+        print('test_repeats completed {} reps with {}s'.format(Tests.reps, time))
+
+if __name__ == '__main__':
+    unittest.main()
+
+