Перенос кода в нужный интерфейс

#include <vcl.h>
#pragma hdrstop
#include <tchar.h>
#include <iostream>
 
#define OPENFILE        "D:\\opentext.txt"
#define CRYPTEDFILE     "D:\\cryptedtext.txt"
#define DECRYPTEDFILE   "D:\\decryptedtext.txt"
 
#define SEKRETKEY       "98765432109876543210987654321098"
 
#define CRYPT           false
#define DECRYPT         true
 
using namespace std;
 
int reverse_bit(int X)
{
    return
    X =                             // Реверсирование битов
        ((X & 0x1)          <<31)+((X & 0x2)        <<29)+((X & 0x4)        <<27)+((X & 0x8)        <<25)+
        ((X & 0x10)         <<23)+((X & 0x20)       <<21)+((X & 0x40)       <<19)+((X & 0x80)       <<17)+
        ((X & 0x100)        <<15)+((X & 0x200)      <<13)+((X & 0x400)      <<11)+((X & 0x800)      << 9)+
        ((X & 0x1000)       << 7)+((X & 0x2000)     << 5)+((X & 0x4000)     << 3)+((X & 0x8000)     << 1)+
        ((X & 0x10000)      >> 1)+((X & 0x20000)    >> 3)+((X & 0x40000)    >> 5)+((X & 0x80000)    >> 7)+
        ((X & 0x100000)     >> 9)+((X & 0x200000)   >>11)+((X & 0x400000)   >>13)+((X & 0x800000)   >>15)+
        ((X & 0x1000000)    >>17)+((X & 0x2000000)  >>19)+((X & 0x4000000)  >>21)+((X & 0x8000000)  >>23)+
        ((X & 0x10000000)   >>25)+((X & 0x20000000) >>27)+((X & 0x40000000) >>29)+((X & 0x80000000) >>31);
}
 
int reverse_block(int X)
{
    return
    X =                             // Реверсирование 8-битных блоков + реверс битов результата
        ((X & 0x1)          << 7)+((X & 0x2)        << 5)+((X & 0x4)        << 3)+((X & 0x8)        << 1)+
        ((X & 0x10)         >> 1)+((X & 0x20)       >> 3)+((X & 0x40)       >> 5)+((X & 0x80)       >> 7)+
        ((X & 0x100)        << 7)+((X & 0x200)      << 5)+((X & 0x400)      << 3)+((X & 0x800)      << 1)+
        ((X & 0x1000)       >> 1)+((X & 0x2000)     >> 3)+((X & 0x4000)     >> 5)+((X & 0x8000)     >> 7)+
        ((X & 0x10000)      << 7)+((X & 0x20000)    << 5)+((X & 0x40000)    << 3)+((X & 0x80000)    << 1)+
        ((X & 0x100000)     >> 1)+((X & 0x200000)   >> 3)+((X & 0x400000)   >> 5)+((X & 0x800000)   >> 7)+
        ((X & 0x1000000)    << 7)+((X & 0x2000000)  << 5)+((X & 0x4000000)  << 3)+((X & 0x8000000)  << 1)+
        ((X & 0x10000000)   >> 1)+((X & 0x20000000) >> 3)+((X & 0x40000000) >> 5)+((X & 0x80000000) >> 7);
}
 
void GOST(bool mode)
{
    //--8 S-box'ов----------------------------------------
    unsigned int Sbox[8][16] =
    {
        {4,10,9,2,13,8,0,14,6,11,1,12,7,15,5,3},
        {14,11,4,12,6,13,15,10,2,3,8,1,0,7,5,9},
        {5,8,1,13,10,3,4,2,14,15,12,7,6,0,9,11},
        {7,13,10,1,0,8,9,15,14,4,6,12,11,2,5,3},
        {6,12,7,1,5,15,13,8,4,10,9,14,0,3,11,2},
        {4,11,10,0,7,2,1,13,3,6,8,5,9,12,15,14},
        {13,11,4,1,3,15,5,9,0,10,14,7,6,8,2,12},
        {1,15,13,0,5,7,10,4,9,2,3,14,6,11,8,12}
    };
 
    //--Ключ шифрования и его разбиение--------------------
    char s[33] = SEKRETKEY;
    unsigned int key[8];
 
    for(int i = 0; i<8; i++)
    {
        key[i] = (s[4*i]<<24) + (s[1+4*i]<<16) + (s[2+4*i]<<8) + s[3+4*i];  // Складывание каждых 4-х символов ключа в одно число
 
        key[i] = reverse_bit(key[i]);       // Реверсирование битов
    }
 
    //--Открытие файла-------------------------------------
    FILE* f;            // Входной файл
    FILE* g;            // Выходной файл
    int fsize;          // Размер входного файла
 
    if(mode == CRYPT)
    {
        f = fopen(OPENFILE, "rb");
 
        fseek (f, 0, SEEK_END);         // Вычисление размера файла
        fsize = ftell(f);
        fseek (f, 0, SEEK_SET);
 
        g = fopen(CRYPTEDFILE, "wb");
    }
    if(mode == DECRYPT)
    {
        f = fopen(CRYPTEDFILE, "rb");
 
        fseek (f, 0, SEEK_END);         // Вычисление размера файла
        fsize = ftell(f);
        fseek (f, 0, SEEK_SET);
 
        g = fopen(DECRYPTEDFILE, "wb");
    }
 
    //--Основной цикл шифрования---------------------------
    while(fsize)
    {
        unsigned int A = 0;                 // Страший 32-битный блок
        unsigned int B = 0;                 // Младший 32-битный блок
 
        //------------------------------------
        if(fsize>=4)                    // Заполнение старшего блока...
        {
            fread(&A, 4, 1, f);         // ...символами...
            fsize -= 4;
        }
        else
        {
            fread(&A, fsize, 1, f);
            for(int i = 0; i<(4-fsize); i++)
            {
                A += (32<<(24-(i*8)));  // ... или пробелами, если символы кончились,
                fsize = 0;              //     а 64 бита еще не набралось
            }
        }
 
        //------------------------------------
        if(fsize>=4)                    // Заполнение младшего блока...
        {
            fread(&B, 4, 1, f);         // ...символами...
            fsize -= 4;
        }
        else
        {
            fread(&B, fsize, 1, f);
            for(int i = 0; i<(4-fsize); i++)
            {
                B += (32<<(24-(i*8)));  // ... или пробелами, если символы кончились,
                fsize = 0;              //     а 64 бита еще не набралось
            }
        }
        //------------------------------------
        A = reverse_block(A);           // Реверсирование блоков с последующим реверсом бит
        B = reverse_block(B);           // Реверсирование блоков с последующим реверсом бит
 
        unsigned int T;                 // Для промежуточных вычислений
 
        //--32 раунда--------------------------------------
        for(int i = 0; i<32; i++)
        {
            T = 0;
            if(mode == CRYPT)
            {
                if(i<24) T = (A+key[i%8]) % 0x100000000;    // суммирование с ключом в зависимости от раунда
                else T = (A+key[7-(i%8)]) % 0x100000000;
            }
            if(mode == DECRYPT)
            {
                if(i<8) T = (A+key[i%8])  % 0x100000000;    // суммирование с ключом в зависимости от раунда
                else T = (A+key[7-(i%8)]) % 0x100000000;
            }
 
            unsigned int Fragments[8] =     // Разбиение на 4-битные фрагменты
            {
                (T & 0xF0000000)>>28,
                (T & 0xF000000)>>24,
                (T & 0xF00000)>>20,
                (T & 0xF0000)>>16,
                (T & 0xF000)>>12,
                (T & 0xF00)>> 8,
                (T & 0xF0)>> 4,
                (T & 0xF)
            };
 
            for(int j = 0; j<8; j++)
            {
                Fragments[j] = Sbox[j][Fragments[j]];     // Пропуск фрагментов через Sbox'ы
            }
 
            T = (Fragments[0]<<28) +        // Сборка фрагментов обратно в 32-битный подблок
                (Fragments[1]<<24) +
                (Fragments[2]<<20) +
                (Fragments[3]<<16) +
                (Fragments[4]<<12) +
                (Fragments[5]<< 8) +
                (Fragments[6]<< 4) +
                 Fragments[7];
 
            T = (T<<11)|(T>>21);            // Циклическое смещение влево на 11 бит
            T ^= B;                         // XOR с B
 
            if(i != 31)
            {
                B = A;                      // Перестановка подблоков 1-31 и 32 циклов
                A = T;
            }
            else
            {
                B = T;
            }
        }   //--Коненц 32 раундов---------------------------
 
        A = reverse_block(A);           // Реверсирование блоков с последующим реверсом бит
        B = reverse_block(B);           // Реверсирование блоков с последующим реверсом бит
 
        //--Вывод A и B в файл--------------------------
        fwrite(&A, 4, 1, g);
        fwrite(&B, 4, 1, g);
 
    }   // Конец файла
    fclose(f);
    fclose(g);
}
 
 
int _tmain(int argc, _TCHAR* argv[])
{
    GOST(CRYPT);
    GOST(DECRYPT);
 
    return 0;
}