using System;

using System.Collections;       

using System.Linq;

public class Program

{

    public static void Main()

    {

        var bytes = BitConverter.GetBytes(-2096229253);

        //var bytes = BitConverter.GetBytes(-2004904182);

        var bb0 = (byte)((bytes[0] * 0x0202020202 & 0x010884422010) % 1023); 

        var bb1 = (byte)((bytes[1] * 0x0202020202 & 0x010884422010) % 1023); 

        var bb2 = (byte)((bytes[2] * 0x0202020202 & 0x010884422010) % 1023); 

        var bb3 = (byte)((bytes[3] * 0x0202020202 & 0x010884422010) % 1023); 

        /*

        var testbits = new BitArray(new byte[] { bb  });    

        Console.WriteLine("testbits bits:");

        for (int i = 0; i < testbits.Length; i++)

        {

            Console.Write(testbits[i] == false ? "0" : "1");

        }*/

        //test

         bytes = new[] { bytes[1], bytes[0], bytes[3], bytes[2] };

        // bytes = new[] { bb2, bb3, bb0, bb1 };

        var newbytes = new[] { bytes[3], bytes[2], bytes[1], bytes[0] };

        //Console.WriteLine( BitConverter.ToSingle(newArray, 0));

        var bits = new BitArray(bytes); 

        var newbitArray = new BitArray(newbytes);

        int index =0;

        /*

        var newbitArray = new BitArray(32);

        for (int i = 7; i >= 0; i--)

        {

            //Console.Write(bits[i] == false ? "0" : "1");

            newbitArray.Set(index++, bits[i]);

        }

​

        for (int i = 15; i >= 8; i--)

        {

            //Console.Write(bits[i] == false ? "0" : "1");

            newbitArray.Set(index++, bits[i]);

        }

        for (int i = 23; i >= 16; i--)

        {

            newbitArray.Set(index++, bits[i]);

        }

        for (int i = 31; i >= 24; i--)

        {

            newbitArray.Set(index++, bits[i]);

        }

        */

        Console.WriteLine("Original bits:");

        for (int i = 0; i < bits.Length; i++)

        {

            Console.Write(bits[i] == false ? "0" : "1");

        }

        Console.WriteLine();

        Console.WriteLine("Swapped bits:");

        for (int i = 0; i < newbitArray.Length; i++)

        {

            Console.Write(newbitArray[i] == false ? "0" : "1");     

        }

        Console.WriteLine();

        //note: skip 31

        byte b = 0;

        /*

        if (newbitArray.Get(31)) b++;

        if (newbitArray.Get(30)) b += 2;

        if (newbitArray.Get(29)) b += 4;

        if (newbitArray.Get(28)) b += 8;

        if (newbitArray.Get(27)) b += 16;

        if (newbitArray.Get(26)) b += 32;

        if (newbitArray.Get(25)) b += 64;

        if (newbitArray.Get(24)) b += 128;

        */

        if (newbitArray.Get(24)) b++;

        if (newbitArray.Get(25)) b += 2;

        if (newbitArray.Get(26)) b += 4;

        if (newbitArray.Get(27)) b += 8;

        if (newbitArray.Get(28)) b += 16;

        if (newbitArray.Get(29)) b += 32;

        if (newbitArray.Get(30)) b += 64;

        if (newbitArray.Get(31)) b += 128;

        int intResult = b;  

        Console.WriteLine("Exponent value:");

        Console.WriteLine(intResult);

        // right shift... 

        var result = (byte) (b >> 1);

        intResult = result;

        Console.WriteLine("Right shifted exponent value:");

        Console.WriteLine(intResult);

        index = 7; //??

        var exponentByte = (byte)intResult;

        var exponentBits = new BitArray(new byte[] { exponentByte });   

        //Console.WriteLine(exponentBits.Length);

        for (int i = 31; i >= 23; i--)

        {

            if (i ==31)

            {

                newbitArray.Set(i, false);

            }

            else

            {

            //Console.WriteLine(i);

            newbitArray.Set(i, exponentBits[index--]);

            }

        }

        // subtract 2

        //intResult-=2;

       b = 0;

        /*if (newbitArray.Get(30)) b++;

        if (newbitArray.Get(29)) b += 2;

        if (newbitArray.Get(28)) b += 4;

        if (newbitArray.Get(27)) b += 8;

        if (newbitArray.Get(26)) b += 16;

        if (newbitArray.Get(25)) b += 32;

        if (newbitArray.Get(24)) b += 64;

        if (newbitArray.Get(23)) b += 128;*/

        if (newbitArray.Get(23)) b++;

        if (newbitArray.Get(24)) b += 2;

        if (newbitArray.Get(25)) b += 4;

        if (newbitArray.Get(26)) b += 8;

        if (newbitArray.Get(27)) b += 16;

        if (newbitArray.Get(28)) b += 32;

        if (newbitArray.Get(29)) b += 64;

        if (newbitArray.Get(30)) b += 128;

​

​

        intResult = b;

        intResult-=2;

        Console.WriteLine("Exponent minus 2:");

        Console.WriteLine(intResult);

        exponentByte = (byte)intResult;

        exponentBits = new BitArray(new byte[] { exponentByte });   

        index = 7;

        //Console.WriteLine(exponentBits.Length);

        for (int i = 31; i >= 23; i--)

        {

            if (i ==31)

            {

                newbitArray.Set(i, false);

            }

            else

            {

            //Console.WriteLine(i);

            newbitArray.Set(i, exponentBits[index--]);

            }

        }

        Console.WriteLine();

        Console.WriteLine("Final bit array:");

        for (int i = 0; i < newbitArray.Length; i++)

        {

            Console.Write(newbitArray[i] == false ? "0" : "1");     

        }

        Console.WriteLine();

        byte[] newBytes = new byte[4];

        newbitArray.CopyTo(newBytes, 0); 

        // test

        //newBytes = newBytes.Reverse().ToArray();

        var answer = BitConverter.ToSingle(newBytes, 0);

        Console.WriteLine("Final result:");

        Console.WriteLine(answer);

        byte[] newArray = new[] { newBytes[2], newBytes[3], newBytes[0], newBytes[1] };

        Console.WriteLine( BitConverter.ToSingle(newArray, 0));

    }

}