diff --git a/MorseTrainer/Analyzer.cs b/MorseTrainer/Analyzer.cs
index d445715..e471bb1 100644
--- a/MorseTrainer/Analyzer.cs
+++ b/MorseTrainer/Analyzer.cs
@@ -35,8 +35,14 @@ namespace MorseTrainer
         {
             _resultsRTB.Clear();
             MorseCompareResults results = Comparer.Compare(sent, recorded);
+            ShowStrings(results);
+            ShowStats(results);
+        }
+
+        private void ShowStrings(MorseCompareResults results)
+        {
             Write("I sent   : ");
-            ResultsDisplayFlags flags = ResultsDisplayFlags.Valid | ResultsDisplayFlags.Dropped;
+            ResultsFlags flags = ResultsFlags.Valid | ResultsFlags.Dropped;
             foreach (MorseSubstring substring in results.SubStrings)
             {
                 Write(substring.Str(flags), substring.Color);
@@ -44,13 +50,59 @@ namespace MorseTrainer
             Write(Environment.NewLine);
 
             Write("You typed: ");
-            flags = ResultsDisplayFlags.Valid | ResultsDisplayFlags.Extra;
+            flags = ResultsFlags.Valid | ResultsFlags.Extra;
             foreach (MorseSubstring substring in results.SubStrings)
             {
                 Write(substring.Str(flags), substring.Color);
             }
             Write(Environment.NewLine);
+        }
 
+        private void ShowStats(MorseCompareResults results)
+        {
+            int[] sent = new int[256];
+            int[] valid = new int[256];
+            int[] dropped = new int[256];
+            int[] extra = new int[256];
+            int totalValid = 0;
+
+            foreach (char c in results.Sent)
+            {
+                sent[c]++;
+            }
+            foreach (MorseSubstring substring in results.SubStrings)
+            {
+                int[] counter = null;
+                switch (substring.ResultInfo & ResultsFlags.All)
+                {
+                    case ResultsFlags.Dropped:
+                        counter = dropped;
+                        break;
+                    case ResultsFlags.Extra:
+                        counter = extra;
+                        break;
+                    case ResultsFlags.Valid:
+                        counter = valid;
+                        totalValid += substring.Chars.Length;
+                        break;
+                }
+                if (counter != null)
+                {
+                    foreach (char c in substring.Chars)
+                    {
+                        counter[c]++;
+                    }
+                }
+            }
+
+            Write(String.Format("Sent {0} and {1} recorded valid: {2}%" + Environment.NewLine, results.Sent.Length, totalValid, (float)totalValid / (float)results.Sent.Length));
+            foreach (char c in MorseInfo.PossibleCharacters)
+            {
+                if (sent[c] != 0 || extra[c] != 0)
+                {
+                    Write(String.Format(" {0} {1}/{2} : {3},{4}" + Environment.NewLine, MorseInfo.ExpandProsigns(c), valid[c], sent[c], dropped[c], extra[c]));
+                }
+            }
         }
 
         private void Write(String text)
diff --git a/MorseTrainer/MorseCompareResults.cs b/MorseTrainer/MorseCompareResults.cs
index 5838a7e..e123a3b 100644
--- a/MorseTrainer/MorseCompareResults.cs
+++ b/MorseTrainer/MorseCompareResults.cs
@@ -29,7 +29,7 @@ namespace MorseTrainer
     /// Flags that indicate how to display results
     /// </summary>
     [Flags]
-    public enum ResultsDisplayFlags
+    public enum ResultsFlags
     {
         /// <summary>
         /// Display characters that were received as sent
@@ -148,7 +148,15 @@ namespace MorseTrainer
         /// </summary>
         /// <param name="flags">Flags saying which characters to include</param>
         /// <returns></returns>
-        public abstract String Str(ResultsDisplayFlags flags = ResultsDisplayFlags.All);
+        public abstract String Str(ResultsFlags flags = ResultsFlags.All);
+
+        /// <summary>
+        /// Gets information about the string
+        /// </summary>
+        public abstract ResultsFlags ResultInfo
+        {
+            get;
+        }
 
         protected string _str;
     }
@@ -163,16 +171,24 @@ namespace MorseTrainer
         {
         }
 
-        public override string Str(ResultsDisplayFlags flags)
+        public override string Str(ResultsFlags flags)
         {
             String ret = "";
-            if ((flags & ResultsDisplayFlags.Valid) != 0)
+            if ((flags & ResultsFlags.Valid) != 0)
             {
                 ret = MorseInfo.ExpandProsigns(_str);
             }
             return ret;
         }
 
+        public override ResultsFlags ResultInfo
+        {
+            get
+            {
+                return ResultsFlags.Valid;
+            }
+        }
+
         public override Color Color
         {
             get
@@ -192,16 +208,24 @@ namespace MorseTrainer
         {
         }
 
-        public override string Str(ResultsDisplayFlags flags)
+        public override string Str(ResultsFlags flags)
         {
             String ret = "";
-            if ((flags & ResultsDisplayFlags.Dropped) != 0)
+            if ((flags & ResultsFlags.Dropped) != 0)
             {
                 ret = MorseInfo.ExpandProsigns(_str);
             }
             return ret;
         }
 
+        public override ResultsFlags ResultInfo
+        {
+            get
+            {
+                return ResultsFlags.Dropped;
+            }
+        }
+
         public override Color Color
         {
             get
@@ -221,16 +245,24 @@ namespace MorseTrainer
         {
         }
 
-        public override string Str(ResultsDisplayFlags flags)
+        public override string Str(ResultsFlags flags)
         {
             String ret = "";
-            if ((flags & ResultsDisplayFlags.Extra) != 0)
+            if ((flags & ResultsFlags.Extra) != 0)
             {
                 ret = MorseInfo.ExpandProsigns(_str);
             }
             return ret;
         }
 
+        public override ResultsFlags ResultInfo
+        {
+            get
+            {
+                return ResultsFlags.Extra;
+            }
+        }
+
         public override Color Color
         {
             get
diff --git a/MorseTrainer/MorseInfo.cs b/MorseTrainer/MorseInfo.cs
index 5df4070..f36f99e 100644
--- a/MorseTrainer/MorseInfo.cs
+++ b/MorseTrainer/MorseInfo.cs
@@ -130,8 +130,19 @@ namespace MorseTrainer
                 }
                 __elements[i] = elements;
             }
+
+            List<Char> hasConversion = new List<char>();
+            for (int i=0; i<256; i++)
+            {
+                if (__conversions[i] != null)
+                {
+                    hasConversion.Add((Char)i);
+                }
+            }
+            __orderedPossibleCharacters = hasConversion.ToArray<Char>();
         }
 
+        private static readonly Char[] __orderedPossibleCharacters;
         private static Dictionary<String, char> __prosignExpansionToValue;
         private static Dictionary<char, String> __prosignValueToExpansion;
         private static String[] __conversions;
@@ -186,6 +197,24 @@ namespace MorseTrainer
             return replaced;
         }
 
+        /// <summary>
+        /// Converts a string with prosign constants into a string containing
+        /// the expanded prosigns
+        /// </summary>
+        /// <param name="c">A char with prosign constants</param>
+        /// <returns>A string with expanded prosigns</returns>
+        public static String ExpandProsigns(Char c)
+        {
+            String replaced = c.ToString();
+            foreach (KeyValuePair<String, char> kv in __prosignExpansionToValue)
+            {
+                String expansion = kv.Key;
+                String value = kv.Value.ToString();
+                replaced = replaced.Replace(value, expansion);
+            }
+            return replaced;
+        }
+
         /// <summary>
         /// Converts a string with prosign constants into a string containing
         /// the expanded prosigns
@@ -203,5 +232,16 @@ namespace MorseTrainer
             }
             return replaced;
         }
+
+        /// <summary>
+        /// Gets an array of possible characters in ASCII/prosign order
+        /// </summary>
+        public static Char[] PossibleCharacters
+        {
+            get
+            {
+                return __orderedPossibleCharacters;
+            }
+        }
     }
 }