#include <iostream>
#include <string>

//TODO:
//include
//funkcjonalnosc
//zarzadzanie pamiecia

void mvec(int &length, int &amount, int &arrays_size, double &standard_value, int *offsets, int *values);
void def(int index, int value, int length, int &amount, int &arrays_size, int **offsets, int **values);
void len(int new_length, int &length, int &amount, int &arrays_size, int **offsets, int **values);
void print(int length, int amount, double standard_value, int *offsets, int *values);
void del(double &standard_value, int &length, int &amount, int &arrays_size, int *offsets, int *values);

int find(int value, int size, int *arr);
int read_value(int index, int end, double standard_value, int *offsets, int *values);
int *change_size(int *source, int new_size, int amount);
std::string to_string(int length, double standard_value, int amount, int *offsets, int *values);

int main() {
    int length = 0;                  //dlugosc wektora
    int amount = 0;                  //ilosc elementow roznych od podst. wartosci wektora
    int arrays_size = 0;             //wielkosc tablic przechowujacych wartosci wektora
    double standard_value = 0/0.0;   //podstawowa wartosc vectora
    int *offsets = nullptr;          //indexy poszczegolnych wartosci
    int *values = nullptr;           //poszczegolne wartosci
    
    
    
    std::string command;           //obsluga menu
    while (true) {
        std::cin >> command;
        
        if (command == "mvec") {
            mvec(length, amount, arrays_size, standard_value, offsets, values);
            
        } else if (command == "def") {
            int index;
            int value;
            int **ptr_offsets = &offsets;
            int **ptr_values = &values;
            std::cin >> index;
            std::cin >> value;
            
            def(index, value, length, amount, arrays_size, ptr_offsets, ptr_values);
            
        } else if (command == "len") {
            int new_length;
            int **ptr_offsets = &offsets;
            int **ptr_values = &values;
            std::cin >> new_length;
            
            len(new_length, length, amount, arrays_size, ptr_offsets, ptr_values);
            
        } else if (command == "print") {
            print(length, amount, standard_value, offsets, values);
            
        } else if (command == "del") {
            del(standard_value, length, amount, arrays_size, offsets, values);
            
        } else {
            std::cout << "Errorn";
        }
    }
}



void mvec(int &length, int &amount, int &arrays_size, double &standard_value, int *offsets, int *values) {
    std::cin >> length;
    std::cin >> standard_value;
    amount = 0;
    arrays_size = 0;
    
    delete[] offsets;
    delete[] values;
    
    offsets = nullptr;
    values = nullptr;
}

void def(int index, int value, int length, int &amount, int &arrays_size, int **offsets, int **values) {
    if (index >= 0 && index < length) {
        if (offsets != nullptr && values != nullptr) {
            if (arrays_size == amount) {
                *offsets = change_size(*offsets, arrays_size * 2, amount);
                *values = change_size(*values, arrays_size * 2, amount);
                arrays_size *= 2;
            }
            
            if (find(index, amount, *offsets) != -1) {
                (*values)[find(index, amount, *offsets)] = value;
            } else {
                (*offsets)[amount] = index;
                (*values)[amount] = value;
                amount++;
            }
            
        } else {
            *offsets = new int[1];
            *values = new int[1];
            
            (*offsets)[0] = index;
            (*values)[0] = value;
            amount = 1;
            arrays_size = 1;
        }
    } else {
        std::cout << "Errorn";
    }
}

void len(int new_length, int &length, int &amount, int &arrays_size, int **offsets, int **values) {
    if (new_length < length && (offsets != nullptr || offsets != nullptr)) {
        int new_amount = 0;
        while ((*offsets)[new_amount] < new_length) {
            new_amount++;
        }
        
        *offsets = change_size(*offsets, new_amount, new_amount);
        *values = change_size(*values, new_amount, new_amount);
        
        arrays_size = new_amount;
        amount = new_amount;
    }
    length = new_length;
}


void print(int length, int amount, double standard_value, int *offsets, int *values) {
    std::cout << to_string(length, standard_value, amount, offsets, values) << 'n';
}

void del(double &standard_value, int &length, int &amount, int &arrays_size, int *offsets, int *values) {
    standard_value = 0/0.0;
    length = 0;
    amount = 0;
    arrays_size = 0;
    
    delete[] offsets;
    delete[] values;
    
    offsets = nullptr;
    values = nullptr;
}

/*******************************************
 * ZWRACA POZYCJE SZUKANEGO ELEMNTU LUB -1 *
 *******************************************/
int find(int value, int size, int *arr) {
    int i = 0;
    while (i < size && arr[i] != value) {
        i++;
    }
    
    return i < size ? i : -1;
}


/***************************************
 * ODCZYTUJE WARTOSC Z DANEGO ELEMENTU *
 ***************************************/
int read_value(int index, int end, double standard_value, int *offsets, int *values) {
    int i = 0;
    while (i < end && offsets[i] != index) {
        i++;
    }
    
    return i < end ? values[i] : standard_value;
}

/***************************************************************
 * TWORZY NOWA TABLICE I KOPIUJE DO NIEJ ZAWARTOSC POPRZEDNIEJ *
 ***************************************************************/
int *change_size(int *source, int new_size, int old_size) {
    int *arr = new int[new_size];
    
    for (int i = 0; (i < old_size) && (i < new_size); i++) {
        arr[i] = source[i];
    }
    
    delete[] source;
    return arr;
}

/***************************************
 * ZWRACA STRING REPREZENTUJACY WEKTOR *
 ***************************************/
std::string to_string(int length, double standard_value, int amount, int *offsets, int *values) {
    std::string result = "len: " + std::to_string(length) + " values: ";
    
    if (offsets == nullptr || values == nullptr) {
        for (int i = 0; i < length; i++) {
            result += std::to_string(standard_value) + ',';
        }
    } else {
        for (int i = 0; i < length; i++) {
            result += std::to_string(read_value(i, amount, standard_value, offsets, values)) + ',';
        }
    }
    
    result.pop_back();
    return result;
}