Не работает обратный ход метода Гаусса

#include <iostream>
#include <thread>
#include <condition_variable>
#include <mutex>
#include <atomic>
#include <chrono>
 
using namespace std;
 
condition_variable cv;
condition_variable cv2;
 
mutex cv_m;
mutex cv2_m;
 
int i_row = 0; // индекс текущей строки
atomic_int i_row_obr(3);// индекс обратного хода
atomic_int i_row_obr_two(3);
 
 
void sysout(double** arr, double* y, int n_Size) //выводим систему
{
    for (int i = 0; i < n_Size; i++)
    {
        for (int j = 0; j < n_Size; j++)
        {
            cout << arr[i][j] << "*x" << j;
            if (j < n_Size - 1)
            {
                cout << " + ";
            }
        }
        cout << " = " << y[i] << endl;
    }
    return;
}
 
class Myclass
{
public:
    double glavn_stroka(double* arr[], int n_Size, double* y, int k);
    double calculate_x(double* arr[], int n_Size, double* y, double* x, int k);
};
    
double Myclass::glavn_stroka(double *arr[], int n_Size, double* y, int k) //прямой ход метода Гаусса
{
    if (k == i_row)
    {
        int index;
        const double eps = 0.00001;  // точность
 
        index = k;
 
        lock_guard<mutex> lk(cv_m);
 
        for (int j = 0; j < n_Size; j++)
        {
            double temp = arr[k][j];
            arr[k][j] = arr[index][j];
            arr[index][j] = temp;
        }
 
        double temp = y[k];
        y[k] = y[index];
        y[index] = temp;
 
        // Нормализация уравнений
        for (int i = k; i < n_Size; i++)
        {
            double temp = arr[i][k];
            if (abs(temp) < eps) 
            { 
                continue; // для нулевого коэффициента пропустить
            }
 
            for (int j = 0; j < n_Size; j++)
            {
                arr[i][j] = arr[i][j] / temp;
            }
 
            y[i] = y[i] / temp;
 
            if (i == k)  continue;
 
            for (int j = 0; j < n_Size; j++)
            {
                arr[i][j] = arr[i][j] - arr[k][j];
            }
            
            y[i] = y[i] - y[k];
        }
 
        i_row += 1;
 
        // будим остальные потоки
        cv.notify_all();
    }
 
    else
    {
        unique_lock<mutex> lk(cv_m);
 
        cv.wait(lk, [&] { return i_row == k; });
 
    }
 
    return **arr;
}
 
 
double Myclass::calculate_x(double* arr[], int n_Size, double* y, double* x, int k) //обратный ход метода Гаусса
{
    if (i_row_obr == k)
    {
 
        lock_guard<mutex> lk2(cv2_m);
        
        x[k] = y[k];
 
        for (int i = 0; i < k; i++)
        {
            y[i] = y[i] - arr[i][k] * x[k];
        }
 
        i_row_obr -= 1;
 
        cv2.notify_all();
    }
 
    else
    {
 
        unique_lock<mutex> lk2(cv2_m);
 
        cv2.wait(lk2, [&]() 
        {
            return i_row_obr == k; 
 
        });
 
        lk2.unlock();
    }
 
    return *x;
 
}
 
int main()
{
    setlocale(LC_ALL, "ru");
 
    int n_Size;
    cout << "Введите количество уравнений: ";
    cin >> n_Size;
 
 
    double** arr = new double* [n_Size];
    double* x = new double[n_Size];
    double* y = new double[n_Size];
 
 
    for (int i = 0; i < n_Size; i++) //вводим массив коэффициентов уравнений
    {
        arr[i] = new double[n_Size];
 
        for (int j = 0; j < n_Size; j++)
        {
            cout << "arr[" << i << "][" << j << "]=";
            cin >> arr[i][j];
        }
    }
 
    for (int i = 0; i < n_Size; i++) //вводим значение y
    {
        cout << "y[" << i << "]= ";
        cin >> y[i];
    }
 
    sysout(arr, y, n_Size); // выводим систему
 
    Myclass m;
 
    thread th1([&]()
    {
        **arr = m.glavn_stroka(arr, n_Size, y, 0);
        *x = m.calculate_x(arr, n_Size, y, x, 0);
    });
 
    thread th2([&]()
    {
        **arr = m.glavn_stroka(arr, n_Size, y, 1);
        *x = m.calculate_x(arr, n_Size, y, x, 1);
    });
 
    thread th3([&]()
    {
        **arr = m.glavn_stroka(arr, n_Size, y, 2);
        *x = m.calculate_x(arr, n_Size, y, x, 2);
    });
 
    thread th4([&]()
    {
        **arr = m.glavn_stroka(arr, n_Size, y, 3);
        *x = m.calculate_x(arr, n_Size, y, x, 3);
    });
 
 
    for (int i = n_Size; i != 0; i--) // выводим рещение системы уравнений
    {
        cout << "x[" << i << "]=" << x[i] << endl;
    }
 
    //for (int i = 0; i < n_Size; i++) // выводим рещение системы уравнений
    //{
    //  cout << "x[" << i << "]=" << x[i] << endl;
    //}
 
 
    th4.join();
    th3.join();
    th2.join();
    th1.join();
 
    for (int i = 0; i < n_Size; i++)
        delete arr[i];
    delete[] arr;
    delete[] x;
    delete[] y;
 
    return 0;
}