#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#ifdef APURBA
#include "DEBUG_TEMPLATE.h"
#else
#define HERE
#define debug(args...)
#endif
#define ALL(x) x.begin(),x.end()

typedef pair<int,int> pii;

struct FenwickTree {
    vector<int> bit;  // binary indexed tree
    int n;
    ll sm=0;
    void init(int n) {
        this->n = n;
        bit.assign(n, 0);
    }
    int sum(int r) {
        int ret = 0;
        for (; r >= 0; r = (r & (r + 1)) - 1)
            ret += bit[r];
        return ret;
    }

    int sum(int l, int r) {
        return sum(r) - sum(l - 1);
    }

    void add(int idx, int delta) {
        sm+=delta;
        for (; idx < n; idx = idx | (idx + 1))
            bit[idx] += delta;
    }
};

const int N=2e5+5;

ll lazy[N<<2];

void prop(int u,int ss,int se)
{
    if(ss!=se)
    {
        lazy[u<<1]+=lazy[u],
        lazy[u<<1|1]+=lazy[u];

        lazy[u]=0;
    }

}

ll gt(int u,int ss,int se,int idx)
{
    prop(u,ss,se);
    if(idx<ss or se < idx) return 0;
    if(ss==se)
    {
        ll x = lazy[u];
        lazy[u]=0;
        return x;
    }
    int mid = (ss+se)/2;
    return gt(u<<1,ss,mid,idx)+gt(u<<1|1,mid+1,se,idx);
}

void upd(int u,int ss,int se,int qs,int qe)
{
    prop(u,ss,se);
    if(qe < ss or se < qs) return ;
    if(qs <= ss and se <= qe)
    {
        lazy[u]++;
        return ;
    }
    int mid = (ss+se)/2;
    upd(u<<1,ss,mid,qs,qe);
    upd(u<<1|1,mid+1,se,qs,qe);
}


ll p[N];
vector<pii> ord;
vector<ll> vs;

FenwickTree ft;

int posi(int i)
{
    int ii = lower_bound(ALL(vs), p[i])-vs.begin();
    return ii;
}

int poss(int i)
{
    int ii = posi(i);
    auto jj = lower_bound(ALL(ord), make_pair(ii,i))-ord.begin();
    return jj+1;
}

ll ans[N];

ll calc(int pi)
{
    auto j = lower_bound(ALL(ord), make_pair(pi, N)) - ord.begin();

    return ft.sm - ft.sum(j);
}


void TEST_CASES()
{
    int n,q;
    cin>>n>>q;
    vector<pii> qs(q);
    vs.push_back(0);


    for(auto &[a,pp]: qs)
    {
        cin>>a>>pp;
        p[a]+=pp;
        vs.push_back(p[a]);
    }
    sort(ALL(vs));
    vs.erase(unique(ALL(vs)),vs.end());

    memset(p,0,sizeof p);

    for(int a=1;a<=n;a++)
    {
        int x  = lower_bound(ALL(vs), p[a]) - vs.begin();
        ord.push_back({x,a});
    }
    for(auto [a,pp]: qs)
    {
        p[a]+=pp;
        int x  = lower_bound(ALL(vs), p[a]) - vs.begin();
        ord.push_back({x,a});
    }

    sort(ALL(ord));
    ord.erase(unique(ALL(ord)), ord.end());

    ft.init(ord.size()+5);

    memset(p,0,sizeof p);
    for(int i=1;i<=n;i++)
    {
        ft.add(poss(i),1);
    }

    debug(vs);
    debug(ord);

    for(auto [a,pp]: qs)
    {
        int x = posi(a);
        int xx = poss(a);
        int old = calc(x);
        ft.add(xx,-1);

        ans[a]+=gt(1,1,ord.size(),xx);

        p[a]+=pp;

        int y = posi(a);
        int yy = poss(a);
        int now = calc(y);
        ft.add(yy,1);
        debug(a,old,now);
        debug(a,x,xx,y,yy);
        ans[a]+=abs(now-old);

        if(x==y) continue;

        int l = min(x,y);
        int r = max(x,y);
        l = lower_bound(ALL(ord), make_pair(l,-1))-ord.begin();
        r = lower_bound(ALL(ord), make_pair(r,-1))-ord.begin() - 1;

        debug(a,x,y,l,r);
        assert(l<=r);
        debug(l+1,r+1);
        upd(1,1,ord.size(),l+1,r+1);
        gt(1,1,ord.size(),yy);
        gt(1,1,ord.size(),xx);



//        for(int i=1;i<=ord.size();i++)
//        {
//            cerr<<ft.sum(i,i)<<" ";
//        }
//        cerr<<endl;
    }
    for(int i=1;i<=n;i++)
    {
        int ii = poss(i);
        ans[i]+=gt(1,1,ord.size(),ii);
    }
    for(int i=1;i<=n;i++)
        cout<<ans[i]<<"\n";

}


/*
*/

int32_t main()
{
#ifndef APURBA
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
#endif
    //freopen("input.txt","r",stdin);
    //freopen("out1.txt","w",stdout);
    int t=1;
    //cin>>t;
    while(t--)
    {
        TEST_CASES();
    }
    return 0;
}