bruh

1Y-2H/prog/Makefile

@@ -1,7 +1,7 @@
 CC = gcc
 
-CFLAGS = -I./include -g
-LDFLAGS = -lncursesw -lpanel -lmenu
+CFLAGS = -I./include -g -Wall -Wextra -Wpedantic -g -O0
+LDFLAGS = 
 
 TARGET = matrix
 

1Y-2H/prog/docs/docs.md

@@ -1,111 +0,0 @@
-## Matrix
-
-Когда вы запускаете програму она будет ожидать одну из следующих коммнад.
-Ввод чисел будет проигнорирован но, адм символы приведут к завершению программы.
-
-При вводе символов весь ввод является строкой. 
-Делителем строк являются - Space Enter EOT 
-Также каждый 10 символ - новая строка
-При вводе, каждое запрашиваемое значение должно заканчиваться делителем
-
-###### Пример:
-
-create
-0
-10 20
-getmatrix
-exit
-
-Номер матрицы ограничен их возможным колличеством установленным в header.h
-По умолчанию = 20
-
-Если вы пытаетесь манипулировать несуществующей матрицей 
-То будет создана матрица 4 X 4 со случайными значениями от -100 до 100 
-
-## 
-
-Далее будет описыватся только ожидаеммый ввод после команды.
-Функцианал коммнады понятен из названия.
-
-#### create
-
-(Ожидается 3 числа)
-номер-матрицы
-коллво-строк
-коллво-колон
-
-#### input
-
-(Ожидается 1 число)
-номер-матрицы
-(далее будет ввод матрицы X на Y необходимо ввести X\*Y значений)
-int1 int2 int3 ... int(x\*y)
-
-#### getmatrix
-
-(Ожидается 1 число)
-номер-матрицы
-
-#### logic
-
-(Ожидается 2 числа)
-номер-матрицы1
-номер-матрицы2
-(Ожидается логическая операция > < >= <= != == )
-Логическа-операция
-
-#### edit
-
-(Ожидается 1 число)
-номер-матрицы
-(Далее принимает X\*Y чисел и заменяет предыдущие)
-(Так же может принять 3 буквенных выражения, 
-add - все последующие введёные числа будут добавлены к имеющимся
-sub - от всех имеющихся чисел будут отняты последующие введёные
-point - указать на точку в массиве начиная с которой продолжить заполнение, row:col для разделения могут использоваться , . :)
-
-
-#### random
-
-(Ожидается 1 число)
-номер-матрицы
-
-#### copy
-
-(Ожидается 2 числа)
-номер-матрицы-откуда-копировать
-номер-матрицы-куда-копировать
-
-#### destruct
-
-(Ожидается 1 число)
-номер-матрицы
-
-#### getcolum
-
-(Ожидается 2 числа)
-номер-матрицы
-номер-столбца
-
-#### getrow
-
-(Ожидается 2 числа)
-номер-матрицы
-номер-строки
-
-#### transp
-
-(Ожидается 1 число)
-номер-матрицы
-
-#### determ
-
-(Ожидается 1 число)
-номер-матрицы
-
-#### obr
-
-(Ожидается 1 число)
-номер-матрицы
-
-#### exit

1Y-2H/prog/include/head.h

@@ -1,23 +0,0 @@
-#ifndef Head
-#define Head
-
-// INCLUDE 
-    #include <stdio.h>
-    #include <stdlib.h>
-    #include <limits.h>
-
-// DEFINE
-    #define BUFF_MAX 10 //(char) <= 254
-    #define IN_BUFF_CHARS 10 //(char) <= 254
-    
-//TypeDef
-
-// FUNC
-    // === io.c ===
-    MATRIX2D* create_matrix2d(int rows, int cols);
-    char buff_input(char *inbuff, char *_buff);
-    char cmd_buff(char* _buff,char** _charCommands,char NUM_OF_CHAR_COMMANDS);
-    char get_matrix_num(void);
-    int get_num(void);
-
-#endif

1Y-2H/prog/include/include.h

@@ -0,0 +1,15 @@
+// ===<>===<>===-< <<< include/include.h >>> >-===<>===<>===
+
+#ifndef INCLUDEH
+#define INCLUDEH
+
+    #include <stdio.h>
+    #include <stdlib.h>
+    #include <limits.h>
+    #include <string.h>
+    #include <stdint.h>
+    
+    #define QUERRY_MAX 10 //(char) <= 254
+    #define IN_QUERRY_CHARS 10 //(char) <= 254
+
+#endif

1Y-2H/prog/include/io.h

@@ -0,0 +1,23 @@
+// ===<>===<>===-< <<< include/io.h >>> >-===<>===<>===
+
+#ifndef IOH
+#define IOH
+
+    typedef struct{
+        unsigned int n;
+        char** str;
+    }CMD_LIST;
+    
+    typedef struct{
+        unsigned int n;
+        CMD_LIST** list;
+    }CMD_GRP_LIST;
+
+
+    void init_io(void);
+    [[nodiscard]] int create_cmd_list(char* get[],int n);
+    void del_cmd_list(int id);
+    char querry_input(char *inbuff, char *_buff);
+    [[nodiscard]] char cmd_querry(char* _querry,int id);
+    [[nodiscard]] int get_int(void);
+#endif

1Y-2H/prog/include/matrixstruct.h

@@ -1,28 +0,0 @@
-#ifndef Head
-#define Head
-
-    #define MAX_MATRIX_ALIVE 21
-    
-    typedef struct {
-        int rows;
-        int cols;
-        int** data;
-    } MATRIX2D;
-
-    void create_matrix(MATRIX2D** addr, unsigned char n, int rows, int cols);
-    void input_matrix(MATRIX2D** addr, unsigned char n);
-    void get_matrix(MATRIX2D** addr, unsigned char n);
-    void logic_matrix(MATRIX2D** addr, unsigned char n1, unsigned char n2);
-    void edit_matrix(MATRIX2D** addr, unsigned char n);
-    void matrix_random(MATRIX2D** addr, unsigned char n);
-    void copy_matrix(MATRIX2D** addr, unsigned char n1, unsigned char n2);
-    void free_matrix(MATRIX2D** addr, unsigned char n);
-    void get_matrix_col(MATRIX2D** addr, unsigned char n, int c);
-    void get_matrix_row(MATRIX2D** addr, unsigned char n, int r);
-    void transp_matrix(MATRIX2D** addr, unsigned char n);
-    long long int determ_matrix(MATRIX2D** addr, unsigned char n);
-    void obr_matrix(MATRIX2D** addr, unsigned char n);
-    void is_Matrix_Exist(MATRIX2D** addr, unsigned char n);
-
-
-#endif

1Y-2H/prog/input

@@ -1,38 +0,0 @@
-create 0 3 3
-input 0
-1 2 3
-4 5 6
-7 8 9
-getmatrix 0
-n n
-transp 0
-getmatrix 0
-n n
-create 1 3 3
-random 1
-getmatrix 1
-n
-logic 0 1 >= n
-logic 0 0 == n
-edit 0
-add
-1 1 1
-1 1 1
-1 1 1
-getmatrix 0
-n
-edit 0
-point 1:1
-sub
-10 10
-getmatrix 0
-n
-getcolum 0 1
-getrow 0 2
-n
-copy 0 5
-getmatrix 5
-n
-determ 5
-destruct 5
-exit

1Y-2H/prog/src/io.c

@@ -1,108 +1,155 @@
-#include "head.h"
+// ===<>===<>===-< <<< src/io.c >>> >-===<>===<>===
 
-char buff_input(char *inbuff, char *_buff){
-    
-    *inbuff = 0;
-    { // INPUT
-        char ch;
-        while((ch=getchar())>' '&&*inbuff<BUFF_MAX){
-            *(_buff+*inbuff)=(int)ch;
-            (*inbuff)++;
+#include <include.h>
+#include <io.h>
+
+#include "include.h"
+#include "io.h"
+
+static CMD_GRP_LIST cmd_list = {0, NULL};
+
+void init_io(void){
+    cmd_list.list = NULL;
+    cmd_list.n = 0;
+}
+
+[[nodiscard]] int create_cmd_list(char* get[], int n){
+    if (n <= 0) return -1;
+
+    CMD_LIST* newlist = malloc(sizeof(CMD_LIST));
+    if (!newlist) return -1;
+
+    newlist->n = n;
+    newlist->str = malloc(n * sizeof(char*));
+
+    if (!newlist->str) {
+        free(newlist);
+        return -1;
+    }
+
+    for (int i = 0; i < n; i++) {
+        newlist->str[i] = malloc(strlen(get[i]) + 1);
+
+        if (!newlist->str[i]) {
+            for (int j = 0; j < i; j++)
+                free(newlist->str[j]);
+
+            free(newlist->str);
+            free(newlist);
+            return -1;
         }
-        if(ch<= 4)return -1;
+
+        strcpy(newlist->str[i], get[i]);
     }
 
+    CMD_LIST** tmp = realloc(cmd_list.list, (cmd_list.n + 1) * sizeof(CMD_LIST*));
 
-    if (_buff[0]>='a' && _buff[0] <= 'z')
-        {   // Is input - command?
-        const char NUM_OF_CHAR_COMMANDS = 15;
-        char * _charCommands[NUM_OF_CHAR_COMMANDS]; // _charCommands[*]["char"]
-        _charCommands[0]    = (char[]){"input"};
-        _charCommands[1]    = (char[]){"getmatrix"};
-        _charCommands[2]    = (char[]){"logic"};
-        _charCommands[3]    = (char[]){"edit"};
-        _charCommands[4]    = (char[]){"random"};
-        _charCommands[5]    = (char[]){"copy"};
-        _charCommands[6]    = (char[]){"destruct"};
-        _charCommands[7]    = (char[]){"getcolum"};
-        _charCommands[8]    = (char[]){"getrow"};
-        _charCommands[9]    = (char[]){"transp"};
-        _charCommands[10]   = (char[]){"determ"};
-        _charCommands[11]   = (char[]){"obr"};
-        _charCommands[12]   = (char[]){"create"};
-        _charCommands[13]   = (char[]){"n"};
-        _charCommands[14]   = (char[]){"exit"};
+    if (!tmp) {
+        for (int i = 0; i < n; i++)
+            free(newlist->str[i]);
 
-
-        char cmd = cmd_buff(_buff,_charCommands,NUM_OF_CHAR_COMMANDS);
-        if(cmd==15)return -1; //exit  
-        return cmd; //Вернуть комману    
+        free(newlist->str);
+        free(newlist);
+        return -1;
     }
 
+    cmd_list.list = tmp;
+    cmd_list.list[cmd_list.n] = newlist;
+
+    cmd_list.n++;
+
+    return cmd_list.n - 1;
+}
+
+void del_cmd_list(int id){
+    if (id < 0 || (unsigned int)id >= cmd_list.n)
+        return;
+
+    CMD_LIST* list = cmd_list.list[id];
+
+    if (list == NULL)
+        return;
+
+    for (unsigned int i = 0; i < list->n; i++) {
+        free(list->str[i]);
+    }
+
+    free(list->str);
+    free(list);
+
+    for (unsigned int i = id; i + 1 < cmd_list.n; i++) {
+        cmd_list.list[i] = cmd_list.list[i + 1];
+    }
+
+    cmd_list.n--;
+
+    if (cmd_list.n == 0) {
+        free(cmd_list.list);
+        cmd_list.list = NULL;
+        return;
+    }
+
+    CMD_LIST** tmp = realloc(cmd_list.list, cmd_list.n * sizeof(CMD_LIST*));
+
+    if (tmp != NULL) {
+        cmd_list.list = tmp;
+    }
+}
+
+char querry_input(char *inquerry, char *_querry){
+    int ch;
+    *inquerry = 0;
+
+    memset(_querry, 0, QUERRY_MAX);
+
+    while ((ch = getchar()) > ' ' && *inquerry < QUERRY_MAX - 1) {
+        _querry[(int)*inquerry] = (char)ch;
+        (*inquerry)++;
+    }
+
+    _querry[(int)*inquerry] = '\0';
+
+    if (ch == EOF)
+        return -1;
+
     return 0;
 }
 
-char cmd_buff(char* _buff,char** _charCommands,char NUM_OF_CHAR_COMMANDS){
-    for (int i = 0;i<NUM_OF_CHAR_COMMANDS;i++){
-        char flag = 1;
-        for(int j = 0;*(_charCommands[i]+j)!='\0';j++){
-            if (_buff[j]!=*(_charCommands[i]+j)){
-                flag = 0;
-                break;
-            }
-        }
-        if(flag) return i+1;//Вернуть комманду
+[[nodiscard]] char cmd_querry(char* _querry, int id){
+    if (id < 0 || (unsigned int)id >= cmd_list.n)
+        return -1;
+
+    CMD_LIST* list = cmd_list.list[id];
+
+    if (!list)
+        return -1;
+
+    for (unsigned int i = 0; i < list->n; i++) {
+        if (strcmp(_querry, list->str[i]) == 0)
+            return i;
     }
-    return 0;
+
+    return -1;
 }
 
-char get_matrix_num(void){
-    char inbuff;
-    char _buff[BUFF_MAX];
-    while(buff_input(&inbuff,_buff)>0&&*_buff>' ');
+[[nodiscard]] int get_int(void){
+    char inquerry;
+    char _querry[QUERRY_MAX];
+    while(querry_input(&inquerry,_querry) > 0 && *_querry > ' ');
 
     long int num = 0;
     char flagIsDec = 1;
     { // GetNum
         int i = 0;
-        if(_buff[0]=='-'){i++;flagIsDec = -1;}
-        
-        for(; i<inbuff;i++)
-            if(_buff[i]>= '0' && _buff[i] <= '9')
-                num = (num*10) + (_buff[i]-'0');
-        num *= flagIsDec;
-    }
-        if (num>MAX_MATRIX_ALIVE)num = MAX_MATRIX_ALIVE;
-        if (num<0)num = 0;
-        return num;
-}
+        if(_querry[0]=='-'){i++;flagIsDec = -1;}
 
-
-int get_num(void){
-    char inbuff;
-    char _buff[BUFF_MAX];
-    while(buff_input(&inbuff,_buff)>0&&*_buff>' ');
-
-    long int num = 0;
-    char flagIsDec = 1;
-    { // GetNum
-        int i = 0;
-        if(_buff[0]=='-'){i++;flagIsDec = -1;}
-        
-        for(; i<inbuff;i++)
-            if(_buff[i]>= '0' && _buff[i] <= '9')
-                num = (num*10) + (_buff[i]-'0');
+        for(; i<inquerry;i++)
+            if(_querry[i]>= '0' && _querry[i] <= '9')
+                num = (num*10) + (_querry[i]-'0');
         num *= flagIsDec;
     }
         if (num>INT_MAX)num = INT_MAX;
         if (num<INT_MIN)num = INT_MIN;
         return (int)num;
 }
-/*
-void outputInt(int n){
 
-}
-
-void outputStr(char* str){
-
-}*/ // Подрузамевалось подобный io но он это нецелесообразная трата времени

1Y-2H/prog/src/main.c

@@ -1,119 +1,78 @@
-#include "matrixstruct.h"
-#include "head.h"
+// ===<>===<>===-< <<< src/main.c >>> >-===<>===<>===
 
-int main(void){
+#include "include.h"
+#include "io.h"
+
+enum{
+        CMD_MAIN_CREATE,
+        CMD_MAIN_INPUT,
+        CMD_MAIN_DEL,
+        CMD_MAIN_SHOW,
+        CMD_MAIN_LOGIC,
+        CMD_MAIN_EDIT,
+        CMD_MAIN_RAND,
+        CMD_MAIN_COPY,
+        CMD_MAIN_EXIT,
+        CMD_MAIN_TEST,
+
+        CMD_MAIN_COUNT
+}CMD_MAIN_ENUM;
+
+void declarete_cmd_main(void);
+
+int main(){
+    //declarete_cmd_main();
+    init_io();
+    char mode = 1;
+    char inquerry;
+    char querry[QUERRY_MAX];
     
-    MATRIX2D** __matrixAddr = (MATRIX2D**)calloc(MAX_MATRIX_ALIVE,sizeof(MATRIX2D*));
-    if(__matrixAddr == NULL) {printf("ERROR.__matrixAddr NotExist");return 1;}
+    int main_cmd_id = create_cmd_list((char*[]){
+    "create", "input", "del", "show",
+    "logic", "edit", "rand", "copy",
+    "exit", "test"
+    }, 10);
+
+    if (main_cmd_id < 0) {
+        printf("Failed to create command list\n");
+        return 1;
+    }
     
-    char mode;
     do{
-        char inbuff;
-        char _buff[BUFF_MAX];
-        char n1,n2;
-        int num1,num2;
-        mode = buff_input(&inbuff,_buff);
-        {
-            switch(mode){
-                case 1:
-                    n1 = get_matrix_num();
-                    is_Matrix_Exist(__matrixAddr,n1);
-                    input_matrix(__matrixAddr,n1);
-                    break;
-
-                case 2:  // output
-                    n1 = get_matrix_num();
-                    is_Matrix_Exist(__matrixAddr,n1);
-                    get_matrix(__matrixAddr,n1);
-
-                    break;
-
-                case 3:  // logic
-                    n1 = get_matrix_num();
-                    n2 = get_matrix_num();
-                    is_Matrix_Exist(__matrixAddr,n1);
-                    is_Matrix_Exist(__matrixAddr,n2);
-                    logic_matrix(__matrixAddr,n1,n2);
-                    break;
-
-                case 4:  // edit
-                    n1 = get_matrix_num();
-                    is_Matrix_Exist(__matrixAddr,n1);
-                    edit_matrix(__matrixAddr,n1);
-                    break;
-
-                case 5:  // random
-                    n1 = get_matrix_num();
-                    is_Matrix_Exist(__matrixAddr,n1);
-                    matrix_random(__matrixAddr,n1);
-                    break;
-
-                case 6:  // copy
-                    n1 = get_matrix_num();
-                    n2 = get_matrix_num();
-                    is_Matrix_Exist(__matrixAddr,n1);
-                    free_matrix(__matrixAddr,n2);
-                    copy_matrix(__matrixAddr,n1,n2);
-                    break;
-
-                case 7:  // destroy
-                    n1 = get_matrix_num();
-                    free_matrix(__matrixAddr,n1);
-                    break;
-
-                case 8:  // get colum
-                    n1 = get_matrix_num();
-                    num1 = get_num();
-                    is_Matrix_Exist(__matrixAddr,n1);
-                    get_matrix_col(__matrixAddr,n1,num1);
-                    break;
-
-                case 9:  // get row
-                    n1 = get_matrix_num();
-                    num1 = get_num();
-                    is_Matrix_Exist(__matrixAddr,n1);
-                    get_matrix_row(__matrixAddr,n1,num1);
-                    break;
-
-                case 10: // transp
-                    n1 = get_matrix_num();
-                    is_Matrix_Exist(__matrixAddr,n1);
-                    transp_matrix(__matrixAddr,n1);
-                    break;
-
-                case 11: // determ
-                    n1 = get_matrix_num();
-                    is_Matrix_Exist(__matrixAddr,n1);
-                    printf("%lld",determ_matrix(__matrixAddr,n1));
-                    
-                    break;
-
-                case 12: //obr
-                    n1 = get_matrix_num();
-                    is_Matrix_Exist(__matrixAddr,n1);
-                    obr_matrix(__matrixAddr,n1);
-                    break;
- 
-                case 13:
-                    n1 = get_matrix_num();
-                    num1 = get_num();
-                    num2 = get_num();
-                    free_matrix(__matrixAddr,n1);
-                    create_matrix(__matrixAddr,n1,num1,num2);
-                    break;
-                       
-                case 15:
-                    putchar('\n');
-                    putchar('\n');
-                    break;
-
-                case 0:  // wrong input
-                    break;
- 
-                case -1: return 0;
-                }
-        }
-    }while(mode>=0);
+        querry_input(&inquerry, querry);
+        int cmd = cmd_querry(querry,main_cmd_id);
+        //printf("CMD = %d\n",cmd);
+        switch(cmd){
+            case CMD_MAIN_CREATE:
+                
+            break;
+            case CMD_MAIN_INPUT:
+                
+            break;
+            case CMD_MAIN_DEL:
+                
+            break;
+            case CMD_MAIN_SHOW:
+                
+            break;
+            case CMD_MAIN_LOGIC:
+                
+            break;
+            case CMD_MAIN_EDIT:
+                
+            break;
+            case CMD_MAIN_RAND:
+                
+            break;
+            case CMD_MAIN_COPY:
+                
+            break;
+            case CMD_MAIN_EXIT:
+                mode = 0;
+            break;
+        }   
+    }while(mode);
 
+    del_cmd_list(main_cmd_id);
     return 0;
 }

1Y-2H/prog/src/matrix.c

@@ -1,375 +0,0 @@
-#include "matrixstruct.h"
-#include "head.h"
-
-MATRIX2D* create_matrix2d(int rows,int cols) {
-    MATRIX2D* m = (MATRIX2D*)malloc(sizeof(MATRIX2D));
-    m->rows = rows;
-    m->cols = cols;
-    
-    m->data = (int**)malloc(rows * sizeof(int*));
-
-    for (int i = 0; i < rows; i++){
-        m->data[i] = (int*)malloc(cols * sizeof(int));
-    }
-
-    return m;
-}
-
-void create_matrix(MATRIX2D** __addr,unsigned char n,int rows,int cols){
-    __addr[n] = create_matrix2d(rows,cols);
-    for (int i = 0;i<rows;i++){
-        for(int j = 0;j<cols;j++){
-            __addr[n]->data[i][j] = 0;
-        }
-    }   
-}
-
-void input_matrix(MATRIX2D** __addr,unsigned char n){
-    int** data = __addr[n]->data;
-
-    for(int rows = 0; rows < __addr[n]->rows;rows++){
-        for(int cols = 0; cols < __addr[n]->cols;cols++){
-                int num = get_num();
-                data[rows][cols] = num;
-            }
-        }
-    }
-
-    void get_matrix(MATRIX2D** __addr,unsigned char n){
-        int rows = __addr[n]->rows;
-        int cols = __addr[n]->cols;
-    
-    //printf("\tМассив №%d",n);
-    //printf("Колл-во строк %d\nКолл-во колон %d\n\n",rows,cols);
-    for(int r = 0;r<rows;r++){
-        for(int c = 0;c<cols;c++){
-            printf("%d ",__addr[n]->data[r][c]);
-        }
-        putchar('\n');
-    }
-}
-
-void logic_matrix(MATRIX2D** __addr,unsigned char n1,unsigned char n2){
-    char inbuff;
-    char _buff[BUFF_MAX];
-    int** data1 = __addr[n1]->data;
-    int** data2 = __addr[n2]->data;
-    
-    char cmd = 0;
-    {
-        buff_input(&inbuff,_buff);
-        
-        const char NUM_OF_CHAR_COMMANDS = 6;
-        char * _charCommands[NUM_OF_CHAR_COMMANDS]; // _charCommands[*]["char"]
-        _charCommands[0]    = (char[]){"=="};
-        _charCommands[1]    = (char[]){"!="};
-        _charCommands[2]    = (char[]){">="};
-        _charCommands[3]    = (char[]){"<="};
-        _charCommands[4]    = (char[]){">"};
-        _charCommands[5]    = (char[]){"<"};
-
-        cmd = cmd_buff(_buff,_charCommands,NUM_OF_CHAR_COMMANDS);
-    }
-
-    long long int cost1 = 0;
-    {
-        for(int r = 0;r<__addr[n1]->rows;r++)
-            for(int c = 0;c<__addr[n1]->cols;c++)
-                cost1 += data1[r][c];
-    }
-    long long int cost2 = 0;
-    {
-        for(int r = 0;r<__addr[n2]->rows;r++)
-            for(int c = 0;c<__addr[n2]->cols;c++)
-                cost2 += data2[r][c];
-    }
-
-    switch(cmd){
-        case 0: //Null
-                putchar('-');putchar('1');
-            break;
-        case 1: // ==
-                putchar(cost1==cost2?'1':'0');
-            break;
-        case 2: // !=
-                putchar(cost1!=cost2?'1':'0');
-            break;
-        case 3: //>=
-                putchar(cost1>=cost2?'1':'0');
-            break;
-        case 4: //<=
-                putchar(cost1<=cost2?'1':'0');
-            break;
-        case 5: // >
-                putchar(cost1>cost2?'1':'0');
-            break;
-        case 6: // <
-                putchar(cost1<cost2?'1':'0');
-            break;
-    }
-}
-
-void edit_matrix(MATRIX2D** __addr, unsigned char n) {
-    char inbuff;
-    char _buff[BUFF_MAX];
-    int** data = __addr[n]->data;
-    int r = 0, c = 0;
-    char mode = 0;
-
-    char* _locStrings[3];
-    _locStrings[0] = (char[]){"point"};
-    _locStrings[1] = (char[]){"add"};
-    _locStrings[2] = (char[]){"sub"};
-
-    while (r < __addr[n]->rows) {
-        char res = buff_input(&inbuff, _buff);
-        if (res == -1) break;
-
-        if (_buff[0] == 'n' && inbuff == 1) break;
-
-        char loc_cmd = cmd_buff(_buff, _locStrings, 3);
-
-        if (loc_cmd == 1) {
-            buff_input(&inbuff, _buff);
-            long pr = 0, pc = 0;
-            int i = 0;
-            for (; i < inbuff && (_buff[i] != ':' && _buff[i] != ',' && _buff[i] != '.'); i++)
-                if (_buff[i] >= '0' && _buff[i] <= '9') pr = pr * 10 + (_buff[i] - '0');
-            for (i++; i < inbuff; i++)
-                if (_buff[i] >= '0' && _buff[i] <= '9') pc = pc * 10 + (_buff[i] - '0');
-
-            if (pr < __addr[n]->rows && pc < __addr[n]->cols) {
-                r = (int)pr;
-                c = (int)pc;
-            }
-            continue;
-        }
-
-        if (loc_cmd == 2) { mode = 1; continue; }
-        if (loc_cmd == 3) { mode = 2; continue; }
-
-        long val = 0;
-        int i = 0, sign = 1;
-        if (inbuff > 0 && _buff[0] == '-') { sign = -1; i++; }
-        for (; i < inbuff; i++) {
-            if (_buff[i] >= '0' && _buff[i] <= '9')
-                val = val * 10 + (_buff[i] - '0');
-        }
-        val *= sign;
-
-        if (mode == 1) {
-            long res_val = (long)data[r][c] + val;
-            data[r][c] = (res_val > INT_MAX) ? INT_MAX : (res_val < INT_MIN) ? INT_MIN : (int)res_val;
-        } else if (mode == 2) {
-            long res_val = (long)data[r][c] - val;
-            data[r][c] = (res_val > INT_MAX) ? INT_MAX : (res_val < INT_MIN) ? INT_MIN : (int)res_val;
-        } else {
-            data[r][c] = (val > INT_MAX) ? INT_MAX : (val < INT_MIN) ? INT_MIN : (int)val;
-        }
-
-        if (++c >= __addr[n]->cols) {
-            c = 0;
-            r++;
-        }
-    }
-}
-
-int get_rand(int min, int max) {
-    return (double)rand() / (RAND_MAX + 1.0) * (max - min) + min;
-}
-
-void matrix_random(MATRIX2D** __addr,unsigned char n){
-    unsigned int lo, hi;
-    __asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi));
-    srand(((unsigned long long)hi << 32) | lo);
-
-    for (int r = 0; r < __addr[n]->rows; r++){
-        for(int c = 0; c < __addr[n]->cols; c++){
-            __addr[n]->data[r][c] = get_rand(-100, 100);
-        }
-    }
-}
-
-void copy_matrix(MATRIX2D** __addr,unsigned char n1, unsigned char n2){
-    // n2 = n1
-    __addr[n2] = create_matrix2d(__addr[n1]->rows,__addr[n1]->cols);
-    
-    for(int i = 0; i<__addr[n1]->rows;i++){
-        for(int j = 0; j<__addr[n1]->cols;j++){
-            __addr[n2]->data[i][j] = __addr[n1]->data[i][j]; 
-        }
-    }
-}
-
-void free_matrix(MATRIX2D** __addr,unsigned char n){
-    if (__addr[n] == NULL) return;
-
-    MATRIX2D* m = __addr[n];
-    for (int i = 0; i < m->rows; i++) {
-        free(m->data[i]); 
-    }
-    free(m->data);
-    free(m);
-
-    __addr[n] = NULL;
-}
-
-void get_matrix_col(MATRIX2D** __addr,unsigned char n,int c){
-    //printf("colum %d - ",c);
-    if(c >= __addr[n]->cols)c = __addr[n]->cols - 1;
-    if(c<0)c = 0;
-    for(int i = 0;i<__addr[n]->rows;i++){
-        printf("%d ",__addr[n]->data[i][c]); 
-    }
-    putchar('\n');
-}
-
-void get_matrix_row(MATRIX2D** __addr,unsigned char n,int r){
-    //printf("row %d - ",r);
-    if(r >= __addr[n]->rows)r = __addr[n]->rows - 1;
-    if(r<0)r = 0;
-    for(int i = 0;i<__addr[n]->cols;i++){
-        printf("%d ",__addr[n]->data[r][i]); 
-    }
-    putchar('\n');
-}
-
-void transp_matrix(MATRIX2D** __addr,unsigned char n){
-    MATRIX2D* tr = create_matrix2d(
-        __addr[n]->cols,__addr[n]->rows);
-
-
-    int** dataDef = __addr[n]->data;
-    int** dataRes = tr->data;
-
-    for(int r = 0;r<__addr[n]->rows;r++)
-        for(int c = 0;c<__addr[n]->cols;c++)
-            dataRes[c][r] = dataDef[r][c];
-
-    free_matrix(__addr,n);
-    
-    __addr[n] = tr;
-}
-
-long long int determ_matrix(MATRIX2D** __addr, unsigned char n) {
-    int size = __addr[n]->rows;
-    int** data = __addr[n]->data;
-
-    if (size == 1) return data[0][0];
-    if (size == 2) return (long long int)data[0][0] * data[1][1] - (long long int)data[0][1] * data[1][0];
-
-    double det = 1.0;
-    double** temp = (double**)malloc(size * sizeof(double*));
-    for (int i = 0; i < size; i++) {
-        temp[i] = (double*)malloc(size * sizeof(double));
-        for (int j = 0; j < size; j++) temp[i][j] = (double)data[i][j];
-    }
-
-    for (int i = 0; i < size; i++) {
-        int pivot = i;
-        for (int j = i + 1; j < size; j++) {
-            double val1 = temp[j][i] < 0 ? -temp[j][i] : temp[j][i];
-            double val2 = temp[pivot][i] < 0 ? -temp[pivot][i] : temp[pivot][i];
-            if (val1 > val2) pivot = j;
-        }
-
-        if (pivot != i) {
-            double* swap = temp[i];
-            temp[i] = temp[pivot];
-            temp[pivot] = swap;
-            det *= -1;
-        }
-
-        double current_val = temp[i][i] < 0 ? -temp[i][i] : temp[i][i];
-        if (current_val < 1e-9) { 
-            for (int k = 0; k < size; k++) free(temp[k]);
-            free(temp);
-            return 0;
-        }
-
-        det *= temp[i][i];
-
-        for (int j = i + 1; j < size; j++) {
-            double factor = temp[j][i] / temp[i][i];
-            for (int k = i + 1; k < size; k++) {
-                temp[j][k] -= factor * temp[i][k];
-            }
-        }
-    }
-
-    long long int final_det;
-    if (det >= 0) final_det = (long long int)(det + 0.5);
-    else final_det = (long long int)(det - 0.5);
-
-    for (int i = 0; i < size; i++) free(temp[i]);
-    free(temp);
-
-    return final_det;
-}
-
-void obr_matrix(MATRIX2D** __addr, unsigned char n) {
-    int size = __addr[n]->rows;
-    if (size != __addr[n]->cols) return; 
-
-    long long int d = determ_matrix(__addr, n);
-    if (d == 0) return; 
-
-    double** temp = (double**)malloc(size * sizeof(double*));
-    for (int i = 0; i < size; i++) {
-        temp[i] = (double*)malloc(2 * size * sizeof(double));
-        for (int j = 0; j < size; j++) {
-            temp[i][j] = (double)__addr[n]->data[i][j];
-            temp[i][j + size] = (i == j ? 1.0 : 0.0); 
-        }
-    }
-
-    for (int i = 0; i < size; i++) {
-        int pivot = i;
-        for (int j = i + 1; j < size; j++) {
-            double v1 = temp[j][i] < 0 ? -temp[j][i] : temp[j][i];
-            double v2 = temp[pivot][i] < 0 ? -temp[pivot][i] : temp[pivot][i];
-            if (v1 > v2) pivot = j;
-        }
-
-        double* row_ptr = temp[i];
-        temp[i] = temp[pivot];
-        temp[pivot] = row_ptr;
-
-        double divisor = temp[i][i];
-        for (int j = i; j < 2 * size; j++) {
-            temp[i][j] /= divisor;
-        }
-
-        for (int k = 0; k < size; k++) {
-            if (k != i) {
-                double factor = temp[k][i];
-                for (int j = i; j < 2 * size; j++) {
-                    temp[k][j] -= factor * temp[i][j];
-                }
-            }
-        }
-    }
-
-    for (int i = 0; i < size; i++) {
-        for (int j = 0; j < size; j++) {
-            double val = temp[i][j + size];
-            if (val >= 0) __addr[n]->data[i][j] = (int)(val + 0.5);
-            else __addr[n]->data[i][j] = (int)(val - 0.5);
-        }
-    }
-
-    for (int i = 0; i < size; i++) free(temp[i]);
-    free(temp);
-}
-
-void is_Matrix_Exist(MATRIX2D** __addr,unsigned char n){
-    if(n > MAX_MATRIX_ALIVE) n = MAX_MATRIX_ALIVE-1;
-    if(__addr[n] == NULL){
-        //printf("Матрица №%d не существует, создана новая матрица 4x4\n",n);
-        __addr[n] = create_matrix2d(4,4);
-        matrix_random(__addr,n);
-        }
-
-    return;
-}
-