можно ли упростить этот код ,код не мой просто нужно чтобы он был проще)

#include <iostream>
#include <cmath>
#include <string>
#include <cstdlib>
#include <ctime>
#include <iomanip>
#include <conio.h>
#include <windows.h>
 
#define BANNER(s1,s2,s3) std::cout << s1 <<"\n"<< s2 <<"\n"<< s3 << "\n"
#define LOG(v) Log(#v, v)
#define ENDL std::cout << "\n"
#define FORi(v)  for(int i = 0; i < v; ++i)
#define FORj(v)  for(int j = 0; j < v; ++j)
#define YES true
#define NO  false
 
#define SIZEARR(v) sizeof(v)/sizeof(v[0])
 
template<class T1, class T2>
void Log(T1 v1, T2 v2)
{   std::cout << v1 << " = " << v2 << "\n";
}
 
template<class T>
void Log(T v)
{   std::cout << v;
}
 
///----------------------------------------------------------------------------|
/// Атомы.
///----------------------------------------------------------------------------:
struct smystart
{   smystart()
    {   setlocale(0, "");
        system("mode 74,24");
        srand((unsigned int)time(NULL));
        hCon = GetStdHandle(STD_OUTPUT_HANDLE);
    }
    
    HANDLE hCon;
    
}mystart;
 
namespace myfoo
{   struct sCursor_xy
    {   sCursor_xy(SHORT _x, SHORT _y, int _n = 20) : x(_x), y(_y), n(_n)
        {
        }
    
        void set()
        {   COORD coord = {x, y};
            SetConsoleCursorPosition(mystart.hCon, coord);
        }
        void set_plus(SHORT _dx, SHORT _dy)
        {   COORD coord = {x + _dx, y + _dy};
            SetConsoleCursorPosition(mystart.hCon, coord);
        }
        
        SHORT x, y;
        int n;
        void mycls()
        {   set();
            FORi(n)
            {   std::cout << " ";
            }
        }
    };
    
    int rrand(int range_min, int range_max)
    {   if(range_max == range_min) return 1;
        return rand() % (range_max - range_min + 1) + range_min;
    }
    
    void draw_border(sCursor_xy& cur, int xx, int yy)
    {   cur.set();
        std::cout << "///";
        FORi(yy)
        {   std::cout << "-";
        }
        std::cout << "|";
        FORi(xx)
        {   cur.set_plus(0, i+1);
            std::cout << "///";
            FORj(yy)
            {   std::cout << " ";
            }
            std::cout << "|";
        }
        cur.set_plus(0, xx);
        std::cout << "///";
        FORi(yy)
        {   std::cout << "-";
        }
        std::cout << "|";
    }
};
 
///----------------------------------------------------------------------------|
/// Доска.
///----------------------------------------------------------------------------:
const int AMOUNT_OPERATION = 16;
class cBoard
{   
public:
    cBoard() : cursor_xy(26,9)
    {   
    }
    
    enum OP
    {   OP_ADD = 0,
        OP_SUB,
        OP_MUL,
        OP_DIV,
    };
    
    OP OPERATION[AMOUNT_OPERATION];
    int num     [AMOUNT_OPERATION];
    int count_operation;
    
    myfoo::sCursor_xy cursor_xy;
    void show()
    {   cursor_xy.mycls();
        cursor_xy.set();
        std::cout << num[0];
        FORi(count_operation)
        {   switch(OPERATION[i])
            {   case OP_ADD:
                    std::cout << " + "
                              << abs(num[i+1]);
                break;
                    
                case OP_SUB:
                    std::cout << " - "
                              << abs(num[i+1]);
                break;
                    
                case OP_MUL:
                    std::cout << " * "
                              << abs(num[i+1]);
                break;
                    
                case OP_DIV:
                    std::cout << " / "
                              << abs(num[i+1]);
                break;
                    
                default:
                    Log("Ошибка: Нет такой операции!\n");
            }
        }
        std::cout << " = ?   ";
    }
    
    void draw_borders()
    {   myfoo::sCursor_xy cursor_xy(7, 7);
        myfoo::draw_border(cursor_xy, 4, 55);
    }
    
private:
    
}board;
 
void test_class_cBoard()
{                            BANNER(
    "///-------------------------|",
    "/// test_class_cBoard();    |",
    "///-------------------------|");
    
}
 
///----------------------------------------------------------------------------|
/// Учитель-Экзаминатор.
///----------------------------------------------------------------------------:
class cTeacher
{   myfoo::sCursor_xy cursor_xy;
public:
    cTeacher() : cursor_xy         (30, 18),
                 bound_count_operation_1(1),
                 bound_count_operation_2(2),
                 bound_op_operation     (1),
                 bound_number_1         (0),
                 bound_number_2         (9),
                 correct_result       (777),
                 amount_question       (20),
                 name("Кот Васян")
    {   init();
    }
    
    std::string name;
    
    class Statistics
    {
    public:
        Statistics()
        {
        }
        
    }statistics;
    
    void ask_question()
    {   board.count_operation = myfoo::rrand( bound_count_operation_1,
                                              bound_count_operation_2 );
        FORi(board.count_operation)
        {   board.OPERATION[i] =                 // SIZEARR(board.OPERATION)
                    (cBoard::OP)myfoo::rrand( 0, bound_op_operation);
        }
        
        fill_board_number();
        board.show();
    }
    
    int count__bad,
        count_good;
    void init()
    {   count__bad  = 0;
        count_good  = 0;
        draw_estimator();
    }
    void draw_estimator()
    {   static myfoo::sCursor_xy cur__bad (0, 4);
        static myfoo::sCursor_xy cur_good(0, 5);
        cur__bad.set();
        LOG(count__bad);
        
        cur_good.set();
        LOG(count_good);
    }
    
    void send_answer(int answer)
    {   cursor_xy.mycls();
        cursor_xy.set();
        if(answer == correct_result)
        {    Log("Отлично!");
             count_good++;
        }
        else
        {   Log("Плохо!");
            count__bad++;
        }
        ENDL;
        
        draw_estimator();
    }
    
    int amount_question;
private:
    int bound_count_operation_1,
        bound_count_operation_2;
    int bound_op_operation;
    
    int bound_number_1,
        bound_number_2;
        
    int correct_result;
        
    void fill_board_number()
    {   board.num[0] = myfoo::rrand( bound_number_1,
                                     bound_number_2);
        correct_result = board.num[0];
        FORi(board.count_operation)
        {   switch(board.OPERATION[i])
            {   case cBoard::OP_ADD:
                    board.num[i+1] =   myfoo::rrand( bound_number_1,
                                                     bound_number_2 );
                    correct_result += board.num[i+1];
                break;
                    
                case cBoard::OP_SUB:
                    board.num[i+1] = - myfoo::rrand( bound_number_1,
                                                     bound_number_2 );
                    correct_result += board.num[i+1];
                break;
                    
                case cBoard::OP_MUL:
                    
                break;
                    
                case cBoard::OP_DIV:
                    
                break;
                    
                default:
                    Log("Ошибка: Нет такой операции!\n");
            }
        }
    }
    
};
 
void test_class_cTeacher()
{                            BANNER(
    "///-------------------------|",
    "/// test_class_cTeacher();  |",
    "///-------------------------|");
    
}
 
///----------------------------------------------------------------------------|
/// Круг.
///----------------------------------------------------------------------------:
class cPupil
{   myfoo::sCursor_xy cursor_xy;
public:
    cPupil() : cursor_xy(15, 16, 50)
    {
    }
    
    int give_answer()
    {   return input_user<int>("Дайте ответ немедленно! Итак ваш ответ:");
    }
    
    std::string name;
    
private:
    
    template<class T>
    T input_user(const char* promt)
    {   cursor_xy.mycls();
        cursor_xy.set();
        
        std::cout << promt << " ";
        T my;
        
        while(!(std::cin>>my) || std::cin.get() != '\n')
        {   cursor_xy.mycls();
            cursor_xy.set();
            std::cout << "Incorrect input!";
            std::cin.clear();
            std::cin.sync();
        }
        return my;
    }
    
};
 
void test_class_cPupil()
{                            BANNER(
    "///-------------------------|",
    "/// test_class_cPupil();    |",
    "///-------------------------|");
    
}
 
///----------------------------------------------------------------------------|
/// Комната с учителем и учеником.
///----------------------------------------------------------------------------:
class cRoom
{   cTeacher teacher;
    cPupil   pupil;
    
public:
    cRoom()
    {   board.draw_borders();
        work();
    }
    
    void work()
    {   
        FORi(teacher.amount_question)
        {   teacher.ask_question();
        
            int answer = pupil.give_answer();
            teacher.send_answer(answer);
        }
        
    }
    
private:
    
};
 
void test_class_all()
{                                           BANNER(
    "///----------------------------------------|",
    "/// test_class_all();                      |",
    "///----------------------------------------|");
    test_class_cBoard();
    test_class_cTeacher();
    test_class_cPupil();
}
 
///----------------------------------------------------------------------------|
/// Старт.
///----------------------------------------------------------------------------:
int main()
{                                                                        BANNER(
    " ///--------------------------------------------------------------------|",
    " /// Экзамен начат...                                                    |",
    " ///--------------------------------------------------------------------|");
    cRoom room;
    
    return 0;
}

int main()
{
}

#define FORi(v) for(int i = 0; i < v; ++i)
#define FORj(v) for(int j = 0; j < v; ++j)

        FORi(row)
        {   FORj(column)
            {   std::cout << arr[i][j];
            }
        }