#define _USE_MATH_DEFINES
#include <cstdio>
#include <iostream>
#include <sstream>
#include <fstream>
#include <iomanip>
#include <algorithm>
#include <cmath>
#include <complex>
#include <string>
#include <vector>
#include <list>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <bitset>
#include <numeric>
#include <limits>
#include <climits>
#include <cfloat>
#include <functional>
#include <iterator>
using namespace std;

template <class T>
class cumulativeSum
{
private:
    int ny, nx;
    vector<vector<T> > sum;
public:
    cumulativeSum(){}
    cumulativeSum(const vector<vector<T> >& a)
    {
        ny = a.size();
        nx = a[0].size();
        sum.assign(ny+1, vector<T>(nx+1, 0));
        for(int i=0; i<ny; ++i){
            for(int j=0; j<nx; ++j){
                sum[i+1][j+1] = a[i][j] + sum[i][j+1] + sum[i+1][j] - sum[i][j];
            }
        }
    }
    T getSum(int y1, int x1, int y2, int x2)
    {
        y1 = max(y1, 0);
        x1 = max(x1, 0);
        y2 = min(y2, ny-1);
        x2 = min(x2, nx-1);
        if(y1 > y2 || x1 > x2)
            return 0;
        return sum[y2+1][x2+1] - sum[y1][x2+1] - sum[y2+1][x1] + sum[y1][x1];
    }
};

class TriangleSum
{
private:
    int n;
    cumulativeSum<long long> cs1, cs2;
public:
    TriangleSum(const vector<vector<long long> >& v){
        n = v.size();
        vector<vector<long long> > a(n, vector<long long>(n, 0));
        vector<vector<long long> > b(n, vector<long long>(n, 0));
        for(int i=0; i<n; ++i){
            for(int j=0; j<=i; ++j){
                a[i][j] = v[i][j];
                b[i][n-1-i+j] = v[i][j];
            }
        }
        cs1 = cumulativeSum<long long>(a);
        a.clear();
        cs2 = cumulativeSum<long long>(b);
    }
    long long getSum(int y, int x, int size){
        long long ans = cs1.getSum(y, x, y+size-1, n-1);
        ans -= cs2.getSum(y, n-y+x, y+size-1, n-1);
        return ans;
    }
};

void bfs(int n, const vector<int>& by, const vector<int>& bx, vector<vector<long long> >& dist)
{
    static const int dy[] = {-1, -1, 0, 0, 1, 1};
    static const int dx[] = {-1, 0, -1, 1, 0, 1};

    dist.resize(n);
    for(int i=0; i<n; ++i)
        dist[i].assign(i+1, -1);

    int k = by.size();
    queue<pair<int, int> > q;
    for(int i=0; i<k; ++i){
        dist[by[i]][bx[i]] = 0;
        q.push(make_pair(by[i], bx[i]));
    }

    while(!q.empty()){
        int y, x;
        tie(y, x) = q.front();
        q.pop();
        for(int i=0; i<6; ++i){
            int y2 = y + dy[i];
            int x2 = x + dx[i];
            if(0 <= y2 && y2 < n && 0 <= x2 && x2 <= y2 && dist[y2][x2] == -1){
                dist[y2][x2] = dist[y][x] + 1;
                q.push(make_pair(y2, x2));
            }
        }
    }
}

int main()
{
    int n, k, p;
    cin >> n >> k >> p;

    vector<int> by(k), bx(k);
    for(int i=0; i<k; ++i){
        cin >> by[i] >> bx[i];
        -- by[i];
        -- bx[i];
    }

    vector<vector<long long> > dist;
    bfs(n, by, bx, dist);

    TriangleSum ts(dist);
    long long ans = 0;
    for(int y=0; y<n; ++y){
        for(int x=0; x<=y; ++x){
            int left = 1;
            int right = n - y + 1;
            while(left < right){
                int mid = (left + right) / 2;
                if(ts.getSum(y, x, mid) < p)
                    left = mid + 1;
                else
                    right = mid;
            }
            ans += (n - y + 1) - left;
        }
    }
    cout << ans << endl;

    return 0;
}