Change all comments into English:
int main()
{
    int values[] = { 100, 200, 300, 400, 500 };
    int values_size = sizeof(values) / sizeof(int);

    std::cout << "TESTING SIMPLIFIED PERSISTENT ARRAY\n";

    PersistentArray<int> my_persistent_array(values, values_size); // Version[0]

    my_persistent_array.addVersion(0, 2, -250); // Version[1]
    my_persistent_array.addVersion(1, 3, -150); // Version[2]
    my_persistent_array.printAllVersions();

    my_persistent_array.undo(); std::cout << "\tundo\n"; // reject last version
    my_persistent_array.printAllVersions(); std::cout << "\n";
    my_persistent_array.redo(); std::cout << "\tredo\n"; // repeat last action
    my_persistent_array.printAllVersions(); std::cout << "\n";

    std::cout << "\n==============================================\n";
    std::cout << "TESTING SIMPLIFIED PERSISTENT DOUBLY LINKED LIST\n";

    int arr[] = { 100, 200, 300 };
    int size = sizeof(arr) / sizeof(arr[0]);

    PersistentDoublyLinkedList<int> list2(arr, size);

    std::cout << "Initial versions:\n";
    list2.printAllVersions();


    std::cout << "\nVersions after modifications:\n";


    list2.push_front(-250); // Version[1]
    list2.push_front(-150); // Version[2]

    list2.printAllVersions();

    list2.undo();
    list2.printAllVersions();
    list2.redo();
    list2.printAllVersions();

    list2.push_back(350); // Version[1]
    list2.push_back(450); // Version[2]


    list2.printAllVersions();

    std::cout << "\n==============================================\n";
    std::cout << "TESTING SIMPLIFIED PERSISTENT ASSOCIATIVE ARRAY\n";

    //std::vector<std::string> keys = { "one", "two", "three" };

    //PersistentAssociativeArray<std::string, int> myPersistentMap(keys, values, values_size);
    //myPersistentMap.printAllVersions();

    std::vector<std::string> keys = { "zero", "one", "two", "three", "four" };
    //int values_array[] = { 10, 20, 30 };
    //size_t values_array_size = sizeof(values_array) / sizeof(values_array[0]);

    
    PersistentAssociativeArray<std::string, int> assoc_array(keys, values, values_size);
    assoc_array.printAllVersions(); // Вызов функции печати для проверки

    // Добавляем новую версию, изменяя ключ 2 на значение 25
    assoc_array.addVersion(0, "two", -250);
    assoc_array.printAllVersions();
    assoc_array.addVersion(1, "three", -150);
    assoc_array.printAllVersions();
    assoc_array.undo(); std::cout << "\tundo\n"; // reject last version
    assoc_array.printAllVersions(); std::cout << "\n";
    assoc_array.redo(); std::cout << "\tredo\n"; // repeat last action
    assoc_array.printAllVersions(); std::cout << "\n";
    

    std::cout << "\n==============================================\n";
    std::cout << "TESTING CONVERTATION\n";

    //double values2[] = { 100.1, 200.2, 300.3, 400.4, 500.5 };
    //int values2_size = sizeof(values2) / sizeof(double);
    // Создание вектора значений для конвертации
    std::vector<double> values2 = { 100.1, 200.2, 300.3, 400.4, 500.5 };

    // Конвертация массива в PersistentArray
    PersistentArray<double> array_to_convert(values2.data(), values2.size());
    std::cout << "Versions in PersistentArray:" << std::endl;
    array_to_convert.printAllVersions();

    // Конвертация из PersistentArray в PersistentDoublyLinkedList
    PersistentDoublyLinkedList<double> dll_from_array = Convert<double>::convertArrayToList(array_to_convert, 0);
    std::cout << "\nVersions in PersistentDoublyLinkedList (from array):" << std::endl;
    dll_from_array.printAllVersions();

    // Создание другого вектора для конвертации в PersistentDoublyLinkedList
    std::vector<double> values3 = { -100.1, -200.2, -300.3, -400.4, -500.5 };
    PersistentDoublyLinkedList<double> dll_to_convert(values3.data(), values3.size());
    std::cout << "\nVersions in PersistentDoublyLinkedList (initial):" << std::endl;
    dll_to_convert.printAllVersions();

    // Конвертация из PersistentDoublyLinkedList в PersistentArray
    PersistentArray<double> array_from_dll = Convert<double>::convertListToArray(dll_to_convert, 0);
    std::cout << "\nVersions in PersistentArray (from dll):" << std::endl;
    array_from_dll.printAllVersions();

    // Создание ключей для ассоциативного массива
    //std::vector<std::string> keys = { "one:", "two:", "three:", "four:", "five:" };
    std::vector<int> _keys = { 1, 2, 3, 4, 5 };

    // Конвертация из PersistentArray в PersistentAssociativeArray
    PersistentAssociativeArray<int, double> associative_array_from_array =
        Convert<double>::convertArrayToAssociativeArray<int>(array_to_convert, _keys, 0);
    std::cout << "\nVersions in PersistentAssociativeArray (from array):" << std::endl;
    associative_array_from_array.printAllVersions(); // Предполагается, что у вас есть метод печати

    // Конвертация из PersistentDoublyLinkedList в PersistentAssociativeArray
    PersistentAssociativeArray<int, double> associative_array_from_dll =
        Convert<double>::convertListToAssociativeArray<int>(dll_to_convert, _keys, 0);
    std::cout << "\nVersions in PersistentAssociativeArray (from dll):" << std::endl;
    associative_array_from_dll.printAllVersions(); // Предполагается, что у вас есть метод печати

    // Создание PersistentAssociativeArray
    PersistentAssociativeArray<int, double> associative_array(_keys, values2.data(), values2.size());
    std::cout << "Versions in PersistentAssociativeArray:" << std::endl;
    associative_array.printAllVersions(); // Предполагается, что есть метод печати

    // Конвертация из PersistentAssociativeArray в PersistentDoublyLinkedList
    PersistentDoublyLinkedList<double> dll_from_associative = Convert<double>::convertAssociativeArrayToList(associative_array);
    std::cout << "\nVersions in PersistentDoublyLinkedList (from associative):" << std::endl;
    dll_from_associative.printAllVersions();

    // Конвертация из PersistentAssociativeArray в PersistentArray
    PersistentArray<double> array_from_associative = Convert<double>::convertAssociativeArrayToArray(associative_array);
    std::cout << "\nVersions in PersistentArray (from associative):" << std::endl;
    array_from_associative.printAllVersions();

    return 0;

}