internal AsyncResult(string message, int ftpCode, int result)
 {
     m_result = new BitArray(3);
     m_message = message;
     m_ftpResponse = ftpCode;
     m_result[result] = true;
 }

        private ADNode MakeADTree(int i, BitArray recordNums, int depth, Varset variables)
        {
            // since this is index i, there are (variableCount - i) remaining variables.
            // therefore, it will have that many children
            int count = 0;
            for(int idx = 0; idx < recordNums.Count; idx++)
            {
                if (recordNums[idx])
                {
                    count += 1;
                }
            }
            ADNode adn = new ADNode(network.Size() - i, count);

            // check if we should just use a leaf list
            if (adn.Count < rMin)
            {
                BitArray leafList = new BitArray(recordNums);
                adn.LeafList = leafList;
                return adn;
            }

            // for each of the remaining variables
            for (int j = i; j < network.Size(); j++)
            {
                // create a vary node
                variables.Set(j, true);
                Varset newVariables = new Varset(variables);
                VaryNode child = MakeVaryNode(j, recordNums, depth, newVariables);
                adn.SetChild(j - i, child);
            }

            return adn;
        }

        /*
        // It mutates the Chromosome
        //
        // @input probability is a double >=0 and <=100
        */
        public bool Mutate(double probability)
        {
            if (probability < 0) probability = 0;
            if (probability > 100) probability = 100;
            bool isMutated = false;
            for (int counter = 0; counter<nucleotideList.Count; counter++)
            {
                byte myByte = nucleotideList[counter];
                //var bits = new BitArray(myByte);
                var bits = new BitArray(new byte[] { myByte });
                //Cycle for change the single bit of the DNA
                for (int i = 0; i < bits.Length; i++)
                {
                    Random r = new Random(Guid.NewGuid().GetHashCode());
                    if (r.NextDouble() < (probability / 100))
                    {
                        bits[i] = !bits[i]; //the mutation switch the bit
                        isMutated = true;
                    }
                }
                //From BitArray to Byte[]
                byte[] ret = new byte[bits.Length / 8];
                bits.CopyTo(ret, 0);

                //Assigning the new Byte[] to the nucleotide
                nucleotideList[counter] = ret[0];
            }
                
            return isMutated;
        }

        private void Setup()
        {
            // Fill Bit arrays

            chka = new[] {
                flag_0001,flag_0002,flag_0003,flag_0004,flag_0005,
                flag_2237,flag_2238,flag_2239,
                flag_0115,flag_0963, // Mewtwo
                flag_0114,flag_0790, // Zygarde
                flag_0285,flag_0286,flag_0287,flag_0288,flag_0289, // Statuettes
                flag_0290,flag_0291,flag_0292,flag_0293,flag_0294, // Super Unlocks
                flag_0675, // Chatelaine 50
                flag_2546, // Pokedex
            };
            byte[] data = new byte[0x180];
            Array.Copy(Main.SAV.Data, Main.SAV.EventFlag, data, 0, 0x180);
            BitArray BitRegion = new BitArray(data);
            BitRegion.CopyTo(flags, 0);

            // Setup Event Constant Editor
            CB_Stats.Items.Clear();
            for (int i = 0; i < Constants.Length; i += 2)
            {
                CB_Stats.Items.Add($"0x{i.ToString("X3")}");
                Constants[i / 2] = BitConverter.ToUInt16(Main.SAV.Data, Main.SAV.EventConst + i);
            }
            CB_Stats.SelectedIndex = 0;

            // Populate Flags
            setup = true;
            popFlags();
        }

 public CompleteGraph(int n)
 {
     if (n <= 0)
         throw new ArgumentOutOfRangeException("[CompleteGraph Constructor] Input size of CompleteGraph must be positive");
     this.nodes = n;
     this.edges = new BitArray(n * (n - 1) / 2);
 }

 public static bool[] GetBoolArrayFromByte(byte[] bytes)
 {
     bool[] bools = new bool[bytes.Length * 8];
     BitArray bits = new BitArray(bytes);
     bits.CopyTo(bools, 0);
     return bools;
 }

        public SlabAllocator(int pageSize, int pageCount)
        {
            _pageSize = pageSize;
            _totalSize = pageCount * pageSize;

            _allocationMap = new BitArray(pageCount);
        }

 internal virtual void DoPrevSetBit(BitArray a, LongBitSet b)
 {
     int aa = a.Count + Random().Next(100);
     long bb = aa;
     do
     {
         //aa = a.PrevSetBit(aa-1);
         aa--;
         while ((aa >= 0) && (!a.SafeGet(aa)))
         {
             aa--;
         }
         if (b.Length() == 0)
         {
             bb = -1;
         }
         else if (bb > b.Length() - 1)
         {
             bb = b.PrevSetBit(b.Length() - 1);
         }
         else if (bb < 1)
         {
             bb = -1;
         }
         else
         {
             bb = bb >= 1 ? b.PrevSetBit(bb - 1) : -1;
         }
         Assert.AreEqual(aa, bb);
     } while (aa >= 0);
 }

		/// <summary>
		/// get the B&W 1BPP bitmap for a bmp file 
		/// </summary>
		/// <param name="bmpFileName">
		/// </param>
		/// <returns>
		/// </returns>
        private static BitmapDotData GetBitmapData(string bmpFileName)
        {
            Image img = new Bitmap(bmpFileName); 
            using (var bitmap = new Bitmap(img))// (Bitmap)Bitmap.FromFile(bmpFileName))
            {
                var threshold = 127;
                var index = 0;
                var dimensions = bitmap.Width * bitmap.Height;
                var dots = new BitArray(dimensions);

                for (var y = 0; y < bitmap.Height; y++)
                {
                    for (var x = 0; x < bitmap.Width; x++)
                    {
                        var color = bitmap.GetPixel(x, y);
                        var luminance = (int)(color.R * 0.3 + color.G * 0.59 + color.B * 0.11);
                        dots[index] = (luminance < threshold);
                        index++;
                    }
                }

                return new BitmapDotData()
                    {
                        Dots = dots,
                        Height = bitmap.Height,
                        Width = bitmap.Width
                    };
            }
        }

 public ArrayFieldOfView(IFovBoard<IHex> board)
 {
     _isOnboard = h => board.IsOnboard(h);
     _fovBacking = new BitArray[board.MapSizeHexes.Width];
     for (var i = 0; i < board.MapSizeHexes.Width; i++)
         _fovBacking[i] = new BitArray(board.MapSizeHexes.Height);
 }

 private void TM1638ButtonsMessageReader(IList<int> messageData)
 {
     int readPos = 1;
     for (int u = 1; u <= this.numberUnits; u++)
     {
         if (this.tm1640Units[u - 1])
         {
             continue;
         }
         this.buttonsRead = messageData[readPos++];
         if (this.buttonsRead != -1)
         {
             this.butByte[0] = Convert.ToByte(this.buttonsRead);
             this.buttons = new BitArray(this.butByte);
             for (var i = 0; i < Constants.NumberButtonsOnTm1638; i++)
             {
                 if (this.buttons[i])
                 {
                     if (this.ButtonPress == null) throw new ArgumentNullException();
                     ButtonPressEventHandler temp = this.ButtonPress;
                     if (temp != null)
                     {
                         temp(u, i+1);
                     }
                 }
             }
         }
     }
 }

        static IList<string> GetCombines(string str)
        {
            var result = new List<string>();
            var arr = str.Split(',');
            var numItem = arr.Length;

            for (int i = 1; i <= Math.Pow(2, numItem); i++)
            {
                string temp = null;
                BitArray b = new BitArray(new int[] { i });
                for (int j = 0; j < numItem; j++)
                {
                    if (b[j])
                    {
                        if (temp != null)
                        {
                            temp += ",";
                        }

                        temp += arr[j];
                    }
                }

                if (!string.IsNullOrEmpty(temp))
                {
                    result.Add(temp);
                }
            }

            return result;
        }

 /// <summary>
 ///   Get bytes array from Boolean values.
 /// </summary>
 /// <param name = "array">Array to be packed</param>
 /// <returns>Bytes array</returns>
 public static byte[] GetByteArrayFromBool(bool[] array)
 {
     BitArray b = new BitArray(array);
     byte[] bytesArr = new byte[array.Length / 8];
     b.CopyTo(bytesArr, 0);
     return bytesArr;
 }

        private static void WriteBitArray(ObjectWriter writer, BitArray bitArray)
        {
            // Our serialization format doesn't round-trip bit arrays of non-byte lengths
            Contract.ThrowIfTrue(bitArray.Length % 8 != 0);

            writer.WriteInt32(bitArray.Length / 8);

            // This will hold the byte that we will write out after we process every 8 bits. This is
            // LSB, so we push bits into it from the MSB.
            byte b = 0;

            for (var i = 0; i < bitArray.Length; i++)
            {
                if (bitArray[i])
                {
                    b = (byte)(0x80 | b >> 1);
                }
                else
                {
                    b >>= 1;
                }

                if ((i + 1) % 8 == 0)
                {
                    // End of a byte, write out the byte
                    writer.WriteByte(b);
                }
            }
        }

 /// <summary>
 /// aaa -> 000aaa
 /// </summary>
 /// <param name="to">Reference to array to put the result</param>
 /// <param name="bitArray">Array from where to put</param>
 /// <param name="p">Size of the new array</param>
 private void ExtendToSizeRight(ref BitArray to, BitArray bitArray, int p)
 {
     if (to == null)
         to = new BitArray(p, false);
     for (int i = 0; i < bitArray.Length; i++)
         to[i] = bitArray[i];
 }

        protected override AnalogicDataRegisterDE ReadValues(FileStream fstream, string Name, long HeaderLen, DateTime dateHourMinute)
        {
            AnalogicDataRegisterDE measurement;
            DateTime DataDosValores;
            char[] Dbuffer;

            BitArray myBA;

            fstream.Position = HeaderLen - DataDosValoresLen;

            Dbuffer = new char[DataDosValoresLen];
            r.Read(Dbuffer,0,DataDosValoresLen);
            DataDosValores = ConvertDateTime.DateVmsToDateTime(Dbuffer,"pt-BR");

            fstream.Position = HeaderLen + ((int) htHeader[Name] * NumBValGr);
            float measAux = r.ReadSingle();
            float estimAux = r.ReadSingle();
            byte[] BBuffer = new byte[NumBValGr - 8];
            BBuffer = r.ReadBytes(NumBValGr - 8);

            if(BBuffer.Length > 1)
            {
                byte[] aux = new byte[1];
                aux[0] = BBuffer[1];
                myBA = new BitArray(aux);
            }
            else myBA = new BitArray(BBuffer);

            if(DataDosValores.Date == dateHourMinute.Date)
                measurement = new AnalogicDataRegisterDE(dateHourMinute,Name,measAux,estimAux,myBA);
            else
                measurement = new AnalogicDataRegisterDE(Name,dateHourMinute,true);

            return measurement;
        }

        public static int[] ESieve(int upperLimit)
        {
            int sieveBound = (int)(upperLimit - 1) / 2;
            int upperSqrt = ((int)Math.Sqrt(upperLimit) - 1) / 2;

            BitArray PrimeBits = new BitArray(sieveBound + 1, true);

            for (int i = 1; i <= upperSqrt; i++)
            {
                if (PrimeBits.Get(i))
                {
                    for (int j = i * 2 * (i + 1); j <= sieveBound; j += 2 * i + 1)
                    {
                        PrimeBits.Set(j, false);
                    }
                }
            }

            List<int> numbers = new List<int>((int)(upperLimit / (Math.Log(upperLimit) - 1.08366)));
            numbers.Add(2);

            for (int i = 1; i <= sieveBound; i++)
            {
                if (PrimeBits.Get(i))
                {
                    numbers.Add(2 * i + 1);
                }
            }

            return numbers.ToArray();
        }

        public static Byte[] GenerateHeader(Boolean fin, Boolean rsv1, Boolean rsv2, Boolean rsv3, Boolean opt4, Boolean opt3, Boolean opt2, Boolean opt1, Boolean mask)
        {
            Boolean[] header1 = new Boolean[8];
            header1[7] = fin;
            header1[6] = rsv1;
            header1[5] = rsv2;
            header1[4] = rsv3;
            header1[3] = opt4;
            header1[2] = opt3;
            header1[1] = opt2;
            header1[0] = opt1;

            Boolean[] header2 = new Boolean[8];
            header2[7] = mask;
            header2[6] = false;
            header2[5] = false;
            header2[4] = false;
            header2[3] = false;
            header2[2] = false;
            header2[1] = false;
            header2[0] = false;


            BitArray bitArray1 = new BitArray(header1);
            Byte[] byteHead = new Byte[2];
            bitArray1.CopyTo(byteHead, 0);

            BitArray bitArray2 = new BitArray(header2);
            bitArray2.CopyTo(byteHead, 1);

            return byteHead;
        }

 /// <summary>
 ///   Get bytes bools from Boolean values.
 /// </summary>
 /// <param name = "bools">Array to be packed</param>
 /// <returns>Bytes bools</returns>
 public static byte[] GetByteArrayFromBool(bool[] bools)
 {
     BitArray bits = new BitArray(bools);
     byte[] bytes = new byte[bools.Length / 8];
     bits.CopyTo(bytes, 0);
     return bytes;
 }

        public static bool verificarPermissao(Type tipoEntidadeVerificar, string chavePerfilCripto)
        {
            bool resultadoVerificacao = false;
            BitArray arrayChaveDecripto = null;
            byte[] preChavePerfilDecripto = new byte[ControladorAcesso.tamanhoChavePerfil];
            bool[] chavePerfilDecripto = new bool[ControladorAcesso.tamanhoChavePerfil];
            Criptografador cripto = new Criptografador();

            preChavePerfilDecripto = cripto.decriptografarTexto(ref chavePerfilCripto);

            arrayChaveDecripto = new BitArray(preChavePerfilDecripto);
            arrayChaveDecripto.Length = ControladorAcesso.tamanhoChavePerfil;

            arrayChaveDecripto.CopyTo(chavePerfilDecripto, 0);

            foreach (object atributo in tipoEntidadeVerificar.GetCustomAttributes(true))
                if (atributo.GetType().Name.Equals("PerfilAcesso"))
                {
                    long CodigoPerfil = long.Parse(atributo.GetType().GetField("CodigoPerfil").
                                                                      GetValue(atributo).ToString());

                    resultadoVerificacao = chavePerfilDecripto[CodigoPerfil];
                    break;
                }

            return resultadoVerificacao;
        }