diff --git a/mycode.py b/mycode.py
new file mode 100644
index 0000000..15f8b12
--- /dev/null
+++ b/mycode.py
@@ -0,0 +1,39 @@
+# nw.py
+# ------
+# Implements a simple number-to-text command-line interface.
+# Ex: python nw.py 145
+
+from argparse import ArgumentParser
+from numberwords import int_under_1000000_to_str
+
+
+
+def int_under_1000000_to_str(number):
+    if number < 0 or number >= 1000000:
+        return "Number out of range"
+
+    units = ["", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"]
+    teens = ["ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", 
+             "seventeen", "eighteen", "nineteen"]
+    tens = ["", "", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"]
+
+    def number_to_words(n):
+        if n < 10:
+            return units[n]
+        elif 10 <= n < 20:
+            return teens[n - 10]
+        elif n < 100:
+            return tens[n // 10] + ('' if n % 10 == 0 else '-' + units[n % 10])
+        elif n < 1000:
+            return units[n // 100] + ' hundred' + (' and ' + number_to_words(n % 100) if n % 100 != 0 else '')
+        elif n < 1000000:
+            return (number_to_words(n // 1000) + ' thousand' +
+                    ('' if n % 1000 == 0 else ' ' + number_to_words(n % 1000)))
+
+    return number_to_words(number)
+
+parser = ArgumentParser("Print out a number as it is spoken in English.")
+parser.add_argument("number", type=int)
+args = parser.parse_args()
+text = int_under_1000000_to_str(args.number)
+print(text)
diff --git a/numberwords.py b/numberwords.py
index 8c590cd..0b1cd0a 100644
--- a/numberwords.py
+++ b/numberwords.py
@@ -15,19 +15,51 @@ TENS_NAMES = [
 ]
 
 def int_under_1000000_to_str(number):
-    return "umm..."
+    if number < 1000:
+        return int_under_1000_to_str(number)
+    else:
+        thousands = number // 1000
+        remainder = number % 1000
+        thousands_name = int_under_1000_to_str(thousands) + ' thousand'
+        if remainder == 0:
+            return thousands_name 
+        else:
+            return thousands_name + ' ' + int_under_1000_to_str(remainder)
+       
         
 def int_under_1000_to_str(number):
-    return "umm..."
+    if number < 100 :
+        return int_under_100_to_str(number)
+    else:
+        hundreds = number // 100
+        remainder = number % 100
+        hundreds_names = int_under_10_to_str(hundreds) + ' hundred'
+        if remainder == 0:
+            return hundreds_names 
+        else:
+            return hundreds_names + ' and ' + int_under_100_to_str(remainder)
 
 def int_under_100_to_str(number):
-    return "umm..."
+    if number <20:
+        return int_under_20_to_str(number)
+    else:
+        tens = number // 10
+        units = number % 10
+        if units == 0:
+            return TENS_NAMES[tens]
+        else:
+            return TENS_NAMES[tens] + '-' + int_under_10_to_str(units)
+        
 
 def int_under_20_to_str(number):
-    return "umm..."
+    if number <10:
+        return int_under_10_to_str(number)
+    else:
+        return TWEEN_AND_TEEN_NAMES [number-10]
+
 
 def int_under_10_to_str(number):
-    return "umm..."
+    return DIGIT_NAMES [number]
 
 def divide_with_remainder(dividend, divisor):
     """Divides one number by another, using whole-number division. 
diff --git a/planning.md b/planning.md
index 40d428a..fd86e52 100644
--- a/planning.md
+++ b/planning.md
@@ -21,6 +21,11 @@ elif number == 1:
     return "one"
 elif number == 1:
     return "two"
+    if n < 10:
+        return units[n]
+        n % 10
+        n% 100
+        n % 1000
 ```
 
 A cleaner way to do this would be to make a list of digit names, from zero to nine.
@@ -35,21 +40,32 @@ return digit_names[number]
 ```
 
 ## Integers under 20
-If the integer is under 10, then use the procedure described above. 
-Otherwise, ... (this is where you take over!)
+if n < 10:
+            return units[n]
 
 ## Integers under 100
+ n < 100:
+            return tens[n // 10] + ('' if n % 10 == 0 else '-' + units[n % 10])
+
 
 
 ## Integers under 1000
+ n < 1000:
+            return units[n // 100] + ' hundred' + (' and ' + number_to_words(n % 100) if n % 100 != 0 else '')
 
 
 ## Integers under 1000000
+n < 1000000:
+            return (number_to_words(n // 1000) + ' thousand' +
+                    ('' if n % 1000 == 0 else ' ' + number_to_words(n % 1000)))
 
 
 ## Negative integers down to -1 million
 We won't deal with negative integers in this problem set, 
 but how would you deal with a negative integer, using the 
 functions above?
+if number < 0:
+        
+        return "negative " + int_under_1000000_to_str(-number)
 
 
diff --git a/test_numberwords.py b/test_numberwords.py
index 0fa6d68..8424af0 100644
--- a/test_numberwords.py
+++ b/test_numberwords.py
@@ -33,7 +33,7 @@ class TestIntToStr(unittest.TestCase):
         [int_under_1000000_to_str, 1001, 'one thousand one'], 
         [int_under_1000000_to_str, 1672, 'one thousand six hundred and seventy-two'], 
         [int_under_1000000_to_str, 10000, 'ten thousand'], 
-        [int_under_1000000_to_str, 588567, 'five hundred and ninety-eight thousand five hundred and sixty-seven'],
+        [int_under_1000000_to_str, 588567, 'five hundred and eighty-eight thousand five hundred and sixty-seven'],
     ]
 
     def test_converts_integer_to_string(self):