Перевести код из c# на DELPHI

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Security.Cryptography;
using ManagedRC4;
 
namespace LegacyRC4
{
    class Program
    {
        public static string password;
        public static uint uKeySize;
 
        static void CheckVerifier(byte[] verifierBuf)
        {
            MD5 md5Hash = MD5.Create();
 
            // Salt is copied below
            byte[] encryptedVerifier = new byte[16];
            Array.Copy(verifierBuf, 16, encryptedVerifier, 0, 16);
 
            byte[] encryptedVerifierHash = new byte[16];
            Array.Copy(verifierBuf, 32, encryptedVerifierHash, 0, encryptedVerifierHash.Length);
 
            // First, derive the encryption key from the salt 
            // and the password
            byte[] pwdBuf = System.Text.UnicodeEncoding.Unicode.GetBytes(password);
            byte[] pwdHash = md5Hash.ComputeHash(pwdBuf);
 
            // Now create the hashing buffer with the hash of the password 
            // and the salt. Cryptographically, this is not a good approach,
            // but that's how it was done.
            byte[] hashBuf = new byte[21 * 16];
            for (int i = 0; i < 16; i++)
            {
                Array.Copy(pwdHash, 0, hashBuf, i * 21, 5);
                Array.Copy(verifierBuf, 0, hashBuf, i * 21 + 5, 16);
            }
 
            // Get the hash of the previous buffer
            pwdHash = md5Hash.ComputeHash(hashBuf);
 
            // Now factor in the block number
            uint block = 0;
            Array.Copy(pwdHash, 0, hashBuf, 0, 5);
            Array.Copy(BitConverter.GetBytes(block), 0, hashBuf, 5, 4);
 
            pwdHash = md5Hash.ComputeHash(hashBuf, 0, 9);
 
            // The key is always 128-bit
            byte[] rc4Key = new byte[16];
 
            Array.Copy(pwdHash, rc4Key, 16); // 5 bytes = 40 bits
 
            // Now use the ManagedRC4 implementation
            ManagedRC4.RC4 rc4 = new ManagedRC4.RC4();
 
            rc4.Init(rc4Key, (uint)rc4Key.Length);
 
            // Now we need to decrypt the two encrypted elements of the verifier
            rc4.Decrypt(encryptedVerifier, (uint)encryptedVerifier.Length);
            rc4.Decrypt(encryptedVerifierHash, (uint)encryptedVerifierHash.Length);
 
            // Finally, hash the decrypted verifier, and compare
            byte[] hashedVerifier = md5Hash.ComputeHash(encryptedVerifier);
            for (int i = 0; i < hashedVerifier.Length; i++)
            {
                if (hashedVerifier[i] != encryptedVerifierHash[i])
                    throw new Exception("Verifier hash does not match");
            }
 
            md5Hash.Clear();
            Console.WriteLine("Password matches");
 
        }
 
        static void ReadHeader(FileStream inputFile)
        {
            long cbStream = inputFile.Length - inputFile.Seek(0, SeekOrigin.Current);
            byte[] readBuf = new byte[4];
 
            inputFile.Read(readBuf, 0, 4);
            ushort vMajor = BitConverter.ToUInt16(readBuf, 0);
            ushort vMinor = BitConverter.ToUInt16(readBuf, 2);
            // Now check version
            if (vMajor != 1 || vMinor != 1)
            {
                throw new Exception("Incorrect Version");
            }
 
            // Encryption key size
            uKeySize = 40;
 
            // Fixed size verifier
            int verifierSize = 48;
            byte[] verifierBuf = new byte[verifierSize];
            inputFile.Read(verifierBuf, 0, verifierSize);
 
            CheckVerifier(verifierBuf);
        }
 
        static void Main(string[] args)
        {
            try
            {
                Program.password = args[1];
                FileStream inputFile = File.OpenRead(args[0]);
                // Use a Word document to demonstrate this - header is
                // at the start of the 1Table stream
                ReadHeader(inputFile);
            }
            catch (Exception err)
            {
                Console.Write(err);
            }
 
        }
 
    }
}