Не работает алгоритм нахождения обратной матрицы

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
 
namespace Шифр_Хилла
{
    public partial class Form1 : Form
    {
        public Random rnd = new Random();   //  для псевдослучайного составления слов из образующего текста(символы будут браться случайно)
        
        public string[] alph = new string[31] {"А","Б","В","Г","Д","Е","Ж","З","И","К","Л","М","Н","О","П","Р","С","Т","У","Ф","Х","Ц","Ч","Ш","Щ","Ъ","Ы","Ь","Э","Ю","Я"};
        public string[] newAlph = new string[31];
        public Form1()
        {
            InitializeComponent();
        }
        private void button1_Click(object sender, EventArgs e)
        {
            
            OpenFileDialog openFileDialog1 = new OpenFileDialog();
            openFileDialog1.Filter = "Text Files (.txt)|*.txt";
 
            if(openFileDialog1.ShowDialog() != DialogResult.OK)
            {
                return;
            }
 
            this.textBox2.Text = openFileDialog1.FileName;
            this.textBox3.Text = System.IO.File.ReadAllText(openFileDialog1.FileName).ToUpper();
        }  // выбор файла для шифрования(кнопка "Обзор")
 
        private void Button4_Click(object sender, EventArgs e)  // шифрование(кнопка "Зашифровать)+
        {
            Matrix key = new Matrix((int)this.numericUpDown1.Value, (int)this.numericUpDown1.Value); // матрица-ключ размера nxn для шифрования
            Matrix inverseKey = new Matrix((int)this.numericUpDown1.Value, (int)this.numericUpDown1.Value); // обратная матрица матрицы-ключа размера nxn для расшифрования
 
            // для вы-я определителя матрицы key используется метод LU - разложения(см. Matrix.Determinant())
            // матрицы строятся над полем вычетов Zm по модулю m(m - размер алфавита)
 
            string sourceText = "";   // исходный текст
            UpperSourceText(ref sourceText);   // убираем лишнее и переводим в верхний регистр исходный текст
            this.textBox1.Text = this.textBox1.Text.ToUpper();   // переводим в верхний регистр образующий текст
 
            string worldSizeN = "";
 
            int determinant = 0;  // определитель матрицы-ключа
            string alpha = "";
            createNewAlph(ref alpha);
 
            do
            {
                formingKey(ref worldSizeN);  //  см. formingKey
                worldSizeN = "АЛЬПИНИЗМ";  // !!!Специально присваиваю АЛЬПИНИЗМ чтоб можно было проверить!!!
                createMatrixKey(in worldSizeN, ref key);   // см. createMatrixKey
                textBox3.Text = "Матрица ключ до модуля: ";
                textBox3.Text += Environment.NewLine;
 
                for (int i = 0; i < 3; ++i)
                {
                    for (int j = 0; j < 3; ++j)
                    {
                        textBox3.Text += "  ";
                        textBox3.Text += key[i, j];
                    }
                    textBox3.Text += Environment.NewLine;
                }
                key.Mod((int)this.numericUpDown2.Value);   // матрица по модулю m
                determinant = key.Determinant();
 
            } while (determinant == 0);
 
            // если определитель != 0 находим обратную матрицу  и
            textBox1.Text += " ключ:  ";
            textBox1.Text += worldSizeN;
 
            textBox3.Text = "Матрица ключ: ";
            textBox3.Text += Environment.NewLine;
 
            for (int i = 0; i < 3; ++i)
            {
                for (int j = 0; j < 3; ++j)
                {
                    textBox3.Text += "  ";
                    textBox3.Text += key[i, j];
                }
                textBox3.Text += Environment.NewLine;
            }
            textBox3.Text += Environment.NewLine;
            textBox3.Text += "определитель матрицы ключа: ";
            textBox3.Text += determinant;
            textBox3.Text += Environment.NewLine;
            textBox3.Text += "обратная матрица: ";
            inverseKey = key.InverseMatrix();  // вычисляем обратную матрицу
            inverseKey.Mod((int)this.numericUpDown2.Value);  // матрица по модулю m
            determinant = reverseDet(determinant);
            inverseKey = inverseKey * determinant;
            inverseKey.Mod((int)this.numericUpDown2.Value);
            inverseKey.Transpose();
 
            for (int i = 0; i < inverseKey.Row; ++i)
            {
                for (int j = 0; j < inverseKey.Column; ++j)
                {
                    if (inverseKey[i, j] < 0)
                    {
                        textBox3.Text += "  ";
                        inverseKey[i, j] = (int)this.numericUpDown2.Value + inverseKey[i, j];
                    }
                }
                textBox3.Text += Environment.NewLine;
            }
            for (int i = 0; i < 3; ++i)
            {
                for (int j = 0; j < 3; ++j)
                {
                    textBox3.Text += "  ";
                    textBox3.Text += inverseKey[i, j];
                }
                textBox3.Text += Environment.NewLine;
            }
            textBox3.Text += "обратный детерминант: ";
            textBox3.Text += determinant;
        }
        void formingKey(ref string _worldSizeN)     // из образующего текста составляем n-слов, размера n-символов и на их основе составляем матрицу ключ - каждое слово эта строка матрицы ключа 
        {
            _worldSizeN = "";
            int count = 0;
 
            while (count < (int)this.numericUpDown1.Value)   // образуем n-слов
            {
                int j = 0;
                int k = 0;
 
                while (j < (int)this.numericUpDown1.Value)  // образуем слово размера n
                {
                    k = rnd.Next(0, this.textBox1.Text.Length);
                    _worldSizeN += this.textBox1.Text[k].ToString();
                    ++j;
                }
 
                ++count;
            }
        }
        void createMatrixKey(in string _worldSizeN, ref Matrix _key)   // Образующий текст разбиваем на n-граммы и и каждому символому сопаставляем число на основе таблицы
        {
            int item = 0;
 
            for(int i = 0; i < (int)this.numericUpDown1.Value; ++i)
            {
                for(int j = 0; j < (int)this.numericUpDown1.Value; ++j)
                {
                    for(int k = 0; k < 31; ++k)
                    {
                        if (newAlph[k] == _worldSizeN[item].ToString())
                        {
                            _key[i, j] = k;
                        }
                    }
 
                    ++item;
                }
            }
        }
        string UpperSourceText(ref string _sourceText)    // в исходном тексте оставляем только буквы
        {
            int counter = 0;
 
            for (int i = 0; i < this.textBox3.Text.Length; ++i)
            {
                for (int j = 0; j < 31; ++j)
                {
                    counter = 0;
 
                    if (this.textBox3.Text[i].ToString() == alph[j])
                    {
                        ++counter;
                        break;
                    }
                }
 
                if (counter > 0)
                {
                    _sourceText += this.textBox3.Text[i]; ;
                }
            }
 
            return _sourceText;
        }
        void createNewAlph(ref string _alph)
        {
            string text = this.textBox1.Text.ToString();  // образующий текст
            string ftext = string.Concat(text.Distinct());   // удаление дублируюзихся букв
            ftext += "АБВГДЕЖЗИКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ";
            _alph = string.Concat(ftext.Distinct());   // удаление дублируюзихся букв
 
            for(int i = 0; i < 31; ++i)
            {
                newAlph[i] = _alph[i].ToString();
            }
        }    // новый алфавит
        int nod(int a, int b, ref int x, ref int y)
        {
            if (a == 0)
            {
                x = 0; y = 1;
                return b;
            }
            int x1 = 0, y1 = 0;
            int d = nod(b % a, a, ref x1, ref y1);
            x = y1 - (b / a) * x1;
            y = x1;
            return d;
        }    // расширенный алгоритм евклида
        int reverseDet(int determinant)
        {
            int x = 0, y = 0;
            int d = nod(determinant, (int)this.numericUpDown2.Value, ref x, ref y);
 
            if (determinant < 0 && x > 0)
            {
                determinant = x;
            }
            else if (determinant > 0 && x < 0)
            {
                determinant = (int)this.numericUpDown2.Value + x;
            }
            else if (determinant > 0 && x > 0)
            {
                determinant = x;
            }
            else
            {
                determinant = x * -1;
            }
 
            return determinant;
        }
    }
}