#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>

std::ifstream f("marbles.in");
std::ofstream g("marbles.out");

typedef std::pair<int,int>pi;

const int COLORS = 64;
const int NMAX = 100000;

int n,q,t,i,j,s[COLORS + 1][NMAX + 1],maxxColor;
std::pair<int,int>v[NMAX + 1];

inline int binary_search(int left,int right,int value){
    
    while(left <= right){
        
        int mid = (left + right) / 2;
        
        if(v[mid].first == value)
            return mid;
        
        if(v[mid].first < value)
            left = mid + 1;
        else
            right = mid - 1;
    }
    
    return -1;
}

inline int lower_bound(int left,int right,int value){
    
    int sol{ -1 };
    
    while(left <= right){
        
        int mid = (left + right) / 2;
        
        if(v[mid].first <= value){
            sol = mid;
            left = mid + 1;
        }else{
            right = mid - 1;
        }
        
    }
    
    return sol;
}

inline int upper_bound(int left,int right,int value){
    
    int sol{ -1 };
    
    while(left <= right){
        
        int mid = (left + right) / 2;
        
        if(v[mid].first < value){
            left = mid + 1;
        }else{
            sol = mid;
            right = mid - 1;
        }
    }
    
    return sol;
}

int main(){
    
    f >> n >> q;
    
    for(int i = 1;i <= n;++i){
        f >> v[i].first >> v[i].second;
        maxxColor = std::max(maxxColor,v[i].second);
    }
    
    std::sort(v + 1,v + n + 1,[](pi a,pi b){
        return a.first < b.first;
    });
    
    for(int j = 1;j <= COLORS;++j)
         for(int i = 1;i <= n;++i)
             s[j][i] = (v[i].second == j ? s[j][i - 1] + 1 : s[j][i - 1]);
    
    while(q--){
        
        f >> t >> i >> j;
        
        if(t == 0){
            
            int pos = binary_search(1,n,i);
            
            if(pos != -1)
                v[pos].first += j;
        
        }else{
            
            int lower = lower_bound(1,n,j);
            int upper = upper_bound(1,n,i);
            //lower >= upper
            
            int sol{};
            for(int color = 1;color <= COLORS;++color)
                sol = std::max(sol,s[color][lower] - s[color][upper - 1]);
            
            g << sol << '\n';
        }
    }
    
    return 0;
}