Pasted

using System.Collections;
using System.Linq;
 
namespace Cryptos
{
    class Key
    {
        const int key_length = 64;
 
        BitArray key;
        BitArray temp_key;
 
        BitArray register19;
        BitArray register22;
        BitArray register23;
 
        public int[] shift19 { get; set; }
        public int[] shift22 { get; set; }
        public int[] shift23 { get; set; }
 
        public int majority19 { get; set; }
        public int majority22 { get; set; }
        public int majority23 { get; set; }
 
        private bool majority_winner()
        {
            int count = 0;
            if (register19[majority19 - 1] == true)
                count++;
 
            if (register22[majority22 - 1] == true)
                count++;
 
            if (register23[majority23 - 1] == true)
                count++;
 
            if (count > 1)
                return true;
 
            return false;
        }
        public bool Step()
        {
            bool m_winner = majority_winner();
 
            if (register19[majority19 - 1] == m_winner)
            {
                bool new_bit = register19[shift19[0] - 1];
                for(int i=1; i<shift19.Length; i++)
                    new_bit = new_bit ^ register19[shift19[i] - 1];
 
                for (int i = register19.Length-1; i > 0; i--)
                    register19[i] = register19[i-1];
 
                register19[0] = new_bit;
            }
 
            if (register22[majority22 - 1] == m_winner)
            {
                bool new_bit = register22[shift22[0] - 1];
                for (int i = 1; i < shift22.Length; i++)
                    new_bit = new_bit ^ register22[shift22[i] - 1];
 
                for (int i = register22.Length - 1; i > 0; i--)
                    register22[i] = register22[i - 1];
 
                register22[0] = new_bit;
            }
 
            if (register23[majority23 - 1] == m_winner)
            {
                bool new_bit = register23[shift23[0] - 1];
                for (int i = 1; i < shift23.Length; i++)
                    new_bit = new_bit ^ register23[shift23[i] - 1];
 
                for (int i = register23.Length - 1; i > 0; i--)
                    register23[i] = register23[i - 1];
 
                register23[0] = new_bit;
            }
 
            return register19[register19.Length - 1] ^ register22[register22.Length - 1] ^ register23[register23.Length - 1];
 
        }
 
        //Get key STRING
        public string GetKeyString()
        {
            string key_string = "";
            int i;
            for (i = 0; i < key_length; i++)
            {
                if (key[i] == true)
                    key_string += "1";
                else
                    key_string += "0";
            }
                
 
            return key_string;
        }
 
        public string ShiftString(int register)
        {
            string result = "";
            int i;
            if (register == 19)
            {
                for (i = 0; i < shift19.Length-1; i++)
                    result += shift19[i] + " ";
                result += shift19[i];
                return result;
            }
            else if (register == 22)
            {
                for (i = 0; i < shift22.Length-1; i++)
                    result += shift22[i] + " ";
                result += shift22[i];
                return result;
            }
            else if (register == 23)
            {
                for (i = 0; i < shift23.Length-1; i++)
                    result += shift23[i] + " ";
                result += shift23[i];
                return result;
            }
            else
                throw new System.Exception("Bad register!");
        }
 
        //Checks is argument valid key
        public bool isKey(string new_key)
        {
            if (new_key.Length != key_length)
                return false;
 
            int result;
            temp_key = new BitArray(key_length);
 
            for (int i = 0; i < key_length; i++)
            {
                if (int.TryParse(new_key[i].ToString(), out result))
                {
                    if (result == 1)
                        temp_key[i] = true;
                    else if (result == 0)
                        temp_key[i] = false;
                    else
                        return false;
                }
                else
                    return false;
            }
 
            return true;
        }
 
        //Checks is bit valid majority bit in register
        public bool isMajority(string bit, int register)
        {
            int bit_index;
 
            if (!int.TryParse(bit, out bit_index))
                return false;
 
            if(register == 19 || register == 22 || register == 23)
            {
                if (bit_index > 0 && bit_index <= register)
                    return true;
 
                return false;
            }
 
            return false;
        }
 
 
        //Check are bits valid shift bits in register
        public bool isShift(string bits, int register)
        {
            bits = bits.Trim();
            string[] parts = bits.Split(' ');
            int result;
 
            if (parts.Length > 0)
            {
                if (register == 19 || register == 22 || register == 23)
                {
                    for(int i=0; i<parts.Length; i++)
                    {
                        if (!int.TryParse(parts[i], out result))
                            return false;
                        else
                            if (result < 1 || result > register)
                                return false;
                    }
 
                    return true;
                }
 
                return false;
            }
            else
                return false;
        }
 
        //Set argument as new key
        public bool SetKey(string new_key)
        {
            key = new BitArray(key_length);
            if (isKey(new_key))
            {
                register19 = new BitArray(19);
                register22 = new BitArray(22);
                register23 = new BitArray(23);
 
                for (int i = 0; i < key_length; i++)
                {
                    if (i < 19)
                        register19[i] = temp_key[i];
 
                    if (i >= 19 && i < 41)
                        register22[i-19] = temp_key[i];
 
                    if (i >= 41 && i < 64)
                        register23[i - 41] = temp_key[i];
 
                    key[i] = temp_key[i];
                }
 
                return true;
            }
            else
                return false;
        }
 
        //Set bit as new majority bit in register
        public bool SetMajority(string bit, int register)
        {
            if (isMajority(bit, register))
            {
                if (register == 19)
                    majority19 = int.Parse(bit);
                else if (register == 22)
                    majority22 = int.Parse(bit);
                else if (register == 23)
                    majority23 = int.Parse(bit);
                else
                    return false;
 
                return true;
            }
            else
                return false;
        }
 
        //Set bit as new shift bits in register
        public bool SetShift(string bits, int register)
        {
            if (!isShift(bits, register))
                return false;
 
            string[] parts = bits.Split(' ');
 
            if (register == 19)
            {
                if (parts.Length > 19)
                    return false;
 
                shift19 = new int[parts.Length];
 
                for (int i = 0; i < parts.Length; i++)
                    shift19[i] = int.Parse(parts[i]);
            }
            else if (register == 22)
            {
                if (parts.Length > 22)
                    return false;
 
                shift22 = new int[parts.Length];
 
                for (int i = 0; i < parts.Length; i++)
                    shift22[i] = int.Parse(parts[i]);
            }
            else if (register == 23)
            {
                if (parts.Length > 23)
                    return false;
 
                shift23 = new int[parts.Length];
 
                for (int i = 0; i < parts.Length; i++)
                    shift23[i] = int.Parse(parts[i]);
            }
            else
                return false;
 
            return true;
 
        }
    }
}