#include <bits/stdc++.h>
 
using namespace std;
#include "dzialka.h"
#include "message.h"
 
#define FOR(i,a,n) for (decltype(n) i = (a), i ## __ = (n); i <= i ## __; ++i)
#define FORD(i,a,n) for (decltype(n) i = (a), i ## __ = (n); i >= i ## __; --i)
#define REP(i,n) FOR(i, 0, n - 1)
#define REPD(i, n) FORD(i, n - 1, 0)
#define ALL(x) x.begin(), x.end()
#define SZ(x) (int(x.size()))
#define EB emplace_back
#define V vector
#define ST first
#define ND second
#define RS resize
 
template<class T, class B> inline void mini(T &&a, B &&b) { if (b < a) a = b; }
template<class T, class B> inline void maxi(T &&a, B &&b) { if (b > a) a = b; }
int ceil2(int x) { return x < 2 ? 1 : 1 << (sizeof(x) * 8 - __builtin_clz(x - 1)); }
 
constexpr char nl = '\n';
template<class T> struct DumpOff { T a, b; };
template<class T> auto dumpOff(T &x) -> DumpOff<decltype(x.begin())> { return {x.begin(), x.end()}; }
template<class T> auto dumpOff(T &x) -> decltype(cerr << x, x) { return x; }
template<class T> auto dumpOff(T &x) -> decltype(x.first, x) { return x; }
struct Debug {
    Debug() { cerr << '[' << MyNodeId() << "] "; }
    ~Debug() { cerr << nl; }
    template<class T> auto operator<<(T x) -> decltype(cerr << x, *this) { cerr << dumpOff(x); return *this; }
    template<class T> auto operator<<(T x) -> decltype(x.begin(), *this) {
        cerr << "{\n";
        for (auto a = x.begin(), b = x.end(); a != b; ++a)
            *this << "  " << distance(x.begin(), a) << ": " << dumpOff(*a) << '\n';
        return *this << "}";
    }
    template<class T, class B> Debug& operator<<(pair<T, B> p) { return *this << "(" << dumpOff(p.first) << ", " << dumpOff(p.second) << ")"; }
    template<class T> Debug& operator<<(DumpOff<T> d) {
        cerr << "{";
        for (auto a = d.a, b = d.b; a != b; ++a)
            *this << dumpOff(*a) << (next(a) == b ? "" : ", ");
        return *this << "}";
    }
};
struct Foo {template<class T>Foo& operator<<(T) {return *this;}};
 
#ifdef DEBUG
# define D Debug()
#else
# define D Foo()
#endif
#define I(x...) #x ": " << x << "   "
 

typedef long long LL;
typedef pair<int, int> PII;
typedef V<int> VI;
typedef V<VI> VVI;
typedef V<PII> VPII;
typedef V<VPII> VVPII;
typedef V<bool> VB;
typedef V<VB> VVB;
typedef V<LL> VLL;
typedef V<VLL> VVLL;


struct Tree
{
    VI MIN, MAX;
    int size;
    Tree(int n)
    {
        size = ceil2(n);
        MAX.resize(2 * size, -1);
        MIN.resize(2 * size, 1000000000); 
    }

    void set(int id)
    {
        MIN[id + size] = id;
        MAX[id + size] = id;
        id += size;
        id /= 2;
        while(id != 0)
        {
            MIN[id] = min(MIN[id * 2], MIN[id * 2 + 1]);
            MAX[id] = max(MAX[id * 2], MAX[id * 2 + 1]);
            id /= 2;
        }
    }

    int left(int id)
    {
        id += size;
        int begin = size;        
        int ans = max(MAX[begin], MAX[id]);
        while(begin + 1 < id)
        {
            if(begin % 2 == 0) maxi(ans, MAX[begin + 1]);
            if(id % 2 == 1) maxi(ans, MAX[id - 1]);
            begin /= 2;
            id /= 2;
        }
        return ans;
    }

    int right(int id)
    {
        id += size;
        int end = 2 * size - 1;        
        int ans = min(MIN[id], MIN[end]);
        while(id + 1 < end)
        {  
            if(id % 2 == 0) mini(ans, MIN[id + 1]);
            if(end % 2 == 1) mini(ans, MIN[end - 1]);
            end /= 2;
            id /= 2;
        }
        return ans == 1000000000 ? -1 : ans;
    }
};

int mutual_part(int a, int b, int x)
{
    return (a + 1) * (x - b);
}

int main()
{
    int n = GetFieldHeight(), m = GetFieldWidth();
    int NON = NumberOfNodes();
    int ID = MyNodeId();
    if(NON > n) NON = n;
    if(ID >= NON)
        return 0;

    int k = n / (NON); // calculating part of the field to work on
    int r = n - (NON) * k;
    int a = k * (ID);
    int b = k * (ID + 1) - 1;
    if(ID < r) a += ID, b += ID + 1;
    else a += r, b += r;
    
    VI times(m, 0); // calculating times table
    FOR(i, a, b)
        REP(j, m)
            if(!IsUsableCell(i, j)) times[j] = i + 1;


    VI previous_times(m);
    if(ID != 0) // receieving times table
    {
        REP(i, (m / 10000) + 1)
        {
            Receive(ID - 1);
            for(int j = i * 10000; j < m && j < (i + 1) * 10000; j++)
                previous_times[j] = GetInt(ID - 1);
        }

        REP(i, m)
            maxi(times[i], previous_times[i]);
    } 

    if(ID != NON - 1) // sending times table
    {
        REP(i, (m / 10000) + 1)
        {
            for(int j = i * 10000; j < m && j < (i + 1) * 10000; j++)
                PutInt(ID + 1, times[j]);
            Send(ID + 1);
        }
    }

    //convert times to t
    VPII t(m);
    if(ID != 0)
        REP(i, m)
            t[i] = PII(previous_times[i], i);
    else
        REP(i, m)
            t[i] = PII(0, i);

    LL sum = 0;
    FOR(i, a, b)
    {
        REP(j, m) 
        {
            if(!IsUsableCell(i, j))
                t[j].ST = i + 1;
        }

        Tree tree(m);
        VPII to_sort = t;
        sort(to_sort.rbegin(), to_sort.rend());
        REP(j, m)
        {
            int id = to_sort[j].ND;

            int left = tree.left(id), right = tree.right(id);
            int amount_of_dudes = (id + 1) * (m - id);

            if(left != -1)
                amount_of_dudes -= mutual_part(left, id, m);
            if(right != -1)
                amount_of_dudes -= mutual_part(id, right, m);
            if(left != -1 && right != -1)
                amount_of_dudes += mutual_part(left, right, m);

            sum += LL(amount_of_dudes) * (i + 1 - to_sort[j].ST);
            tree.set(id);
        }
    }

    if(ID != 0)
    {
        PutLL(0, sum);
        Send(0);
    }
    else
    {
        FOR(i, 1, NON - 1)
        {
            Receive(i);
            sum += GetLL(i);
        }
        cout << sum << "\n";
    }
}