class Program
    {
        private static void Main(string[] args)
        {
            uint rangeStart = 0;
            uint rangeEnd = 0;
            bool setOutputEncodingToUnicode = true;
            // Get the current encoding so we can restore it.
            Encoding originalOutputEncoding = Console.OutputEncoding;

            try
            {
                switch (args.Length)
                {
                    case 2:
                        rangeStart = uint.Parse(args[0], NumberStyles.HexNumber);
                        rangeEnd = uint.Parse(args[1], NumberStyles.HexNumber);
                        setOutputEncodingToUnicode = true;
                        break;
                    case 3:
                        if (!uint.TryParse(args[0], NumberStyles.HexNumber, null, out rangeStart))
                            throw new ArgumentException(String.Format("{0} is not a valid hexadecimal number.", args[0]));

                        if (!uint.TryParse(args[1], NumberStyles.HexNumber, null, out rangeEnd))
                            throw new ArgumentException(String.Format("{0} is not a valid hexadecimal number.", args[1]));

                        bool.TryParse(args[2], out setOutputEncodingToUnicode);
                        break;
                    default:
                        Console.WriteLine("Usage: {0} <{1}> <{2}> [{3}]",
                                          Environment.GetCommandLineArgs()[0],
                                          "startingCodePointInHex",
                                          "endingCodePointInHex",
                                          "<setOutputEncodingToUnicode?{true|false, default:false}>");
                        return;
                }

                if (setOutputEncodingToUnicode)
                {
                    // This won‘t work before .NET Framework 4.5.
                    try
                    {
                        // Set encoding using endianness of this system.
                        // We‘re interested in displaying individual Char objects, so 
                        // we don‘t want a Unicode BOM or exceptions to be thrown on
                        // invalid Char values.
                        Console.OutputEncoding = new UnicodeEncoding(!BitConverter.IsLittleEndian, false);
                        Console.WriteLine("\nOutput encoding set to UTF-16");
                    }
                    catch (IOException)
                    {
                        Console.OutputEncoding = new UTF8Encoding();
                        Console.WriteLine("Output encoding set to UTF-8");
                    }
                }
                else
                {
                    Console.WriteLine("The console encoding is {0} (code page {1})",
                                      Console.OutputEncoding.EncodingName,
                                      Console.OutputEncoding.CodePage);
                }
                DisplayRange(rangeStart, rangeEnd);
            }
            catch (ArgumentException ex)
            {
                Console.WriteLine(ex.Message);
            }
            finally
            {
                // Restore console environment.
                Console.OutputEncoding = originalOutputEncoding;
            }
        }

        public static void DisplayRange(uint start, uint end)
        {
            const uint upperRange = 0x10FFFF;
            const uint surrogateStart = 0xD800;
            const uint surrogateEnd = 0xDFFF;

            if (end <= start)
            {
                uint t = start;
                start = end;
                end = t;
            }

            // Check whether the start or end range is outside of last plane.
            if (start > upperRange)
                throw new ArgumentException(String.Format("0x{0:X5} is outside the upper range of Unicode code points (0x{1:X5})",
                                                          start, upperRange));
            if (end > upperRange)
                throw new ArgumentException(String.Format("0x{0:X5} is outside the upper range of Unicode code points (0x{0:X5})",
                                                          end, upperRange));

            // Since we‘re using 21-bit code points, we can‘t use U+D800 to U+DFFF.
            if ((start < surrogateStart & end > surrogateStart) || (start >= surrogateStart & start <= surrogateEnd))
                throw new ArgumentException(String.Format("0x{0:X5}-0x{1:X5} includes the surrogate pair range 0x{2:X5}-0x{3:X5}",
                                                          start, end, surrogateStart, surrogateEnd));
            uint last = RoundUpToMultipleOf(0x10, end);
            uint first = RoundDownToMultipleOf(0x10, start);

            uint rows = (last - first) / 0x10;

            for (uint r = 0; r < rows; ++r)
            {
                // Display the row header.
                Console.Write("{0:x5} ", first + 0x10 * r);

                for (uint c = 0; c < 0x10; ++c)
                {
                    uint cur = (first + 0x10 * r + c);
                    if (cur < start)
                    {
                        Console.Write(" {0} ", Convert.ToChar(0x20));
                    }
                    else if (end < cur)
                    {
                        Console.Write(" {0} ", Convert.ToChar(0x20));
                    }
                    else
                    {
                        // the cast to int is safe, since we know that val <= upperRange.
                        String chars = Char.ConvertFromUtf32((int)cur);
                        // Display a space for code points that are not valid characters.
                        if (CharUnicodeInfo.GetUnicodeCategory(chars[0]) ==
                                                        UnicodeCategory.OtherNotAssigned)
                            Console.Write(" {0} ", Convert.ToChar(0x20));
                        // Display a space for code points in the private use area.
                        else if (CharUnicodeInfo.GetUnicodeCategory(chars[0]) ==
                                                       UnicodeCategory.PrivateUse)
                            Console.Write(" {0} ", Convert.ToChar(0x20));
                        // Is surrogate pair a valid character?
                        // Note that the console will interpret the high and low surrogate
                        // as separate (and unrecognizable) characters.
                        else if (chars.Length > 1 && CharUnicodeInfo.GetUnicodeCategory(chars, 0) ==
                                                     UnicodeCategory.OtherNotAssigned)
                            Console.Write(" {0} ", Convert.ToChar(0x20));
                        else
                            Console.Write(" {0} ", chars);
                    }

                    switch (c)
                    {
                        case 3:
                        case 11:
                            Console.Write("-");
                            break;
                        case 7:
                            Console.Write("--");
                            break;
                    }
                }

                Console.WriteLine();
                if (0 < r && r % 0x10 == 0)
                    Console.WriteLine();
            }
        }

        private static uint RoundUpToMultipleOf(uint b, uint u)
        {
            return RoundDownToMultipleOf(b, u) + b;
        }

        private static uint RoundDownToMultipleOf(uint b, uint u)
        {
            return u - (u % b);
        }



    }