#pragma GCC optimize("Ofast")
#include <iostream>
#include <vector>
#include <algorithm>
#include <map>
#include <queue>
#include <cstdio>
#include <ctime>
#include <assert.h>
#include <chrono>
#include <random>
#include <numeric>
#include <set>
#include <deque>
#include <stack>
#include <sstream>
#include <utility>
#include <cstring>
#include <unordered_map>
#include <unordered_set>
#include <tuple>
#include <array>
#include <bitset>
using namespace std;
typedef long long int ll;
typedef unsigned long long ull;

mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
ll myRand(ll B) {
    return (ull)rng() % B;
}
inline ll time() {
    return static_cast<long double>(chrono::duration_cast<chrono::nanoseconds>(chrono::steady_clock::now().time_since_epoch()).count()) * 1e-9;
}

// 区間加算+1点取得
// 0-indexed
template<typename T>
struct BIT{
    int n;
    vector<T> bit;
    BIT(int n_=0):n(n_),bit(n+1){}
    T get(int i){
        T res=0;
        i++;
        while(i<bit.size()){
            res+=bit[i];
            i+=(i&-i);
        }
        return res;
    }
    void add(int i,T a){
        i++;
        while(i){
            bit[i]+=a;
            i-=(i&-i);
        }
    }
    // 区間[l,r]にaを足す
    void add(int l,int r,T a){
        add(r,a);
        add(l-1,-a);
    }
};

// 1-indexed
template<typename T>
struct BIT2{
    int n;
    vector<T> bit;
    BIT2(int n_=0):n(n_),bit(n+1){}
    T sum(int i){
        T res=0;
        for(;i>0;i-=(i&-i))res+=bit[i];
        return res;
    }
    void add(int i,T a){
        if(i==0)return;
        for(;i<=n;i+=(i&-i)){bit[i]+=a;}
    }
    int lower_bound(T k){ // k<=sum(res)
        if(k<=0)return 0;
        int res=0,i=1;
        while((i<<1)<=n)i<<=1;
        for(;i;i>>=1){
            if(res+i<=n&&bit[res+i]<k)k-=bit[res+=i];
        }
        return res+1;
    }
};

int main(){
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    int n,q; cin >> n >> q;
    vector<int> a(q),b(q);
    for(int i=0;i<q;i++){
        cin >> a[i] >> b[i];
        a[i]--;
    }
    for(int i=0;i<n;i++){
        a.push_back(i);
        b.push_back(0);
        q++;
    }
    vector<ll> point(n);
    vector<ll> p={0};
    vector<ll> res(n);
    {
        vector<ll> po(n);
        for(int i=0;i<q;i++){
            po[a[i]] += b[i];
            p.push_back(po[a[i]]);
        }
        sort(p.begin(), p.end());
        p.erase(unique(p.begin(), p.end()), p.end());
    }
    auto get_point_index=[&](ll po)->int{
        return lower_bound(p.begin(), p.end(), po) - p.begin();
    };

    vector<ll> memo(n);
    int m = p.size();
    BIT<ll> bit(m);
    BIT2<ll> bit2(m);
    int idx = get_point_index(0);
    bit2.add(idx+1, n);
    vector<int> po_idx(n, idx);

    for(int i=0;i<q;i++){
        int cur = po_idx[a[i]];
        // cout << point[0] << " " << point[1] << " " << point[2] << " " << a[i] << "'s pre: ";
        point[a[i]] += b[i];
        int nxt = get_point_index(point[a[i]]);
        int pre_standing = n - bit2.sum(cur+1);
        // cout << pre_standing << endl;
        bit2.add(cur+1, -1);
        bit2.add(nxt+1, 1);
        // cout << point[0] << " " << point[1] << " " << point[2] << " " << a[i] << "'s nxt: ";
        int nxt_standing = n - bit2.sum(nxt+1);
        // cout << nxt_standing << endl;
        res[a[i]] += abs(nxt_standing - pre_standing);
        res[a[i]] += bit.get(cur) - memo[a[i]];
        if(cur < nxt){
            bit.add(cur, nxt-1, 1);
        }
        else if(nxt < cur){
            bit.add(nxt, cur-1, 1);
        }
        memo[a[i]] = bit.get(nxt);
        po_idx[a[i]] = nxt;
    }

    for(int i=0;i<n;i++){
        cout << res[i] << "\n";
    }
}