using System;

using System.Text;

​

class BinaryToText

{

    static void Main()

    {

        string binaryMessage = @"01000101 01011000

01010000 01001100

01001111 01010010

01000001 010101000

1001001010011110100

11100100111101000

111 01001000 010101

010100110101000001

01001110 01001001

01010100 01011001

0011011 0011011

0011011 00111000

00110001 00110000

00110000

00110101 00110010

00110000 00111001 0011

010000110010 0011

0101 00110011 0011

0010 01001110

00110001 0011001100

110001 00110011

0011000100110010 0011

0110 00111001 0101

0111 01000011 0100

1111 01001110

01010100 0100

1001 001 01001110

0101010101001111 01 01

01 01 0101 001101

01000110 01001111

01010010010100000100

1100010000010100

1110 01000101010101

0001000001 0101

0010 01011001

01000001 01000

100 01010110010

00001 01001110

000111 001 000

100 100001

0100011001001110101010

101010 10010010101

000100100001000011

01001111010011110100

01000100100101001

1100100000101010100

01000 10101000011010

0111101001 11001010

100 01001001 01001110

010101010100111101010

10001 010 1010101000

1010 1001110

01000011 011000101

01010000 0101001

0 01000010 01000

101 010 0011 0 010011

11 01010010

01000101

001100 1 00110110 0011

0111 00110110 00110011

0011000 1 00 11 01

1100110111 0100

111000111000001

1100 1 00110001

00110001 00110

1110011011100 11

0 110 0 0 1 1 1

000 01010111

0011001100 1 1

0100 00111000

001 1000000

11000000110010

001101110110010

0100111000110001

00110001 00110001

00111 00000

110100 00 11 00

1101101010011

01100011011 1

0101011100110

0 10 00111001

00111001 001

10 1 11

0011011100111000

00 11 0011 001 1

0 1 10 0 100

1110 00110011

0011000 1 0011

0001 00110011

0011 0001 0011

0110 00110100

00111 00101000

101

0011000100110100

001101110011000000

11000 10011010100

110000 00110101

010100 1100110111

00110101001100010

0 110110011011100

1100000110 10 00

0 1 1 00 1 1

010101 1100110011

0011 0 110 00

11001000110101

001101100011

10000011

0100 00 11

0 1 0 1 01

001110

001100

01 001 1

0 001

0 0110

111 0011 0001

0011000000

11 0000 0011

01 10 0011

0011 0011

0010 010001010

0110011

001101110011000

1001100010011

000000110001

00111001001

101010100111

0 0011 0010

00110101

00110011001

10 1 11 0011

0010

0011001000111000

0011 000101000

10 1

0100010101011001

01000 101

0 101 0011

010011110100011 0

010110010100111101

01010101010010

0100010101011001 01

000 0 10 10

1010011

0100111101010010

0100100101000111

0100100101001110

0011010100110010

0011 000 00 111001

00 11 0100 00110010

001101 01 0011 0011

0011 0010 01001110

00110001 00 11

00110011 000 1

001100110011

0001 00 11

0010 00110110

011100101010 111

01 00 111101010010 01

001 00 1 0 1 00 0

111 01001001 0100

11 1 0 0101100101000

1010100000 1 010100

1000111000 001100

01 00110 000

0011000 0";

​

        string result = BinaryToUtf8(binaryMessage);

        Console.WriteLine(result);

    }

​

    static string BinaryToUtf8(string binaryInput)

    {

        StringBuilder result = new StringBuilder();

        StringBuilder currentBinaryChar = new StringBuilder();

        foreach (char c in binaryInput)

        {

            if (c == ' ' || c == '\n')

            {

                // Process the current binary character

                if (currentBinaryChar.Length > 0)

                {

                    string binaryStr = currentBinaryChar.ToString();

                    // Pad with zeros to make it 8 bits if needed

                    while (binaryStr.Length < 8 && binaryStr.Length > 0)

                    {

                        binaryStr = '0' + binaryStr;

                    }

                    if (binaryStr.Length == 8)

                    {

                        try

                        {

                            int value = Convert.ToInt32(binaryStr, 2);

                            result.Append((char)value);

                        }

                        catch

                        {

                            // Ignore invalid binary strings

                        }

                    }

                    currentBinaryChar.Clear();

                }

                if (c == '\n')

                {

                    result.Append('\n');

                }

            }

            else if (c == '0' || c == '1')

            {

                currentBinaryChar.Append(c);

            }

            // Ignore other characters

        }

        // Process any remaining binary characters

        if (currentBinaryChar.Length > 0)

        {

            string binaryStr = currentBinaryChar.ToString();

            while (binaryStr.Length < 8 && binaryStr.Length > 0)

            {

                binaryStr = '0' + binaryStr;

            }

            if (binaryStr.Length == 8)

            {

                try

                {

                    int value = Convert.ToInt32(binaryStr, 2);

                    result.Append((char)value);

                }

                catch

                {

                    // Ignore invalid binary strings

                }

            }

        }

        return result.ToString();

    }

}