/*
ID: ashish1610
PROG:
LANG: C++
*/
#include <message.h>
#include "crates.h"
#include <bits/stdc++.h>
using namespace std;
#define ll              long long int
#define MOD             1000000007
#define si(a)           scanf("%d", &a)
#define sl(a)           scanf("%lld", &a)
#define pi(a)           printf("%d", a)
#define pl(a)           printf("%lld", a)
#define pn              printf("\n")
ll pow_mod(ll a, ll b) {
    ll res = 1;
    while(b) {
        if(b & 1)
            res = (res * a) % MOD;
        a = (a * a) % MOD;
        b >>= 1;
    }
    return res;
}
int main() {
    ll N = GetNumStacks();

    ll nodeId = MyNodeId();
    ll nodes = NumberOfNodes();

    ll l = (nodeId * N) / nodes;
    ll r = ((nodeId + 1) * N) / nodes;

    ll sm = 0;
    for(int i = l + 1; i <= r ;++i) {
        sm += GetStackHeight(i);
    }

    PutLL(0, sm);
    Send(0);

    if(nodeId == 0) {
        ll final_sm = 0;
        for(int i = 0; i < nodes; ++i) {
            Receive(i);
            final_sm += GetLL(i);
        }
        for(int i = 0; i < nodes; ++i) {
            PutLL(i, final_sm);
            Send(i);
        }
    }

    if(nodeId > 0) {
        Receive(0);
        ll tot_sm = GetLL(0);

        Receive(nodeId - 1);
        ll ext = GetLL(nodeId - 1);
        ll lft_cnt = GetLL(nodeId - 1);

        ll running_res = GetLL(nodeId - 1);

        vector < ll > v;
        for(int i = l + 1; i <= r; ++i) {
            v.push_back(GetStackHeight(i));
        }
        v.push_back(0);

        ll lft_sm = tot_sm / N;
        if(tot_sm % N) {
            lft_sm += 1;
        }

        ll rgt_sm = tot_sm / N;

        v[0] += ext;

        for(int i = 0; i < (int)(v.size() - 1); ++i) {
            if(lft_cnt > 0) {
                if(v[i] < lft_sm) {
                    running_res = (running_res + (lft_sm - v[i])) % MOD;
                    v[i + 1] -= (lft_sm - v[i]);
                    v[i] = lft_sm;
                } else if(v[i] > lft_sm) {
                    running_res = (running_res + (v[i] - lft_sm)) % MOD;
                    v[i + 1] += (v[i] - lft_sm);
                    v[i] = lft_sm;
                }
                lft_cnt -= 1;
            } else {
                if(v[i] < rgt_sm) {
                    running_res = (running_res + (rgt_sm - v[i])) % MOD;
                    v[i + 1] -= (rgt_sm - v[i]);
                    v[i] = rgt_sm;
                } else if(v[i] > rgt_sm) {
                    running_res = (running_res + (v[i] - rgt_sm)) % MOD;
                    v[i + 1] += (v[i] - rgt_sm);
                    v[i] = rgt_sm;
                }
            }
        }

        if(nodeId == nodes - 1) {
            cout << running_res << endl;
        } else {
            PutLL(nodeId + 1, v.back());
            PutLL(nodeId + 1, lft_cnt);
            PutLL(nodeId + 1, running_res);
            Send(nodeId + 1);
        }
    } else if(nodeId == 0) {
        Receive(0);
        ll tot = GetLL(0);
        vector < ll > v;
        for(int i = l + 1; i <= r; ++i) {
            v.push_back(GetStackHeight(i));
            // tot += GetStackHeight(i);
        }
        v.push_back(0);

        ll moves = 0;

        ll lft_cnt = tot % N;
        ll lft_sm = tot / N;
        if(tot % N) {
            lft_sm += 1;
        }

        ll rgt_cnt = N - lft_cnt;
        ll rgt_sm = tot / N;

        for(int i = 0; i < (int)(v.size() - 1); ++i) {
            if(lft_cnt > 0) {
                if(v[i] < lft_sm) {
                    moves = (moves + (lft_sm - v[i])) % MOD;
                    v[i + 1] -= (lft_sm - v[i]);
                    v[i] = lft_sm;
                } else if(v[i] > lft_sm) {
                    moves = (moves + (v[i] - lft_sm)) % MOD;
                    v[i + 1] += (v[i] - lft_sm);
                    v[i] = lft_sm;
                }
                lft_cnt -= 1;
            } else {
                if(v[i] < rgt_sm) {
                    moves = (moves + (rgt_sm - v[i])) % MOD;
                    v[i + 1] -= (rgt_sm - v[i]);
                    v[i] = rgt_sm;
                } else if(v[i] > rgt_sm) {
                    moves = (moves + (v[i] - rgt_sm)) % MOD;
                    v[i + 1] += (v[i] - rgt_sm);
                    v[i] = rgt_sm;
                }
            }
        }
        PutLL(nodeId + 1, v.back());
        PutLL(nodeId + 1, lft_cnt);
        PutLL(nodeId + 1, moves);
        Send(nodeId + 1);
    }
    return 0;
}