#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<ll,ll> PP;
// #define MOD 1000000007
#define MOD 998244353
#define INF 2305843009213693951
#define PI 3.141592653589
#define setdouble setprecision
#define REP(i,n) for(ll i=0;i<(n);++i)
#define OREP(i,n) for(ll i=1;i<=(n);++i)
#define RREP(i,n) for(ll i=(n)-1;i>=0;--i)
#define ORREP(i,n) for(ll i=(n);i>=1;--i)
#define rep(i,a,b) for(ll i=(a);i<=(b);++i)
#define ALL(v) (v).begin(), (v).end()
#define chmin(k,m) k = min(k,m)
#define chmax(k,m) k = max(k,m)
#define GOODBYE do { cout << "-1" << endl; return 0; } while (false)
#define MM <<" "<<
#define Endl endl

template<typename T,typename F>
class lazysegmenttree{
    /*
    Copyright (c) 2024 0214sh7
    https://github.com/0214sh7/library/
    */
    //private:
    public:
    int n,height;
    
    std::vector<T> dat;
    std::vector<F> lazy;
    std::vector<bool> lazy_flag;
    std::function<T(T,T)> calc;
    T identity;
    std::function<T(F,T)> action;
    std::function<F(F,F)> composition;
    F action_identity;
    
    void eval(int k){
        if(!lazy_flag[k])return;
        if(k<n-1){
            lazy[2*k+1] = composition(lazy[k],lazy[2*k+1]);
            lazy[2*k+2] = composition(lazy[k],lazy[2*k+2]);
            lazy_flag[2*k+1] = true;
            lazy_flag[2*k+2] = true;
        }
        dat[k] = action(lazy[k],dat[k]);
        lazy[k] = action_identity;
        lazy_flag[k] = false;
    }
    
    public:
    
    void init(int N,std::function<T(T,T)> func,T Identity,
    std::function<T(F,T)> Action,std::function<F(F,F)> Composition, F Action_identity){
        n=1;height=1;
        while(n<N){n*=2;height++;};
        dat.resize(2*n-1);
        lazy.resize(2*n-1);
        lazy_flag.resize(2*n-1);
        for(int i=0;i<2*n-1;++i){
            dat[i]=Identity;
            lazy[i]=Action_identity;
            lazy_flag[i]=false;
        }
        calc = func;
        identity = Identity;
        action = Action;
        composition = Composition;
        action_identity = Action_identity;
    }
    
    lazysegmenttree(int N,std::function<T(T,T)> func,T Identity,
    std::function<T(F,T)> Action,std::function<F(F,F)> Composition,F Action_identity){
        init(N,func,Identity,Action,Composition,Action_identity);
    }
    
    void set(std::vector<T> A){
        if(n<(int)A.size()){
            n=1;height=1;
            while(n<(int)A.size()){n*=2;height++;};
            dat.resize(2*n-1);
            lazy.resize(2*n-1);
            lazy_flag.resize(2*n-1);
        }
        for(int i=0;i<2*n-1;++i){
            dat[i]=identity;
            lazy[i]=action_identity;
            lazy_flag[i]=false;
        }
        for(unsigned i=0;i<A.size();i++){
            dat[n-1+i] = A[i];
        }
        for(int i=n-2;i>=0;i--){
            dat[i] = calc(dat[2*i+1],dat[2*i+2]);
        }
    }
    
    void update(int a,int b,F f){
        a+=n-1;
        b+=n-1;
        for(int i=height-1;i>=0;i--){
            if(((a+1)>>i)>0){
                eval(((a+1)>>i)-1);
            }
            if((b>>i)>0){
                eval((b>>i)-1);
            }
        }
        
        int l = a,r = b-1;
        while(a < b){
            if(a % 2 == 0){
                lazy[a] = composition(f,lazy[a]);
                lazy_flag[a] = true;
                a++;
            }
            a = (a-1)/2;
            
            if(b % 2 == 0){
                b--;
                lazy[b] = composition(f,lazy[b]);
                lazy_flag[b] = true;
            }
            b = (b-1)/2;
        }
        
        while(l>0){
            l = (l-1)/2;
            eval(2*l+1);eval(2*l+2);
            dat[l] = calc(dat[2*l+1],dat[2*l+2]);
        }
        while(r>0){
            r = (r-1)/2;
            eval(2*r+1);eval(2*r+2);
            dat[r] = calc(dat[2*r+1],dat[2*r+2]);
        }
        
    }
    
    T query(int a,int b){
        a+=n-1;
        b+=n-1;
        for(int i=height-1;i>=0;i--){
            if(((a+1)>>i)>0){
                eval(((a+1)>>i)-1);
            }
            if((b>>i)>0){
                eval((b>>i)-1);
            }
        }
        
        T L= identity,R = identity;
        while(a < b){
            if(a % 2 == 0){
                eval(a);
                L = calc(L,dat[a]);
                a++;
            }
            a = (a-1)/2;
            if(b % 2 == 0){
                b--;
                eval(b);
                R = calc(dat[b],R);
            }
            b = (b-1)/2;
        }
        R = calc(L,R);
        return R;
    }
    
};


int main(void){
    //cin.tie(nullptr);
    //ios::sync_with_stdio(false);

    ll N,Q;
    cin >> N >> Q;

    std::function<long long(long long,long long)> func = [](long long a,long long b){
        return std::min(a,b);
    };
    
    std::function<long long(ll,long long)> action = [](ll f,long long x){
        return min(x,f);
    };
    
    std::function<ll(ll,ll)>
    composition = [](ll f,ll g){
        return min(f,g);
    };

    lazysegmenttree<long long,ll> SEGL(N,func,INF,action,composition,INF);
    lazysegmenttree<long long,ll> SEGR(N,func,INF,action,composition,INF);
    
    SEGL.set(vector<ll>(N,0));
    
    vector<ll> d(N);REP(i,N){d[i]=i-(N-1-i);}
    SEGR.set(d);

    REP(_,Q){

        ll t;
        cin >> t;
        if(t==1){
            ll x;
            cin >> x;
            x--;

            ll a = min(SEGL.query(x,x+1)+x, SEGR.query(x,x+1)+(N-1-x));
            cout << a << endl;

        }else{
            ll x,c;
            cin >> x >> c;
            x--;

            SEGL.update(x,N,c-x);
            SEGR.update(0,x+1,c-(N-1-x));
        }

        // REP(i,N){cout << SEGL.query(i,i+1)+i << " ";}cout << endl;
        // REP(i,N){cout << SEGR.query(i,i+1)+(N-1-i) << " ";}cout << endl;
        // cout << endl;

    }

    return 0;
    
}