In this HackerEarth Convoluted Operations problem solution, Mishki is quite interested in playing games, and recently she found an empty stack. Now she wants to perform 3 types of operations on the stack:
1. 1 A : push element A in the stack.
2. 0 : pop one element from stack.
3. 2 K X : find how many elements were less than X present in the stack, after performing Kth operation on the stack.
Can you help her in performing the above operations ?

## HackerEarth Convoluted Operations problem solution.

```#include <bits/stdc++.h>
#define ll long long

using namespace std;
const int ma = 5e5+5;

ll n, ans[ma], pus[ma], bit[ma],op[ma], val[ma], compr[ma];
pair <ll, ll> p[ma];
vector < pair<ll,ll> >  v[ma];

void update(int x, int val)
{

while(x<=5e5)
{
bit[x]+=val;
x = x + (x&-x);
}
}
int query(int x)
{

int an=0;
while(x>0)
{
an+=bit[x];
x = x&(x-1);
}
return an;
}
int main(int argc, char* argv[])
{
//freopen(argv[1],"r",stdin);
//freopen(argv[2],"w",stdout);*/
cin>>n;
ll x,y,k,q=0,opr=1,cnt=0;

for(int i=1;i<=n;i++)
{
cin>>x;
if(x==1)
{
cin>>y;
p[i] = make_pair(x,y);
compr[cnt++] = y;
}
else if(x==0)
p[i] = make_pair(x,-1);
else
{
p[i] = make_pair(-1,-1);
cin>>op[q]>>val[q];
compr[cnt++] = val[q];
q++;
}
}
//compression
sort(compr, compr+cnt);
for(int i=1;i<=n;i++)
{

if(p[i].first!=-1 and p[i].second!=-1)
{
p[i].second = lower_bound(compr, compr+cnt, p[i].second) - compr+1;
}

}
for(int i=0;i<q;i++)
{
val[i] = lower_bound(compr, compr+cnt, val[i]) - compr+1;
}

for(int i=0;i<q;i++)
{
v[op[i]].push_back(make_pair(val[i],i));
}
int o=0;
for(int i=1;i<=n;i++)
{
if(p[i].first==1)
{
update(p[i].second,1);
pus[o++] = i;
}
else if(p[i].first==0)
{
update(p[pus[o-1]].second,-1);
o--;
}

if(v[i].size())
{
for(int j=0;j<v[i].size();j++)
{
ans[v[i][j].second] = query(v[i][j].first-1);
}
}
}
for(int i=0;i<q;i++)
{
cout<<ans[i]<<endl;
}
return 0;
}```

### Second solution

```#include <bits/stdc++.h>

using namespace std;

int N;
int A[500001];
vector<int> q[500001];
int T[500001];
int P[500001];
int X[500001];
int C[500001], NC;
int bit[500001];
int ans[500001];

{
for(x=lower_bound(C, C+NC, x)-C+1; x<=NC; x+=x&-x)
bit[x]+=v;
}

int sum(int x)
{
int ret=0;
for(x=lower_bound(C, C+NC, x)-C+1; x>0; x-=x&-x)
ret+=bit[x];
return ret;
}

void dfs(int u)
{
for(auto& it: q[u])
ans[it]=sum(X[it]);
{
dfs(v);
}
}

int main()
{
memset(ans, -1, sizeof ans);
scanf("%d", &N);
assert(1<=N && N<=500000);
int n=1;
for(int i=1; i<=N; i++)
{
int op;
scanf("%d", &op);
assert(0<=op && op<=2);
if(op==0)
{
assert(T[i-1]);
T[i]=P[T[i-1]];
}
else if(op==1)
{
scanf("%d", A+n);
assert(0<=A[n] && A[n]<=1000000000);
C[NC++]=A[n]+1;
P[n]=T[i-1];
T[i]=n++;
}
else
{
int k, x;
scanf("%d%d", &k, &x);
assert(1<=k && k<=i);
assert(0<=x && x<=1000000000);
C[NC++]=x;
X[i]=x;
T[i]=T[i-1];
q[T[k]].push_back(i);
}
}
sort(C, C+NC);
dfs(0);
for(int i=1; i<=N; i++) if(ans[i]!=-1)
printf("%d\n", ans[i]);
return 0;
}```