#include "bits/extc++.h"

using namespace std;

template <typename T>
void dbgh(const T& t) {
    cerr << t << endl;
}

template <typename T, typename... U>
void dbgh(const T& t, const U&... u) {
    cerr << t << " | ";
    dbgh(u...);
}

#ifdef DEBUG
#define dbg(...)                                           \
    cerr << "L" << __LINE__ << " [" << #__VA_ARGS__ << "]" \
         << ": ";                                          \
    dbgh(__VA_ARGS__)
#else
#define cerr   \
    if (false) \
    cerr
#define dbg(...)
#endif

using ld = long double;

#define endl "\n"
#define long int64_t
#define sz(x) int(std::size(x))

constexpr int DIRS[4][2] {{0, -1}, {0, 1}, {-1, 0}, {1, 0}};

long sq(long x) {
    return x * x;
}

struct DS1 {
    vector<int> v;

    DS1(int n) : v(n + 1) {}

    void update(int l, int r, int x) {
        v[l] += x;
        v[r + 1] -= x;
    }

    vector<int> query() const {
        vector<int> ans(sz(v));
        partial_sum(begin(v), end(v), ans.begin());
        ans.pop_back();
        return ans;
    }
};

template <typename T>
T reversed(T t) {
    reverse(begin(t), end(t));
    return t;
}

vector<vector<bool>> solve(const vector<vector<bool>>& arr, int r) {
    int n = sz(arr), m = sz(arr[0]), cols[m];
    memset(cols, -1, sizeof(cols));
    vector<vector<bool>> ans(n, vector<bool>(m));
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (arr[i][j]) {
                cols[j] = i;
            }
        }
        DS1 ds(m);
        for (int j = 0; j < m; j++) {
            int y = cols[j];
            if (y == -1) {
                continue;
            }
            long s = r - sq(y - i);
            if (s < 0) {
                continue;
            }
            ld ql = j - sqrtl(s), qr = j + sqrtl(s);
            int cl = int(floor(ql) + 1), cr = int(ceil(qr) - 1);
            cl = max(0, cl);
            cr = min(m - 1, cr);
            if (cl <= cr) {
                ds.update(cl, cr, 1);
            }
        }
        auto cans = ds.query();
        for (int j = 0; j < m; j++) {
            ans[i][j] = !!cans[j];
        }
    }
    return ans;
}

void solve() {
    int n, m, r, sx, sy, kv;
    cin >> n >> m >> r >> sx >> sy >> kv;
    auto ibs = [&](int x, int y) -> bool {
        return 0 <= x && x <= n + 1 && 0 <= y && y <= m + 1;
    };
    vector<vector<bool>> iarr(n + 2, vector<bool>(m + 2));
    for (int i = 0; i < kv; i++) {
        int x, y;
        cin >> x >> y;
        iarr[x][y] = true;
    }
    auto arr1 = solve(iarr, r), arr2 = reversed(solve(reversed(iarr), r));
    vector<vector<bool>> arr(n + 2, vector<bool>(m + 2, true));
    for (int i = 0; i <= n + 1; i++) {
        for (int j = 0; j <= m + 1; j++) {
            bool cans = true;
            cans &= !arr1[i][j];
            cans &= !arr2[i][j];
            cans &= sq(i) >= r && sq(n + 1 - i) >= r && sq(j) >= r && sq(m + 1 - j) >= r;
            arr[i][j] = cans;
        }
    }
    if (!arr[sx][sy]) {
        cout << 0 << endl;
        return;
    }
    vector<vector<bool>> vis(n + 2, vector<bool>(m + 2));
    vector<pair<int, int>> q;
    auto push = [&](int x, int y) -> void {
        if (vis[x][y]) {
            return;
        }
        vis[x][y] = true;
        q.emplace_back(x, y);
    };
    push(sx, sy);
    while (sz(q)) {
        auto [x, y] = q.back();
        q.pop_back();
        for (auto& [dx, dy] : DIRS) {
            int cx = x + dx, cy = y + dy;
            if (ibs(cx, cy) && arr[cx][cy]) {
                push(cx, cy);
            }
        }
    }
    int ans = 0;
    for (auto& a : vis) {
        for (auto&& b : a) {
            ans += b;
        }
    }
    cout << ans << endl;
}

int main() {
    cin.tie(nullptr);
    cin.exceptions(ios::failbit);
    ios_base::sync_with_stdio(false);
    solve();
}