#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
//#pragma GCC optimize("O3")
//#pragma GCC target("avx,avx2,fma")
//#pragma GCC optimization ("unroll-loops")
//#pragma GCC target("avx,avx2,sse,sse2,sse3,sse4,popcnt")
using namespace std;
using namespace __gnu_pbds;
//#define int long long
#define float long double
#define elif else if
#define endl "\n"
#define mod 1000000007
#define pi acos(-1)
#define eps 0.000000001
#define inf 1000'000'000'000'000'000LL
#define FIXED(a) cout << fixed << setprecision(a)
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define time_init auto start = std::chrono::high_resolution_clock::now()
#define time_report \
auto end = std::chrono::high_resolution_clock::now(); \
std::cout << std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count() << " ms" << endl
#define debug(x) \
{ cerr << #x << " = " << x << endl; }
#define len(x) (int) x.size()
#define sqr(x) ((x) * (x))
#define cube(x) ((x) * (x) * (x))
#define bit(x, i) (((x) >> (i)) & 1)
#define set_bit(x, i) ((x) | (1LL << (i)))
#define clear_bit(x, i) ((x) & (~(1LL << (i))))
#define toggle_bit(x, i) ((x) ^ (1LL << (i)))
#define low_bit(x) ((x) & (-(x)))
#define count_bit(x) __builtin_popcountll(x)
#define srt(x) sort(all(x))
#define rsrt(x) sort(rall(x))
#define mp make_pair
#define maxel(x) (*max_element(all(x)))
#define minel(x) (*min_element(all(x)))
#define maxelpos(x) (max_element(all(x)) - x.begin())
#define minelpos(x) (min_element(all(x)) - x.begin())
#define sum(x) (accumulate(all(x), 0LL))
#define product(x) (accumulate(all(x), 1LL, multiplies<int>()))
#define gcd __gcd
#define lcm(a, b) ((a) / gcd(a, b) * (b))
#define rev(x) (reverse(all(x)))
#define shift_left(x, k) (rotate(x.begin(), x.begin() + k, x.end()))
#define shift_right(x, k) (rotate(x.rbegin(), x.rbegin() + k, x.rend()))
#define is_sorted(x) (is_sorted_until(all(x)) == x.end())
#define is_even(x) (((x) &1) == 0)
#define is_odd(x) (((x) &1) == 1)
#define pow2(x) (1LL << (x))
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
// http://xorshift.di.unimi.it/splitmix64.c
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
template<typename T>
using min_heap = priority_queue<T, vector<T>, greater<T>>;
template<typename T>
using max_heap = priority_queue<T, vector<T>, less<T>>;
template<typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
template<typename T>
using ordered_multiset = tree<T, null_type, less_equal<T>, rb_tree_tag, tree_order_statistics_node_update>;
template<typename T>
using matrix = vector<vector<T>>;
template<typename T>
using graph = vector<vector<T>>;
using hashmap = gp_hash_table<int, int, custom_hash>;
template<typename T>
vector<T> vect(int n, T val) {
return vector<T>(n, val);
}
template<typename T>
vector<vector<T>> vect(int n, int m, T val) {
return vector<vector<T>>(n, vector<T>(m, val));
}
template<typename T>
vector<vector<vector<T>>> vect(int n, int m, int k, T val) {
return vector<vector<vector<T>>>(n, vector<vector<T>>(m, vector<T>(k, val)));
}
template<typename T>
vector<vector<vector<vector<T>>>> vect(int n, int m, int k, int l, T val) {
return vector<vector<vector<vector<T>>>>(n, vector<vector<vector<T>>>(m, vector<vector<T>>(k, vector<T>(l, val))));
}
template<typename T>
matrix<T> new_matrix(int n, int m, T val) {
return matrix<T>(n, vector<T>(m, val));
}
template<typename T>
graph<T> new_graph(int n) {
return graph<T>(n);
}
template<class T, class S>
inline bool chmax(T &a, const S &b) {
return (a < b ? a = b, 1 : 0);
}
template<class T, class S>
inline bool chmin(T &a, const S &b) {
return (a > b ? a = b, 1 : 0);
}
using i8 = int8_t;
using i16 = int16_t;
using i32 = int32_t;
using i64 = int64_t;
using i128 = __int128_t;
using u8 = uint8_t;
using u16 = uint16_t;
using u32 = uint32_t;
using u64 = uint64_t;
using u128 = __uint128_t;
template<typename T>
using vec = vector<T>;
struct node {
int val;
int cnt;
int left, right;
explicit node(int val) : val(val), left(-1), right(-1) {
if (val != -1) cnt = 1;
else cnt = 0;
}
};
vec<node> nodes;
void fetch(int id) {
if (id == -1) return;
nodes[id].cnt = 0;
if (nodes[id].left != -1) nodes[id].cnt += nodes[nodes[id].left].cnt;
if (nodes[id].right != -1) nodes[id].cnt += nodes[nodes[id].right].cnt;
}
int add_node(int x) {
nodes.emplace_back(x);
return len(nodes) - 1;
}
int build(int l, int r) {
if (l == r) {
return add_node(-1);
}
int m = (l + r) / 2;
int new_root = add_node(-1);
int id = build(l, m);
nodes[new_root].left = id;
id = build(m + 1, r);
nodes[new_root].right = id;
fetch(new_root);
return new_root;
}
int update(int v, int l, int r, int pos, int val) {
if (l == r) {
return add_node(val);
}
int m = (l + r) / 2;
int new_node = add_node(-1);
if (pos <= m) {
int left = update(nodes[v].left, l, m, pos, val);
nodes[new_node].left = left;
nodes[new_node].right = nodes[v].right;
} else {
int right = update(nodes[v].right, m + 1, r, pos, val);
nodes[new_node].right = right;
nodes[new_node].left = nodes[v].left;
}
fetch(new_node);
return new_node;
}
int get(int v, int l, int r, int pos) {
if (l == r) {
return nodes[v].val;
}
int m = (l + r) / 2;
if (pos <= m) {
return get(nodes[v].left, l, m, pos);
} else {
return get(nodes[v].right, m + 1, r, pos);
}
}
const int maxN = 1e6 + 5;
vec<int> roots;
void Init() {
roots.push_back(build(0, maxN));
}
void TypeLetter(char L) {
// node *last = roots.back();
// node *new_n = update(last, 0, maxN, last->cnt, L);
// roots.push_back(new_n);
int last = roots.back();
int new_n = update(last, 0, maxN, nodes[last].cnt, L);
roots.push_back(new_n);
}
void UndoCommands(i32 U) {
// node *pr = roots[len(roots) - U - 1];
// roots.push_back(pr);
int pr = roots[len(roots) - U - 1];
roots.push_back(pr);
}
char GetLetter(i32 P) {
return get(roots.back(), 0, maxN, P);
}
