protected override string GetBenchmarkCommandStringPart(ComputeDevice benchmarkDevice, Algorithm algorithm)
 {
     return " --opencl --opencl-platform " + GPUPlatformNumber
         + " " + algorithm.ExtraLaunchParameters
         + " --benchmark-warmup 40 --benchmark-trial 20"
         + " --opencl-devices ";
 }

 public EncryptedAttribute( string key, string salt, Algorithm algorithm = Crypt.Algorithm.Rijndael )
 {
     var db = new Rfc2898DeriveBytes( key, Encoding.ASCII.GetBytes( salt ), 2 );
     this.Algorithm = algorithm;
     this.Key = db.GetBytes( KeySize( this.Algorithm ) / 8 );
     this.Vector = db.GetBytes( 16 );
 }

 /// <summary>
 /// Main constructor.
 /// </summary>
 /// <param name="KeyID">
 /// A <see cref="System.String"/>, the primary key ID.
 /// </param>
 /// <param name="SignKey">
 /// A <see cref="System.String"/>, the signing key ID.
 /// </param>
 /// <param name="SignDate">
 /// A <see cref="System.String"/>, the signature date (seconds from Epoch)
 /// </param>
 public Signature(string KeyID, string SignKey, string SignDate)
 {
     // sig:::17:F4B4B0CC797EBFAB:1223678701::::Enrico Zini <[email protected]>:10x:
     //			Console.WriteLine(String.Format("Key: {0} - SignKey: {1} - SignDate: {2}", KeyID, Key, Date));
     GPG gpg = new GPG(KeyID, Commands.List);
     gpg.Exec();
     foreach (string line in gpg.Output.Split('\n')) {
         RecordType tag = Utils.GetRecordType(Utils.GetField(line, 0));
         if (tag == RecordType.Signature) {
             string key = Utils.GetField(line, 4);
             string date = Utils.GetField(line, 5);
             if ((key == SignKey) && (date == SignDate)) {
                 this._algorithm = Utils.GetAlgorithm(Convert.ToInt32(Utils.GetField(line, 3)));
                 this._user = Utils.ParseUsername(Utils.GetField(line, 9));
                 this._signingKey = SignKey;
                 this._signingDate = SignDate;
                 // TODO: also parse the "10x" above? The docs give very poor info:
                 /*
                  * 11. Field:  Signature class.  This is a 2 digit hexnumber followed by
                  *             either the letter 'x' for an exportable signature or the
                  *             letter 'l' for a local-only signature.
                  *             The class byte of an revocation key is also given here,
                  *             'x' and 'l' ist used the same way.
                  */
             }
         }
     }
 }

        public Generator(string data)
        {
			byte[] d = Convert.FromBase64String(data);
			string strXML = Encoding.UTF8.GetString(d);
			XmlDocument doc = new System.Xml.XmlDocument();
			doc.LoadXml(strXML);

			XmlNode root = doc.SelectSingleNode("/vmp-lm-product");
			if (root == null) throw new ArgumentException("Invalid data: not a product information string");

			XmlNode attrProduct = root.SelectSingleNode("@product");
			if (attrProduct == null) throw new ArgumentException("Invalid data: information about product is missed");
			pProductCode = Convert.FromBase64String(attrProduct.Value);
			if (pProductCode.Length != 8) throw new ArgumentException("Invalid data: product code has incorrect length");

			XmlNode nodeAlgo = root.SelectSingleNode("@algorithm");
			if (nodeAlgo == null) throw new ArgumentException("Invalid data: missed encryption algorithm");
			switch (nodeAlgo.Value)
			{
				case "RSA":
					algo = new AlgorithmRSA(root);
					break;
				default:
					throw new ArgumentException("Invalid data: unsupported encryption algorithm");
			}
        }

        static void Main(string[] args)
        {
            var line = Console.ReadLine();
            var segments = line.Split(' ');

            var Rows = Convert.ToInt32(segments[0]);
            var Columns = Convert.ToInt32(segments[1]);
            var rotations = Convert.ToInt32(segments[2]);

            var matrix = new int[Rows][];
            for (int i = 0; i < Rows; i++)
            {
                line = Console.ReadLine();
                segments = line.Split(' ');
                matrix[i] = new int[segments.Length];

                for (int t = 0; t < segments.Length; t++)
                {
                    matrix[i][t] = Convert.ToInt32(segments[t]);
                }
            }

            var algorithm = new Algorithm();

            algorithm.Process(matrix, rotations);
        }

 public MiningAlgorithm(ComputeDevice dev, Algorithm algo)
 {
     this.AlgoRef = algo;
     // init speed that will be avaraged later
     this.AvaragedSpeed = algo.BenchmarkSpeed;
     this.MinerPath = MinerPaths.GetOptimizedMinerPath(dev, algo);
 }

        public static void ShowResults(Algorithm.MMatrixAlgorithm algorithm)
        {
            ResultsForm form = new ResultsForm();
            form.m_Algorithm = algorithm;

            form.ShowDialog();
        }

    public void Main()
    {
        var m = new Algorithm();

        m.TemplateMethod(new ClassA());
        m.TemplateMethod(new ClassB());
    }

        public override void Start(Algorithm miningAlgorithm, string url, string username)
        {
            CurrentMiningAlgorithm = miningAlgorithm;
            if (miningAlgorithm == null) return;

            string algo = "";
            string apiBind = "";
            string intensity = "";
            if (CurrentMiningAlgorithm.NiceHashID != AlgorithmType.CryptoNight) {
                algo = "--algo=" + miningAlgorithm.MinerName;
                apiBind = " --api-bind=" + APIPort.ToString();
                intensity = getIntensityString();
            }

            IsAPIReadException = CurrentMiningAlgorithm.NiceHashID == AlgorithmType.CryptoNight;

            LastCommandLine = algo +
                                  " --url=" + url +
                                  " --userpass=" + username + ":" + Algorithm.PasswordDefault +
                                  apiBind +
                                  " " + miningAlgorithm.ExtraLaunchParameters +
                                  intensity +
                                  " --devices ";

            LastCommandLine += GetDevicesCommandString();

            Path = GetOptimizedMinerPath(miningAlgorithm.NiceHashID);

            ProcessHandle = _Start();
        }

 /// <summary>
 /// Creates a new private key.
 /// </summary>
 /// <param name="keyProvider">The provider for the key. <see cref="KeyProviders"/> contains different types of providers.</param>
 /// <param name="keyName">The name of the key to persist. Use <c>null</c> to create an ephemeral key.</param>
 /// <param name="algorithm">The algorithm of the key. Not all providers support all algorithms.</param>
 /// <param name="keyUsage">Specifies the purpose of the key. This is not appicable to CNG algorithms.</param>
 /// <param name="keySize">The size of the key. Only valid for RSA keys.</param>
 /// <param name="overwrite">True to overwrite the provider's exisint private key, otherwise false.</param>
 /// <returns>A new private key.</returns>
 public static PrivateKey CreateNew(KeyProviderBase keyProvider, string keyName, Algorithm algorithm, KeyUsage keyUsage, int? keySize = null, bool overwrite = false)
 {
     var keySizeValue = keySize ?? 2048;
     KeySpec keySpec;
     var handle = keyProvider.CreateKey(keyName, keySizeValue, algorithm, overwrite, keyUsage, out keySpec);
     return new PrivateKey(handle, keyProvider, keySpec);
 }

        public void GetHashFile(Algorithm algorithm, bool useNullFile)
        {
            FileInfo file = null;

            if (!useNullFile)
            {
                string tempFile = Path.GetTempFileName();

                using (var sw = new StreamWriter(tempFile, false))
                {
                    for (int i = 0; i < 100; i++)
                    {
                        sw.Write(GenerateText(10, 500));
                        sw.Write(" ");
                    }
                }

                file = new FileInfo(tempFile);
            }

            string hashed = DataHashing.Compute(algorithm, file);

            Assert.IsTrue(DataHashing.Validate(algorithm, file, hashed));

            if (!useNullFile)
            {
                file.Delete();
            }
        }

        public void SetCurrentlySelected(ListViewItem lvi, ComputeDevice computeDevice)
        {
            // should not happen ever
            if (lvi == null) return;

            _computeDevice = computeDevice;
            var algorithm = lvi.Tag as Algorithm;
            if (algorithm != null) {
                _selected = true;
                _currentlySelectedAlgorithm = algorithm;
                _currentlySelectedLvi = lvi;
                this.Enabled = lvi.Checked;

                groupBoxSelectedAlgorithmSettings.Text = String.Format(International.GetText("AlgorithmsListView_GroupBox"),
                algorithm.GetName()); ;

                field_LessThreads.Enabled = _computeDevice.DeviceGroupType == DeviceGroupType.CPU;
                if (field_LessThreads.Enabled) {
                    field_LessThreads.EntryText = algorithm.LessThreads.ToString();
                }
                fieldBoxBenchmarkSpeed.EntryText = ParseDoubleDefault(algorithm.BenchmarkSpeed);
                richTextBoxExtraLaunchParameters.Text = ParseStringDefault(algorithm.ExtraLaunchParameters);
                this.Update();
            } else {
                // TODO this should not be null
            }
        }

 public SolutionStepCompletedEventArgs(string step, bool finished, Algorithm moves, int milliseconds, SolutionStepType type = SolutionStepType.Standard)
 {
     this.Step = step;
     this.Finished = finished;
     this.Algorithm = moves;
     this.Milliseconds = milliseconds;
     this.Type = type;
 }

 public void Copy(Work work)
 {
     hashStart = work.hashStart;
     hashCount = work.hashCount;
     hashAlgorithm = work.hashAlgorithm;
     Array.Copy(work.target, target, 8);
     Array.Copy(work.data, data, 32);
 }

 // create miner creates new miners based on device type and algorithm/miner path
 public static Miner CreateMiner(ComputeDevice device, Algorithm algorithm)
 {
     var minerPath = MinerPaths.GetOptimizedMinerPath(device, algorithm);
     if (minerPath != MinerPaths.NONE) {
         return CreateMiner(device.DeviceType, minerPath);
     }
     return null;
 }

 public Symmetric(Algorithm mode, int keySize)
 {
     if (IsKeySizeValid(keySize, mode) == false)
         throw new ArgumentException("The given keySize is invalid.", "keySize");
     this._Mode = mode;
     this._KeySize = keySize;
     Init();
 }

        public static void ShowResults(Algorithm.DynAlgorithm algorithm)
        {
            ResultsForm form = new ResultsForm();
            form.m_Algorithm = algorithm;
            form.edtResults.Text = algorithm.GetResults();

            form.ShowDialog();
        }

 protected override string GetBenchmarkCommandStringPart(Algorithm algorithm)
 {
     return " --benchmark-warmup 40 --benchmark-trial 20"
         + " "
         + ExtraLaunchParametersParser.ParseForMiningSetup(
                                             MiningSetup,
                                             DeviceType.NVIDIA)
         + " --cuda --cuda-devices ";
 }

        public void GetHash(Algorithm algorithm, bool useNullString, bool useNullEncoding)
        {
            string normalText = useNullString ? null : GenerateText(100, 500);
            Encoding encoding = useNullEncoding ? null : Encoding.UTF8;

            string hashed = DataHashing.Compute(algorithm, normalText, encoding);

            Assert.IsTrue(DataHashing.Validate(algorithm, normalText, hashed, encoding));
        }

    // *** METHODS ***

    /// <summary>
    /// Returns the solution for the transferred Rubik
    /// </summary>
    /// <param name="cube">Defines the Rubik to be solved</param>
    protected virtual void Solve(Rubik cube)
    {
      Rubik = cube.DeepClone();
      Algorithm = new Algorithm();
      InitStandardCube();

      GetSolution();
      RemoveUnnecessaryMoves();
    }