///Finding number of element s in a range which is greater than k
#include<bits/stdc++.h>
#define ll int
#define ff first
#define ss second
#define inf 1000000000
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
typedef tree<pair<ll,ll>,null_type,less<pair<ll,ll>>,rb_tree_tag,tree_order_statistics_node_update> indexed_pairset;
indexed_pairset vec[900000];
ll arr[90000];
ll k;
///log2(n)
void build(ll ind,ll left,ll right)
{
if(left==right)
{
ll c=0;
vec[ind].insert({arr[left],c});
return ;
}
ll mid=(left+right)/2;
build(2*ind,left,mid);
build(2*ind+1,mid+1,right);
ll c=0;
auto it1=vec[2*ind].begin();
auto it2=vec[2*ind+1].begin();
while(it1!=vec[2*ind].end()&&it2!=vec[2*ind+1].end())
{
if(it1->ff<=it2->ff)
{
vec[ind].insert({it1->ff,c});
c++;
it1++;
}
else
{
vec[ind].insert({it2->ff,c});
c++;
it2++;
}
}
while(it1!=vec[2*ind].end())
{
vec[ind].insert({it1->ff,c});
c++;
it1++;
}
while(it2!=vec[2*ind+1].end())
{
vec[ind].insert({it2->ff,c});
it2++;
c++;
}
}
///log2(n)
void update(ll ind,ll left,ll right,ll pos,ll val,ll old_val)
{
auto it=vec[ind].lower_bound({arr[pos],-inf});
ll l1=it->ss;
vec[ind].erase(it);
vec[ind].insert({val,l1});
if(left!=right)
{
ll mid=(left+right)/2;
if(pos<=mid)
update(2*ind,left,mid,pos,val,old_val);
else
update(2*ind+1,mid+1,right,pos,val,old_val);
}
else
{
arr[pos]=val;
}
}
///log2(n)
ll query(ll ind,ll left,ll right,ll i,ll j)
{
if(j<left||i>right)
return 0;
if(i<=left&&j>=right)
{
ll l1= vec[ind].size()-vec[ind].order_of_key({k+1,-inf});
return l1;
}
ll mid=(left+right)/2;
ll x=query(2*ind,left,mid,i,j);
ll y=query(2*ind+1,mid+1,right,i,j);
return x+y;
}
int main()
{
ll i,j,n,q,l,r,type;
scanf("%d",&n);
for(i=0; i<n; i++)
scanf("%d",&arr[i]);
build(1,0,n-1);
scanf("%d",&q);
for(i=0; i<q; i++)
{
scanf("%d",&type);
if(type==0)
{
scanf("%d%d",&l,&r);
l--;
update(1,0,n-1,l,r,arr[l]);
}
else
{
scanf("%d%d%d",&l,&r,&k);
l--;
r--;
printf("%d\n",query(1,0,n-1,l,r));
}
}
return 0;
}
Ly8vRmluZGluZyBudW1iZXIgb2YgZWxlbWVudCBzIGluIGEgcmFuZ2Ugd2hpY2ggaXMgZ3JlYXRlciB0aGFuIGsKI2luY2x1ZGU8Yml0cy9zdGRjKysuaD4KI2RlZmluZSBsbCBpbnQKI2RlZmluZSBmZiBmaXJzdAojZGVmaW5lIHNzIHNlY29uZAojZGVmaW5lIGluZiAxMDAwMDAwMDAwCiNpbmNsdWRlPGV4dC9wYl9kcy9hc3NvY19jb250YWluZXIuaHBwPgojaW5jbHVkZTxleHQvcGJfZHMvdHJlZV9wb2xpY3kuaHBwPgp1c2luZyBuYW1lc3BhY2Ugc3RkOwp1c2luZyBuYW1lc3BhY2UgX19nbnVfcGJkczsKdHlwZWRlZiB0cmVlPHBhaXI8bGwsbGw+LG51bGxfdHlwZSxsZXNzPHBhaXI8bGwsbGw+PixyYl90cmVlX3RhZyx0cmVlX29yZGVyX3N0YXRpc3RpY3Nfbm9kZV91cGRhdGU+IGluZGV4ZWRfcGFpcnNldDsKaW5kZXhlZF9wYWlyc2V0IHZlY1s5MDAwMDBdOwpsbCBhcnJbOTAwMDBdOwpsbCBrOwovLy9sb2cyKG4pCnZvaWQgYnVpbGQobGwgaW5kLGxsIGxlZnQsbGwgcmlnaHQpCnsKICAgIGlmKGxlZnQ9PXJpZ2h0KQogICAgewogICAgICAgIGxsIGM9MDsKICAgICAgICB2ZWNbaW5kXS5pbnNlcnQoe2FycltsZWZ0XSxjfSk7CiAgICAgICAgcmV0dXJuIDsKICAgIH0KICAgIGxsIG1pZD0obGVmdCtyaWdodCkvMjsKICAgIGJ1aWxkKDIqaW5kLGxlZnQsbWlkKTsKICAgIGJ1aWxkKDIqaW5kKzEsbWlkKzEscmlnaHQpOwogICAgbGwgYz0wOwogICAgYXV0byBpdDE9dmVjWzIqaW5kXS5iZWdpbigpOwogICAgYXV0byBpdDI9dmVjWzIqaW5kKzFdLmJlZ2luKCk7CiAgICB3aGlsZShpdDEhPXZlY1syKmluZF0uZW5kKCkmJml0MiE9dmVjWzIqaW5kKzFdLmVuZCgpKQogICAgewogICAgICAgIGlmKGl0MS0+ZmY8PWl0Mi0+ZmYpCiAgICAgICAgewogICAgICAgIHZlY1tpbmRdLmluc2VydCh7aXQxLT5mZixjfSk7CiAgICAgICAgYysrOwogICAgICAgIGl0MSsrOwogICAgICAgfQogICAgICAgZWxzZQogICAgICAgewogICAgICAgICAgIHZlY1tpbmRdLmluc2VydCh7aXQyLT5mZixjfSk7CiAgICAgICAgICAgYysrOwogICAgICAgICAgIGl0MisrOwogICAgICAgfQogICAgfQogICAgd2hpbGUoaXQxIT12ZWNbMippbmRdLmVuZCgpKQogICAgewogICAgICAgIHZlY1tpbmRdLmluc2VydCh7aXQxLT5mZixjfSk7CiAgICAgICAgYysrOwogICAgICAgIGl0MSsrOwogICAgfQogICAgIHdoaWxlKGl0MiE9dmVjWzIqaW5kKzFdLmVuZCgpKQogICAgewogICAgICAgIHZlY1tpbmRdLmluc2VydCh7aXQyLT5mZixjfSk7CiAgICAgICAgaXQyKys7CiAgICAgICAgYysrOwogICAgfQp9Ci8vL2xvZzIobikKdm9pZCB1cGRhdGUobGwgaW5kLGxsIGxlZnQsbGwgcmlnaHQsbGwgcG9zLGxsIHZhbCxsbCBvbGRfdmFsKQp7CiAgICAgIGF1dG8gaXQ9dmVjW2luZF0ubG93ZXJfYm91bmQoe2Fycltwb3NdLC1pbmZ9KTsKICAgICAgbGwgbDE9aXQtPnNzOwogICAgICB2ZWNbaW5kXS5lcmFzZShpdCk7CiAgICAgIHZlY1tpbmRdLmluc2VydCh7dmFsLGwxfSk7CiAgICAgIGlmKGxlZnQhPXJpZ2h0KQogICAgewogICAgICBsbCBtaWQ9KGxlZnQrcmlnaHQpLzI7CiAgICAgIGlmKHBvczw9bWlkKQogICAgICB1cGRhdGUoMippbmQsbGVmdCxtaWQscG9zLHZhbCxvbGRfdmFsKTsKICAgICAgZWxzZQogICAgICB1cGRhdGUoMippbmQrMSxtaWQrMSxyaWdodCxwb3MsdmFsLG9sZF92YWwpOwogICAgfQogICAgICBlbHNlCiAgICAgIHsKICAgICAgICBhcnJbcG9zXT12YWw7CiAgICAgIH0KfQovLy9sb2cyKG4pCmxsIHF1ZXJ5KGxsIGluZCxsbCBsZWZ0LGxsIHJpZ2h0LGxsIGksbGwgaikKewogICAgaWYoajxsZWZ0fHxpPnJpZ2h0KQogICAgICAgIHJldHVybiAwOwogICAgaWYoaTw9bGVmdCYmaj49cmlnaHQpCiAgICB7CiAgICAgICAgbGwgbDE9IHZlY1tpbmRdLnNpemUoKS12ZWNbaW5kXS5vcmRlcl9vZl9rZXkoe2srMSwtaW5mfSk7CiAgICAgICAgcmV0dXJuIGwxOwogICAgfQogICAgbGwgbWlkPShsZWZ0K3JpZ2h0KS8yOwogICAgbGwgeD1xdWVyeSgyKmluZCxsZWZ0LG1pZCxpLGopOwogICAgbGwgeT1xdWVyeSgyKmluZCsxLG1pZCsxLHJpZ2h0LGksaik7CiAgICByZXR1cm4geCt5Owp9CmludCBtYWluKCkKewogICAgbGwgaSxqLG4scSxsLHIsdHlwZTsKICAgIHNjYW5mKCIlZCIsJm4pOwogICAgZm9yKGk9MDsgaTxuOyBpKyspCiAgICAgICAgc2NhbmYoIiVkIiwmYXJyW2ldKTsKICAgIGJ1aWxkKDEsMCxuLTEpOwogICAgIHNjYW5mKCIlZCIsJnEpOwogICAgZm9yKGk9MDsgaTxxOyBpKyspCiAgICB7CiAgICAgICBzY2FuZigiJWQiLCZ0eXBlKTsKICAgICAgICBpZih0eXBlPT0wKQogICAgICAgIHsKICAgICAgICAgICAgc2NhbmYoIiVkJWQiLCZsLCZyKTsKICAgICAgICAgICAgbC0tOwogICAgICAgICAgICB1cGRhdGUoMSwwLG4tMSxsLHIsYXJyW2xdKTsKICAgICAgICB9CiAgICAgICAgZWxzZQogICAgICAgIHsKICAgICAgICAgICAgc2NhbmYoIiVkJWQlZCIsJmwsJnIsJmspOwogICAgICAgICAgICBsLS07CiAgICAgICAgICAgIHItLTsKICAgICAgICAgICAgcHJpbnRmKCIlZFxuIixxdWVyeSgxLDAsbi0xLGwscikpOwogICAgICAgIH0KICAgIH0KICAgIHJldHVybiAwOwp9CgoK