public static void And_EmptyArray()
 {
     BitArray bitArray1 = new BitArray(0);
     BitArray bitArray2 = new BitArray(0);
     
     Assert.Equal(0, bitArray1.And(bitArray2).Length);
 }

 public void UpdateScreen(BitArray bitData)
 {
     for (int i = 0; i < pixelsObjects.Count; i++)
     {
         pixelsObjects[i].SetActive(bitData[i]);
     }
 }

	// Use this for initialization
	void Start () {
		
		
		
		object[] obj = GameObject.FindSceneObjectsOfType(typeof (GameObject));		
		foreach (object o in obj)
		{
			GameObject g = (GameObject) o;
			if(g.GetComponent<PhotoEye>()!=null)
			{
				if(g.GetComponent<PhotoEye>().IO_name_photoeye==IO_name_photoeye_trigger)
				{
					g.GetComponent<PhotoEye>().ConnectATR(gameObject);
				}
			}
		}
		encoding = new System.Text.ASCIIEncoding();		
		
		max_emu_to_plc_io = 1600; // 200 bytes
		emu_to_plc_bits = new BitArray(max_emu_to_plc_io);
		
		
		
		
		Logger.WriteLine("[INFO]","STARTUP AtrsCom on port " + ATR_PORT + " linked to photoeye " + IO_name_photoeye_trigger,"",true);
		Debug.Log("STARTUP AtrsCom on port " + ATR_PORT + " linked to photoeye " + IO_name_photoeye_trigger+".\r\n");
		ready = true;
		
		listenerThread = new Thread(new ThreadStart(DoListen));
        listenerThread.Start();
		
		
	}

 public static string Read()
 {
     String xd;
     using(StreamReader reader = new StreamReader("Output.txt"))
     {
         xd = reader.ReadToEnd();
     }
     string[] c = xd.Split(' ');
     List<byte> outputs = new List<byte>();
     foreach(string x in c)
     {
         char[] d = x.ToCharArray();
         BitArray Out = new BitArray(8);
         if (d.Length != 8)
         {
             continue;
         }
         for(int i = 0; i < 8; i++)
         {
             Out[i] = d[i] == 'x';
         }
         outputs.Add(ConvertToByte(Out));
     }
     return Encoding.ASCII.GetString(outputs.ToArray());
 }

 static void Main()
 {
     BitArray bits = new BitArray(8);
     bits[0] = 1;
     bits[7] = 1;
     System.Console.WriteLine(bits);
 }

	public static string Decode (Texture2D image){
		
		//Get the pixels for the image...
		Color[] imagePixels = image.GetPixels();
		
		//Go Through the First 32 Pixels and create a 4 byte array. 
		//This array should give us the message's length.	
		BitArray newBits = new BitArray(32);
		for (int i=0;i<32;i++){
			if(imagePixels[i].a == 1){
				newBits[i] = true;
			}
			else {
				newBits[i] = false;
			}
		}
		
		int total = System.BitConverter.ToInt32(ToByteArray(newBits), 0);
		BitArray messageBits = new BitArray(total);
		for (int j=32;j<total + 32;j++){
				if(imagePixels[j].a == 1){
					messageBits[j-32] = true;
				}
				else {
					messageBits[j-32] = false;
				}
		}
		
		return System.Text.Encoding.ASCII.GetString(ToByteArray(messageBits));
		
	}

    private void renderCurrentState()
    {
        int i;
        BitArray stacks = new BitArray( brain.getKnownObjects().Count );

        foreach ( iThinkFact fact in brain.curState.getFactList() )
        {
            if ( fact.getName().Equals( "onTable" ) )
            {
                i = findNextFreeStack( stacks );
                fact.getObj( 0 ).transform.position = new Vector3( (float)( 1.5 - i * 1.5 ), 0, 0 );
                stacks.Set( i - 1, true );
            }
        }

        foreach ( iThinkFact fact in brain.curState.getFactList() )
        {
            if ( fact.getName().Equals( "on" ) )
            {
                fact.getObj( 0 ).transform.position = fact.getObj( 1 ).transform.position;
                fact.getObj( 0 ).transform.Translate( 0, (float)1.5, 0 );
            }

            else if ( fact.getName().Equals( "holding" ) )
            {
                fact.getObj( 0 ).transform.position = new Vector3( -15, 5, 0 );
            }
        }
    }

        static void Main()
        {
            BitArray bits = new BitArray();

            //Random set of bits
            for (int i = 0; i < 64; i++)
            {
                Random random = new Random();
                StringBuilder getTime = new StringBuilder();
                
                int randomNumber = (int)DateTime.Now.Ticks;

                //Трябва ми време за да се получи добър random
                for (int j = 0; j < 100000; j++)
                {
                    Math.Sqrt(j + 1);
                }
                //Край на губенето на време

                if (randomNumber % 2 == 0)
                {
                    bits[i] = 1;
                }
            }

            Console.WriteLine(bits);

            //Print all Bits
            foreach (var item in bits)
            {
                Console.Write(item);
            }
            Console.WriteLine();
        }

        public static void Not(int length)
        {
            BitArray bitArray = new BitArray(length, false);
            if (length > 0)
            {
                bitArray[0] = true;
                bitArray[1] = true;
                bitArray[length - 2] = true;
                bitArray[length - 1] = true;
            }

            BitArray bitArrayNot = bitArray.Not();
            Assert.Equal(bitArray.Length, bitArrayNot.Length);
            Assert.Same(bitArray, bitArrayNot);
            for (int i = 0; i < bitArray.Length; i++)
            {
                if (i <= 1 || i >= length - 2)
                {
                    Assert.False(bitArrayNot[i]);
                }
                else
                {
                    Assert.True(bitArrayNot[i]);
                }
            }
        }

    static void Main()
    {
        BitArray bits = new BitArray(100000);
        bits[99999] = 1;

        Console.WriteLine(bits.ToString());
    }

 static void Main()
 {
     BitArray num = new BitArray(8);
     num[0] = 1;
     num[7] = 1;
     Console.WriteLine(num);
 }

    static void Main()
    {
        int n = 10000000;
        int m = (int)Math.Sqrt(n);
        BitArray sieve = new BitArray(n);

        int i = 2;
        while (i <= m)
        {
            for (int j = 2 * i; j < n; j += i)
            {
                sieve[j] = true;
            }
            do
            {
                i++;
            }
            while (sieve[i] == true);
        }

        //print just the prime numbers up to 100
        for (int j = 2; j < 100; j++)
        {
            if (sieve[j] == false)
            {
                Console.WriteLine(j);
            }
        }
    }

    public BitArray GetBitsStuffed()
    {
        int nstuff = 0;
        bool last = false;
        BitArray ba = new BitArray();
        foreach (bool bit in GetBitsUnstuffed().Bits())
        {
            if (bit == last)
                nstuff++;
            else
            {
                nstuff = 1;
                last = bit;
            }

            if (nstuff > 5)
            {
                ba.AddBit(!last);
                nstuff = 1;
            }

            ba.AddBit(bit);
        }

        return ba;
    }

    public void loadSaveData(int id)
    {
        currentFlag.SetAll(false);

        //load file
        string filepath = string.Format("{0}/sav{1}", Application.persistentDataPath, id);
        Debug.Log(filepath);

        if (!File.Exists(filepath))
        {
            //show error
            return;
        }

        FileStream fs = File.Open(filepath, FileMode.Open);

        BinaryReader reader = new BinaryReader(fs);
        currentID = reader.ReadInt32();
        byte[] buf = reader.ReadBytes(10);
        currentFlag = new BitArray(buf);

        for (int i = (int)GameValueType.None; i < (int)GameValueType.Max; i++ )
        {
            values[(GameValueType)i] = reader.ReadInt32();
        }

        fs.Flush();
        fs.Close();

        startGame();
    }

        private static void TestSequentialInv(int count)
        {
            BitArray array = new BitArray(false, count);
            for (int x = 0; x < count; x++)
            {
                if (array.GetBit(x))
                    throw new Exception("each bit should be cleared");
            }

            array = new BitArray(true, count);
            for (int x = 0; x < count; x++)
            {
                if (!array.GetBit(x))
                    throw new Exception("each bit should be set");
            }
            for (int x = 0; x < count; x++)
            {
                array.ClearBit(x);
                if (array.GetBit(x))
                    throw new Exception("each bit should be cleared");
                array.SetBit(x);
                if (!array.GetBit(x))
                    throw new Exception("each bit should be cleared");
                array.ClearBit(x);

                if (array.FindSetBit() != (x == count - 1 ? -1 : x + 1))
                    throw new Exception();
            }
        }

    static void Main()
    {
        int maxNum = 10000000;

        BitArray primeNumbers = new BitArray(maxNum, true);

        for (int i = 2; i < Math.Sqrt(maxNum); i++)
        {
            if (primeNumbers[i] == true)
            {
                for (int j = i * i; j < maxNum; )
                {
                    primeNumbers[j] = false;
                    j += i;
                }
            }
        }

        for (int i = 0; i < primeNumbers.Count; i++)
        {
            if (primeNumbers[i] == true)
            {
                Console.Write("{0} ",i);
            }
        }
    }

    public static LinkedList<Point> GetWalkingSteps(Point start, BitArray goals, bool walkInWater = false, bool nearbyOk = false)
    {
        Bb.ReadBoard();

        if (!goals.ToPoints().Any())
        {
            return null;
        }
        Point[] starts = { start };
        var passable = Solver.GetPassable(true);
        var aStarPassable = new BitArray(passable);
        aStarPassable.Set(start, true);
        if (nearbyOk)
        {
            aStarPassable.Or(goals);
        }
        Func<Point, Point, int> cost = (c, n) => (Bb.Water.Get(n) && !walkInWater) ? 10 : 1;
        var route = Pather.AStar(starts, p => goals.Get(p), aStarPassable, cost, p => 0);
        if (route == null)
        {
            return null;
        }
        var steps = new LinkedList<Point>(route);
        steps.RemoveFirst();
        if (steps.Count > 0 && !passable.Get(steps.Last.Value))
        {
            steps.RemoveLast();
        }
        return steps;
    }

	public void Load(int Index){
			MemoryMappedFileSecurity CustomSecurity = new MemoryMappedFileSecurity();
CustomSecurity.AddAccessRule(new System.Security.AccessControl.AccessRule<MemoryMappedFileRights>("everyone", MemoryMappedFileRights.FullControl, System.Security.AccessControl.AccessControlType
.Allow));
			using(MemoryMappedFile mmf = MemoryMappedFile.CreateOrOpen("bits", (long)Math.Ceiling(Length/8.0), MemoryMappedFileAccess.ReadWriteExecute, MemoryMappedFileOptions.None, CustomSecurity, System.IO.HandleInheritability.Inheritable)){
			using (MemoryMappedViewStream stream = mmf.CreateViewStream())
           		{
				int Amount = (int)Math.Ceiling((double)(Length/Int32.MaxValue));
				int Remainder = (int)(Length%Int32.MaxValue);
				int length = (int)(Amount==Index?Math.Ceiling(Remainder/8.0):Math.Ceiling(Int32.MaxValue/8.0));
				byte[] buffer = BitArrayToByteArray(LoadedArray,0,LoadedArray.Length);
				stream.Position=(long)Math.Ceiling((Int32.MaxValue/8.0))*LoadedArrayIndex;
                		BinaryWriter writer = new BinaryWriter(stream);
				writer.Write(buffer);
				stream.Position=0;//(long)Math.Ceiling((Int32.MaxValue/8.0))*Index;
				BinaryReader reader = new BinaryReader(stream);
				buffer = new byte[(int)Math.Ceiling((Int32.MaxValue/8.0))];
				try{reader.Read(buffer,(int)Math.Ceiling((Int32.MaxValue/8.0))*Index,(int)Math.Ceiling((Int32.MaxValue/8.0)));} catch{LoadedArray = new BitArray((int)(length*8.0));}
           		}
			}
			//int ElementIndex = (int)Math.Floor((double)(T/Int32.MaxValue));
			//int Index = (int)(T%Int32.MaxValue);
			//Elements[ElementIndex][Index]=value;
		//}
	}

    // Update is called once per frame
    void Update()
    {
        if (ListenClient.ori != null && ListenClient.ori.Length > 4)
        {
            //Debug.Log (ListenClient.ori);
            string[] difPos = ListenClient.ori.Split('_');
            Debug.Log (difPos);
            string[] pos = difPos[0].Split(' ');

            double accel = double.Parse(difPos[1]);
            if (accel >= 7000 && !audio.isPlaying) {
                audio.Play ();
            }
            int button = int.Parse(difPos[2]);
            int trigger = int.Parse(difPos[3]);
            Debug.Log (button);
            b = new BitArray (new int[] { button });
            bool[] bits = new bool[32];
            if (button != 0) {
                b.CopyTo (bits, 0);

            }
            Debug.Log ("button " + bits[19]);
            if (bits [19]) {
                globalExtended = true;
            } else {
                globalExtended = false;
            }

            if (pos.Length >= 4)
            {
                Quaternion q = new Quaternion(float.Parse(pos[1]), float.Parse(pos[2]), float.Parse(pos[3]), float.Parse(pos[0]));
                //q = upInv * q;
                //q = Quaternion.Inverse(q);
                Vector3 e = q.eulerAngles;
                e.x *= -1;
                e.y *= -1;
                pivot.transform.rotation = Quaternion.Euler(e);
                //Debug.Log("transformed");
            }

        }

        if (ListenClient.pos != null && ListenClient.pos.Length > 5)
        {
            string[] strPos = ListenClient.pos.Split(';');
            for (int i = 0; i < strPos.Length; i++)
            {
                if (strPos[i].Contains("rwrist"))
                {
                    string[] headPos = strPos[i].Split(' ');
                    Debug.Log("POS: " + ListenClient.pos);
                    Debug.Log("i: " + strPos[i]);
                    transform.position =
                        new Vector3(float.Parse(headPos[1]) * 5, float.Parse(headPos[2]) * 5, 7 - float.Parse(headPos[3]) * 2);
                    break;
                }
            }
        }
    }

    public BitArray GenerateSubset(
            int n, int k, BigInteger i, BitArray b, int offset)
    {
        BigInteger upperBound = Choose(n, k);
        if (i>=upperBound) {
            // There are only nCk possible subsets to return.
            return null;
        }

        int zeros = 0; // Count of zeros on the front before the first 1.
        BigInteger low = BigInteger.ZERO;
        BigInteger high = Choose(n-1, k-1);
        while (i>=high){
            zeros += 1;
            low = high;
            high = high+Choose(n-zeros-1, k-1);
        }

        if (zeros + k > n) {
            // Something is wrong! Not enough bits exist.
            throw new Exception("Too many zeros!");
        }

        b[offset+zeros] = true;

        if (k == 1) return b;
        else return GenerateSubset(
                n-zeros-1, k-1, i-low, b, offset+zeros+1);
    }