// 包含所有标准库头文件
#include <bits/stdc++.h>
// 使用标准命名空间
using namespace std;

// 简单哈希表类
class SimpleHashMap {
private:
    // 桶数组：每个桶是一个键值对链表，用于处理哈希冲突
    vector<list<pair<int, int>>> buckets;
    // 当前元素数量
    int size;
    // 哈希表容量
    int capacity;
    // 负载因子阈值：当元素数量超过容量的75%时扩容
    const double load_factor = 0.75;
    
    // 哈希函数：将键映射到桶索引
    int hash(int key) {
        // 处理负数键，确保返回非负索引
        return (key % capacity + capacity) % capacity;
    }
    
    // 扩容函数：当负载因子超过阈值时调用
    void resize() {
        // 保存旧容量
        int old_cap = capacity;
        // 容量翻倍
        capacity *= 2;
        // 创建新的桶数组
        vector<list<pair<int, int>>> new_buckets(capacity);
        
        // 重新哈希所有元素到新桶
        for (int i = 0; i < old_cap; ++i)  // 遍历旧桶
            for (auto& kv : buckets[i]) {   // 遍历桶中的每个键值对
                int idx = hash(kv.first);    // 计算新的哈希索引
                new_buckets[idx].push_back(kv);  // 插入到新桶
            }
        // 交换新旧桶数组
        buckets.swap(new_buckets);
    }
    
public:
    // 构造函数：初始化哈希表
    SimpleHashMap() : size(0), capacity(16) {
        // 调整桶数组大小为初始容量
        buckets.resize(capacity);
    }
    
    // put操作：插入或更新键值对
    void put(int key, int value) {
        // 检查是否需要扩容
        if (size >= capacity * load_factor)
            resize();
        // 计算键的哈希索引
        int idx = hash(key);
        
        // 查找键是否已存在
        for (auto& kv : buckets[idx])
            if (kv.first == key) {
                // 键存在，更新值
                kv.second = value;
                // 操作完成，返回
                return;
            }
        // 键不存在，插入新键值对
        buckets[idx].emplace_back(key, value);
        // 元素数量加1
        size++;
    }
    
    // get操作：查询键对应的值
    int get(int key) {
        // 计算键的哈希索引
        int idx = hash(key);
        // 查找键
        for (auto& kv : buckets[idx])
            if (kv.first == key)
                // 键存在，返回对应的值
                return kv.second;
        // 键不存在，返回-1
        return -1;
    }
    
    // remove操作：删除键值对
    void remove(int key) {
        // 计算键的哈希索引
        int idx = hash(key);
        // 查找并删除键
        for (auto it = buckets[idx].begin(); it != buckets[idx].end(); ++it)
            if (it->first == key) {
                // 找到键，从链表中删除
                buckets[idx].erase(it);
                // 元素数量减1
                size--;
                // 操作完成，返回
                return;
            }
    }
};

// 主函数
int main() {
    // 输入输出优化，提高速度
    ios::sync_with_stdio(false);
    cin.tie(0);
    // 操作次数
    int N;
    // 读取操作次数
    cin >> N;
    // 创建哈希表实例
    SimpleHashMap map;
    
    // 处理N次操作
    for (int i = 0; i < N; ++i) {
        // 操作命令
        string op;
        // 读取操作命令
        cin >> op;
        
        // 处理put操作
        if (op == "put") {
            // 键和值
            int x, y;
            // 读取键和值
            cin >> x >> y;
            // 调用put方法
            map.put(x, y);
        // 处理get操作
        } else if (op == "get") {
            // 键
            int x;
            // 读取键
            cin >> x;
            // 调用get方法并输出结果
            cout << map.get(x) << endl;
        // 处理remove操作
        } else if (op == "remove") {
            // 键
            int x;
            // 读取键
            cin >> x;
            // 调用remove方法
            map.remove(x);
        }
    }
    
    return 0;
}