Исправить и дополнить программу. Метод Карацубы. Исправить ошибку и сделать ввод и вывод данных

#include <cstring>
 
#define BASE 10 //система счисления
#define MINIMALNAI_DLINA_KARATSUBA 4 //числа короче умножаются квадратичным алгоритмом
typedef int civra; //взят только для разрядов числа
typedef unsigned long int size_dlina; //тип для длинны числа
 
using namespace std;
 
struct long_value { //тип для длинных чисел
    civra* values; //массив с цифрами числа записанными в обратном порядке
    size_dlina dlina; //длинна числа
};
 
long_value sum(long_value a, long_value b) {
    /* функция для суммирования двух длинных чисел. Если суммируются числа разной длинны
    * то более длинное передется в качестве первого аргумента.
    Возвращает новое
  * ненормализованное число.*/
    long_value s;
    s.dlina = a.dlina + 1;
    s.values = new civra[s.dlina];
 
    s.values[a.dlina - 1] = a.values[a.dlina - 1];
    s.values[a.dlina] = 0;
    for (size_dlina i = 0; i < b.dlina; ++i)
        s.values[i] = a.values[i] + b.values[i];
    return s;
}
 
long_value& sub(long_value& a, long_value b) {
    /*функция для вычитания одного длинного числа из другого. Изменяет содержимое первого
    * числа. Возвращает ссылку на первое число. Результат не нормализован.
    */
    for (size_dlina i = 0; i < b.dlina; ++i)
        a.values[i] -= b.values[i];
    return a;
}
 
void normalize(long_value l) {
    /*Нормализация числа - приведение каждого разряда в соответствие с системой счисления.
    *
    */
    for (size_dlina i = 0; i < l.dlina - 1; ++i) {
        if (l.values[i] >= BASE) { //если число больше максимального, то организовавается перенос
            civra carryover = l.values[i] / BASE;
            l.values[i + 1] += carryover;
            l.values[i] -= carryover * BASE;
        }
        else if (l.values[i] < 0) { //если меньше - заем
            civra carryover = (l.values[i] + 1) / BASE - 1;
            l.values[i + 1] += carryover;
            l.values[i] -= carryover * BASE;
        }
    }
}
 
long_value karatsuba(long_value a, long_value b) {
    long_value znachenie; //результирующее произведение
    znachenie.dlina = a.dlina + b.dlina;
    znachenie.values = new civra[znachenie.dlina];
 
    if (a.dlina < MINIMALNAI_DLINA_KARATSUBA) { //если число короче, то применять наивное умножение
        memset(znachenie.values, 0, sizeof(civra) * znachenie.dlina);
        for (size_dlina i = 0; i < a.dlina; ++i)
            for (size_dlina j = 0; j < b.dlina; ++j) {
                znachenie.values[i + j] += a.values[i] * b.values[j];
            }
    }
    else { //умножение методом Карацубы
        long_value a_part1; //младшая часть числа a
        a_part1.values = a.values;
        a_part1.dlina = (a.dlina + 1) / 2;
 
        long_value a_part2; //старшая часть числа a
        a_part2.values = a.values + a_part1.dlina;
        a_part2.dlina = a.dlina / 2;
 
        long_value b_part1; //младшая часть числа b
        b_part1.values = b.values;
        b_part1.dlina = (b.dlina + 1) / 2;
 
        long_value b_part2; //старшая часть числа b
        b_part2.values = b.values + b_part1.dlina;
        b_part2.dlina = b.dlina / 2;
 
        long_value sum_of_a_parts = sum(a_part1, a_part2); //cумма частей числа a
        normalize(sum_of_a_parts);
        long_value sum_of_b_parts = sum(b_part1, b_part2); //cумма частей числа b
        normalize(sum_of_b_parts);
        long_value rezyltat_summ_chastei = karatsuba(sum_of_a_parts, sum_of_b_parts);
        // произведение сумм частей
 
        long_value rezyltat_pervoi_chasti = karatsuba(a_part1, b_part1); //младший член
        long_value rezyltat_vtoroi_chasti = karatsuba(a_part2, b_part2); //старший член
        long_value summa_srednix_chlenov = sub(sub(rezyltat_summ_chastei, rezyltat_pervoi_chasti), rezyltat_vtoroi_chasti);
        //нахождение суммы средних членов
 
       // Суммирование многочлена
        
        memcpy(znachenie.values, rezyltat_pervoi_chasti.values,
            rezyltat_pervoi_chasti.dlina * sizeof(civra));
        memcpy(znachenie.values + rezyltat_pervoi_chasti.dlina,
            rezyltat_vtoroi_chasti.values, rezyltat_vtoroi_chasti.dlina
            * sizeof(civra));
        for (size_dlina i = 0; i < summa_srednix_chlenov.dlina; ++i)
            znachenie.values[a_part1.dlina + i] += summa_srednix_chlenov.values[i];
    }
 
    normalize(znachenie); //конечная нормализация числа
 
    return znachenie;
}