#include <cstdio>
#include <cstring>

#define lson l, mid, rt << 1
#define rson mid + 1, r, rt << 1 | 1
using namespace std;

const int MAXN = 1e5 + 5;
const int SIZE = 2e5 + 5;

int Sum[MAXN * 3], Col[MAXN * 3];
int a[MAXN];
int n, m, k;
struct o {
    int l, r;
} O[MAXN];

void push_up(int rt) {
    Sum[rt] = Sum[rt << 1] + Sum[rt << 1 | 1];
}

void push_down(int rt, int m) {
    if(Col[rt] != -1) {
        Col[rt << 1] = Col[rt << 1 | 1] = Col[rt];
        Sum[rt << 1] = (m - (m >
 
> 1)) * Col[rt];
        Sum[rt << 1 | 1] = (m >> 1) * Col[rt];
        Col[rt] = -1;
    }
}

void build(int lowv, int l, int r, int rt) {
    Col[rt] = -1;
    Sum[rt] = 0;
    if(l == r) {
        Sum[rt] = a[l] > lowv;
        return;
    }
    int mid = (l + r) >> 1;
    build(lowv, lson);
    build(lowv, rson);
    push_up(rt);
}

void
 
 update(int L, int R, int v, int l, int r, int rt) {
    if(L > R) return;
    if(L <= l && r <= R) {
        Sum[rt] = (r - l + 1) * v;
        Col[rt] = v;
        return ;
    }
    push_down(rt, r - l + 1);
    int mid = (l + r) >> 1;
    if(L <= mid) update(L, R, v, lson);
    if
 
(R > mid) update(L, R, v, rson);
    push_up(rt);
}

int query(int L, int R, int l, int r, int rt) {
    if(L <= l && r <= R) {
        return Sum[rt];
    }
    int mid = (l + r) >> 1;
    push_down(rt, r - l + 1);
    int ret = 0;
    if(L <= mid) ret += query(L, R, lson);
    if(R > mid) ret += query(L, R, rson);
    return ret;
}

bool C(int mid, int len) {
    build(mid, 1, n, 1);
    for(int i = 0; i < len; i ++) {
        int s1 = query(O[i].l, O[i].r, 1, n, 1);
        int s0 = O[i].r - O[i].l + 1 - s1;
        int cz = (s1 & 1) == 1;
        int qlk = s1 / 2;
        update(O[i].l, O[i].l + qlk - 1 + cz, 1, 1, n, 1);
        update(O[i].l + qlk + cz, O[i].r - qlk, 0, 1, n, 1);
        update(O[i].r - qlk + 1, O[i].r, 1, 1, n, 1);
    }
    return query(k, k, 1, n, 1) == 0;
}

int main() {
    while(~scanf("%d%d%d", &n, &m, &k)) {
        for(int i = 1; i <= n; i ++) {
            scanf("%d", &a[i]);
        }
        int op, len = 0, zl;
        for(int i = 1; i <= m; i ++) {
            scanf("%d", &op);
            if(op == 1) {
                scanf("%d%d", &O[len].l, &O[len].r);
                len ++;
            } else {
                scanf("%d", &zl);
                len -= zl;
                len = len < 0 ? 0 : len;
            }
        }
        //printf("[%d]\n", len);
        int lb = 0, ub = SIZE;
        while(ub - lb > 1) {
            int mid = (ub + lb) >> 1;
            if(C(mid, len)) ub = mid;
            else lb = mid;
        }
        printf("%d\n", ub);
    }
    return 0;
}

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<iostream>
#include<sstream>
#include<vector>
#include<cmath>
#define LL long long
#define md int mid = (L+R)>>1
#define ls rt<<1
#define rs rt<<1|1
using namespace std;
const int maxn = 2e5+50000;
int id[maxn<<2],mx[maxn<<2];
int n;
int ans[maxn];
int lazy[maxn<<2];
void push_up(int rt)
{
    if(mx[ls]>=mx[rs])
        id[rt] = id[ls];
    else
        id[rt] = id[rs];
    mx[rt] = max(mx[ls],mx[rs]);
}
void push_down(int rt)
{
    if(lazy[rt])
    {
        lazy[ls] += lazy[rt];
        lazy[rs] += lazy[rt];
        mx[ls] += lazy[rt];
        mx[rs] += lazy[rt];
        lazy[rt] = 0;
    }
}
void build(int L,int R,int rt)
{
    if(L==R)
    {
        id[rt] = L;
        mx[rt] = -L;
        return ;
    }
    md;
    build(L,mid,ls);
    build(mid+1,R,rs);
    push_up(rt);
}
void update(int l,int r,int L,int R,int rt)
{
   // cout<<"diap"<<endl;
    if(l<=L&&R<=r)
    {
        lazy[rt]++;
        mx[rt]++;
        return ;
    }
    push_down(rt);
    md;
    if(l<=mid)
        update(l,r,L,mid,ls);
    if(r>mid)
        update(l,r,mid+1,R,rs);
    push_up(rt);
}
void change(int p,int L,int R,int rt)
{
    if(L==R)
    {
        mx[rt] = -0x3f3f3f3f;
       // id[rt] = L;
        return ;
    }
    md;
    push_down(rt);
    if(mid>=p)
        change(p,L,mid,ls);
    else
        change(p,mid+1,R,rs);
    push_up(rt);

}
int main()
{
    while(~scanf("%d",&n))
    {
        memset(ans,-1,sizeof(ans));
        build(1,n,1);
        memset(lazy,0,sizeof(lazy));
        for(int i = 0 ;i < n;i++)
        {
            int op,x;
            scanf("%d%d",&op,&x);
            if(!op)
            {
                //cout<<"fuck"<<endl;
                update(1,x,1,n,1);
            //cout<<"gan"<<endl;
            }
            else
                update(x,n,1,n,1);
            if(mx[1]<0)
                continue;
            while(!mx[1])
            {
                ans[id[1]] = i+1;
                change(id[1],1,n,1);
            }
        }
        for(int i = 1;i <= n;i++ )
            printf("%d%c",ans[i],i==n?'\n':' ');
    }
    return 0;
}

#include <queue>
#include <stack>
#include <ctime>
#include <cmath>
#include <cctype>
#include <cstdio>
#include <string>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <algorithm>

using namespace std;

typedef long long LL;
typedef long double LB;
typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;
typedef vector<int> VI;

const int INF = 0x3f3f3f3f;
const LL INFL = 0x3f3f3f3f3f3f3f3fLL;

void debug() { cout << endl; }
template<typename T, typename ...R> void debug (T f, R ...r) { cout << "[" << f << "]"; debug (r...); }


const int MAXN = 1e5 + 5;
const int MAXM = 20;

int n, m;
struct Edge {
    int v, next;
} edge[MAXN << 1];
int head[MAXN], tot;
int dep[MAXN], siz[MAXN], fa[MAXN][MAXM];
LL all[MAXN], sum[MAXN];
int root;

void init_edge() {
    tot = 0;
    memset(head, -1, sizeof(head));
}
inline void add_edge(int u, int v) {
    edge[tot] = Edge {v, head[u]};
    head[u] = tot ++;
}
void dfs(int u, int pre, int d) {
    int v;
    siz[u] = 1;
    dep[u] = d;
    sum[u] = 0;
    fa[u][0] = pre;
    for(int i = head[u]; ~i; i = edge[i].next) {
        v = edge[i].v;
        if(v == pre) continue;
        dfs(v, u, d + 1);
        siz[u] += siz[v];
        sum[u] += sum[v];
        sum[u] += siz[v];
    }
}

void dfs2(int u, int pre) {
    int v;
    for(int i = head[u]; ~i; i = edge[i].next) {
        v = edge[i].v;
        if(v == pre) continue;
        all[v] = all[u] + (n - 1 - siz[v]) - (siz[v] - 1);
        dfs2(v, u);
    }
}

void lca_init() {
    for(int j = 1; j < MAXM; ++j) {
        for(int i = 1; i <= n; ++i) {
            fa[i][j] = fa[fa[i][j - 1]][j - 1];
        }
    }
}

int lca(int u, int v) {
    while(dep[u] != dep[v]) {
        if(dep[u] < dep[v]) swap(u, v);
        int d = dep[u] - dep[v];
        for(int i = 0; i < MAXM; i++) {
            if(d >> i & 1) u = fa[u][i];
        }
    }
    if(u == v) return u;
    for(int i = MAXM - 1; i >= 0; i--) {
        if(fa[u][i] != fa[v][i]) {
            u = fa[u][i];
            v = fa[v][i];
        }
    }
    return fa[u][0];
}

int son(int u, int v) {
    while(dep[v] > dep[u] + 1) {
        int w = v;
        for(int j = 0; j < MAXM; ++j) {
            if(dep[fa[v][j]] < dep[u] + 1) break;
            w = fa[v][j];
        }
        v = w;
    }
    return v;
}

int main() {
    int u, v, w;
    while(~scanf("%d %d", &n, &m)) {
        init_edge();
        for(int i = 1; i <= n - 1; ++i) {
            scanf("%d %d", &u, &v);
            add_edge(u, v);
            add_edge(v, u);
        }

        dfs(root = 1, 0, 0);
        all[root] = sum[root];
        dfs2(root, 0);

        lca_init();
        while(m --) {
            scanf("%d %d", &u, &v);
            if(dep[u] > dep[v]) swap(u, v);
            w = lca(u, v);
            int dist, sizu, sizv;
            LL sumu, sumv;
            double ans;
            if(w != u) {
                /** 有lca **/
                dist = dep[u] + dep[v] - 2 * dep[w];
                sizu = siz[u];
                sumu = sum[u];
                sizv = siz[v];
                sumv = sum[v];
            } else {
                /**一條鏈**/
                dist = dep[v] - dep[u];
                w = son(u, v);
                sizu = n - siz[w];
                sumu = all[u] - sum[w] - siz[w];
                sizv = siz[v];
                sumv = sum[v];
            }
            ans = 1.0 + dist + 1.0 * ((LL)sizu * sumv + (LL)sizv * sumu) / ((LL)sizu * sizv);
            printf("%.8f\n", ans);
        }
    }
    return 0;
}

#include <iostream>
#include <cstdio>
#include <cmath>
using namespace std;
const int maxn=105;
struct Matrix{
    int n;
    double m[maxn][maxn];

    void init(int sz){
        n=sz;
        for(int i=0;i<n;i++)
            for(int j=0;j<n;j++)
                m[i][j]=0;
    }
    Matrix(int sz){init(sz);}
    void set_I(){
        for(int i=0;i<n;i++) m[i][i]=1.0;
    }
    Matrix operator* (const Matrix& a){
        Matrix ans(n);
        for(int k=0;k<n;k++)
        for(int i=0;i<n;i++)
        for(int j=0;j<n;j++){
            ans.m[i][j]+=m[i][k]*a.m[k][j];
        }
        return ans;
    }
};
int main(){
    double p,q;
    int n,m;
    while(scanf("%lf%lf%d%d",&p,&q,&n,&m)!=EOF){
        Matrix base(n),ans(n);
        for(int i=0;i<n;i++) base.m[i][0]=p*pow(q,i);
        for(int i=0;i<n-1;i++) base.m[i][i+1]=1.0;

        ans.m[0][0]=1-pow(q,n);
        for(int i=1;i<n;i++) ans.m[0][i]=1;

        m=m-n;
        while(m){
            if(m&1) ans=ans*base;
            m>>=1;
            base=base*base;
        }
        printf("%.6lf\n",1-ans.m[0][0]);
    }

}