Не работает дешифрование текста

#include "playfair.h"
using namespace std;
int main(int argc, char* argv[])
{
    int number = 0;
    keyWord();
    initializeMatrix();
    while (1)                   
    {
        if (number == 0)
        {
            cout << "\nInput 1 for encrypting, input 2 for decrypting, input 3 for exit\nYour choose: ";
            cin.clear();
            cin.sync();
            cin >> number;
        }
        if(cin)
        {
            if (number == 1)
            {
                cout << "Write phrase for encrypting: ";
                pre_encrypting();
                encrypting();
                number = 0;
            }
            else if (number == 2)
            {
                cout << "Write phrase for decrypting: ";
                pre_decrypting();
                decrypting();
                number = 0;
            }
            else if (number == 3)
            {
                return 0;
            }
            else
            {
                number = 0;
            }
        }
        else
        {
            cout << "Wrong data type, input again!" << endl;
            number = 0;
        }
    }
}

#include "playfair.h"
using namespace std;
/// Глобальные переменные
char wrongSymbols[] = "!@#$%^&*()_+№;:?_+~`{[}];:'|/<,>.1234567890"; /// Недопустимые символы
char G_processedText[SIZE]; /// Массив символов который передает ключевую фразу в матрицу
char matrix[SIZE_2][SIZE_2];/// Матрица символов которая является шифр таблицей
char bigramm_text[SIZE];    /// Массив символов который содержит фразу которая должна зашифроваться
string ResText;             /// Строка в которую записывается зашифрованная фраза
//---------------------------------------------------------------------------
void keyWord()  
{
    char writedText[SIZE] = {0}, processedText[SIZE] = {0};
    char i, j, k = 0;
    cout << "Input key: ";
    cin.clear();
    cin.sync();
    cin.getline(writedText, SIZE);
    system("cls");
    for(i = 0; i < strlen(writedText); i++)
    {
        j = writedText[i];
        if(!strchr(wrongSymbols, j))
        {
            j = tolower(j);
            if(!strchr(processedText, j) && j != ' ')
            {
                processedText[k] = j;
                k += 1;
            }
        }
    }
    strcpy(G_processedText, processedText);
    cout << "Your Key: " << processedText << endl;
}
//---------------------------------------------------------------------------
void initializeMatrix()
{
    ///cout << "Matrix: " << G_processedText << endl;
    char saveSymbols[SIZE] = "";
    char alphabet[] = "abcdefghiklmnopqrstuvwxyz";
    char j, p, jo;
    int i, k, io, ko;
    k = 0;
    ko =0;
    ///Объединение ключа и алфавита
    strcat(G_processedText, alphabet);
    cout << "\nMatrix: " << endl;
    for (i = 0; i < strlen(G_processedText); i++)
    {
        p = G_processedText[i];
        if(!strchr(saveSymbols, p))
        {
            saveSymbols[k] = p;
            k += 1;
        }
    }
    for(io = 0; io < SIZE_2; io++)
    {
 
        for(jo = 0; jo < SIZE_2; jo++)
        {
            matrix[io][jo] = saveSymbols[jo+ko];
            cout << matrix[io][jo] << " ";
        }
        ko += 5;
        cout << endl;
    }
    ///cout << matrix << endl;
}
//---------------------------------------------------------------------------
void pre_encrypting()
{
    char writedText[SIZE] = {0}, processedText[SIZE] = {0};
    char i, j, k = 0;
    int repeat;
    cin.clear();
    cin.sync();
    cin.getline(writedText, SIZE);
    for(i = 0; i < strlen(writedText); i++)
    {
        j = writedText[i];
        if(!strchr(wrongSymbols, j))
        {
            j = tolower(j);
            if(j != ' ')
            {
                processedText[k] = j;
                k += 1;
            }
        }
    }
    /// Если биграмма имеет одинаковые символы(последний заменить на x)
    for(repeat = 0; repeat < strlen(processedText); repeat += 2)
    {
        char a, b;
        a = processedText[repeat];
        b = processedText[repeat+1];
        ///cout << a << " : " << b << endl;
        if(a == b)
            processedText[repeat+1] = 'x';
    }
    /// Добавление x в конец строки если нет пары для последней биграммы
    if(strlen(processedText) % 2 != 0)
       processedText[strlen(processedText)] = 'x';
    strcpy(bigramm_text, processedText);
    // Вывод зашифровываемой фразы
    cout << "Your phrase: " << processedText << endl;
}
//---------------------------------------------------------------------------
void encrypting()
{
    // шаг кодировки биграммы
    int step = 0;
    // координаты элемента первого символа биграммы(2у мерный массив)
    int ind_x1 = 0;
    int ind_y1 = 0;
    // координаты элемента второго символа биграммы(2у мерный массив)
    int ind_x2 = 0;
    int ind_y2 = 0;
    // переменные для циклов for
    int i, j;
 
    while(step < strlen(bigramm_text))
    {
        /// Координаты совпадений с таблицей
        for (int i=0; i<5; i++)
        {
            for (int j=0; j<5; j++)
            {
                if (bigramm_text[step] == matrix[i][j])
                {
                    ind_x1 = i;
                    ind_y1 = j;
                    ///cout << bigramm_text[step] << " " << ind_x1 << " " << ind_y1 << endl;
                }
 
                if (bigramm_text[step+1] == matrix[i][j])
                {
                    ind_x2 = i;
                    ind_y2 = j;
                    ///cout << bigramm_text[step+1] << " " << ind_x2 << " " << ind_y2 << endl;
                }
            }
        }
        /// Если буквы находятся в одной строке
        if (ind_x1 == ind_x2)
        {
            if (ind_y1 == 4)
            {
                ResText += matrix[ind_x1][0];
                ResText += matrix[ind_x2][ind_y2+1];
            }
            else if (ind_y2 == 4)
            {
                ResText += matrix[ind_x1][ind_y1+1];
                ResText += matrix[ind_x2][0];
            }
            else
            {
                ResText += matrix[ind_x1][ind_y1+1];
                ResText += matrix[ind_x2][ind_y2+1];
            }
        }
 
        /// Если буквы находятся в одном столбце
        if (ind_y1 == ind_y2)
        {
            if (ind_x1 == 4)
            {
                ResText += matrix[0][ind_y1];
                ResText += matrix[ind_x2+1][ind_y2];
            }
            else if (ind_x2 == 4)
            {
                ResText += matrix[ind_x1+1][ind_y1];
                ResText += matrix[0][ind_y2];
            }
            else
            {
                ResText += matrix[ind_x1+1][ind_y1];
                ResText += matrix[ind_x2+1][ind_y2];
            }
        }
 
        /// Если буквы находятся в разных строках и разных столбцах
        if ((ind_x1 != ind_x2) && (ind_y1 != ind_y2))
        {
            ResText += matrix[ind_x1][ind_y2];
            ResText += matrix[ind_x2][ind_y1];
        }
        step += 2;
    }
    cout << "Encrypted: " << ResText << endl;
    ResText = "";
}
//---------------------------------------------------------------------------
void pre_decrypting()
{
    char writedText[SIZE] = {0}, processedText[SIZE] = {0};
    char i, j, k;
    int repeat;
    cin.clear();
    cin.sync();
    cin.getline(writedText, SIZE);
    for(i = 0; i < strlen(writedText); i++)
    {
        j = writedText[i];
        if(!strchr(wrongSymbols, j))
        {
            j = tolower(j);
            if(j != ' ')
            {
                processedText[k] = j;
                k += 1;
            }
        }
    }
    /// Если биграмма имеет одинаковые символы(последний заменить на x)
    /*for(repeat = 0; repeat < strlen(processedText); repeat += 2)
    {
        char a, b;
        a = processedText[repeat];
        b = processedText[repeat+1];
        ///cout << a << " : " << b << endl;
        if(a == b)
            processedText[repeat+1] = 'x';
    }*/
    /// Добавление x в конец строки если нет пары для последней биграммы
    if(strlen(processedText) % 2 != 0)
       processedText[strlen(processedText)] = 'x';
    strcpy(bigramm_text, processedText);
    // Вывод шифрованой фразы
    cout << "Your encrypted phrase: " << processedText << endl;
}
//---------------------------------------------------------------------------
void decrypting()
{
 
    // шаг раскодировки биграммы
    int step = 0;
    // координаты элемента первого символа биграммы(2у мерный массив)
    int ind_x1 = 0;
    int ind_y1 = 0;
    // координаты элемента второго символа биграммы(2у мерный массив)
    int ind_x2 = 0;
    int ind_y2 = 0;
    // переменные для циклов for
    int i, j;
 
    while(step < strlen(bigramm_text))
    {
        /// Координаты совпадений с таблицей
        for (int i=0; i<5; i++)
        {
            for (int j=0; j<5; j++)
            {
                if (bigramm_text[step] == matrix[i][j])
                {
                    ind_x1 = i;
                    ind_y1 = j;
                    ///cout << bigramm_text[step] << " " << ind_x1 << " " << ind_y1 << endl;
                }
 
                if (bigramm_text[step+1] == matrix[i][j])
                {
                    ind_x2 = i;
                    ind_y2 = j;
                    ///cout << bigramm_text[step+1] << " " << ind_x2 << " " << ind_y2 << endl;
                }
            }
        }
        /// Если буквы находятся в одной строке
        if (ind_x1 == ind_x2)
        {
            if (ind_y1 == 0)
            {
                ResText += matrix[ind_x1][4];
                ResText += matrix[ind_x2][ind_y2-1];
            }
            else if (ind_y2 == 0)
            {
                ResText += matrix[ind_x1][ind_y1-1];
                ResText += matrix[ind_x2][4];
            }
            else
            {
                ResText += matrix[ind_x1][ind_y1-1];
                ResText += matrix[ind_x2][ind_y2-1];
            }
        }
 
        /// Если буквы находятся в одном столбце
        if (ind_y1 == ind_y2)
        {
            if (ind_x1 == 0)
            {
                ResText += matrix[4][ind_y1];
                ResText += matrix[ind_x2-1][ind_y2];
            }
            else if (ind_x2 == 0)
            {
                ResText += matrix[ind_x1-1][ind_y1];
                ResText += matrix[4][ind_y2];
            }
            else
            {
                ResText += matrix[ind_x1-1][ind_y1];
                ResText += matrix[ind_x2-1][ind_y2];
            }
        }
 
        /// Если буквы находятся в разных строках и разных столбцах
        if ((ind_x1 != ind_x2) && (ind_y1 != ind_y2))
        {
            ResText += matrix[ind_x1][ind_y2];
            ResText += matrix[ind_x2][ind_y1];
        }
        step += 2;
    }
    /// Удаление символа x если он является последним
    if(ResText[ResText.length() - 1] == 'x')
        ResText.erase(ResText.end() - 1);
    cout << "Decrypted: " << ResText << endl;
    ResText = "";
}

#ifndef playfair
#define playfair
#include <iostream>
#define SIZE 250
#define SIZE_2 5
#include <string>
#include <locale>
#include <cstdlib>
#include <string.h>
#include <_str.h>
#include <typeinfo>    
 
/// Глобальные переменные
extern char wrongSymbols[]; /// Недопустимые символы
extern char G_processedText[SIZE]; /// Массив символов который передает ключевую фразу в матрицу
extern char matrix[SIZE_2][SIZE_2];/// Матрица символов которая является шифр таблицей
extern char bigramm_text[SIZE]; /// Массив символов который содержит фразу которая должна зашифроваться
extern std::string ResText;             /// Строка в которую записывается зашифрованная фраза
/// Прототипы функций
void keyWord();         /// Образует ключ шифратора(удаляет из введенной фразы пробелы, цифры, знаки, заглавные буквы)
void initializeMatrix();/// Вшивает в матрицу ключ шифратора
void pre_encrypting();  /// Убирает из зашифровываемой фразы пробелы, цифры, знаки, заглавные буквы
void pre_decrypting();  /// Ввод расшифровываемой фразы(удаляется все кроме строчных букв)
void encrypting();      /// Шифрует преобразованную фразу
void decrypting();      /// Расшифровывает зашифрованную фразу
#endif