#include <bits/stdc++.h>
using std::abs;
using std::lower_bound;
using std::max;
using std::sort;
using std::swap;
using std::unique;
template <typename T>
inline void read(T& x) {
  x = 0;
  bool w = 1;
  char c = getchar();
  while (!isdigit(c)) {
    if (c == '-') w = 0;
    c = getchar();
  }
  while (isdigit(c)) {
    x = x * 10 + c - '0';
    c = getchar();
  }
  x = w ? x : -x;
}
const int N = 210, T = N * N, P = 998244353;
int n, m, tim[T], t;
void fix(int& x) { x < P ? 0 : x -= P; }
int qp(long long a, int b) {
  long long c = 1;
  for (; b; b >>= 1, a = a * a % P)
    if (b & 1) c = a * c % P;
  return c;
}
struct Fr {
  int x, y;
} pos[N];
struct F2 {
  int a, b, c;
  int f(int x) {
    int tmp = c;
    fix(tmp += 1ll * a * x % P * x % P);
    fix(tmp += 1ll * b * x % P);
    return tmp;
  }
};
namespace MatSum {
int tot, ans, B[N], len, Sum[N << 2], Tag[N << 2], Len[N << 2];
struct opt {
  int x, l, r, v;
} op[N];
bool cmp(opt a, opt b) { return a.x == b.x ? a.v < b.v : a.x < b.x; }
void pt(int p, int v) { Tag[p] += v; }
void up(int p) { Sum[p] = Tag[p] ? Len[p] : Sum[(p << 1)] + Sum[(p << 1 | 1)]; }
void build(int p, int l, int r) {
  Len[p] = B[r + 1] - B[l];
  Sum[p] = Tag[p] = 0;
  if (l == r) return;
  int mid = (l + r) >> 1;
  build((p << 1), l, mid), build((p << 1 | 1), mid + 1, r);
}
void change(int p, int l, int r, int L, int R, int v) {
  assert(L <= R && p);
  if (L <= l && r <= R) return pt(p, v), up(p);
  int mid = (l + r) >> 1;
  if (L <= mid) change((p << 1), l, mid, L, R, v);
  if (mid < R) change((p << 1 | 1), mid + 1, r, L, R, v);
  up(p);
}
int solve(int dt) {
  len = tot = ans = 0;
  for (int i = 1, l, r; i <= n; i++) {
    l = pos[i].y - dt, r = pos[i].y + dt + 1;
    B[++len] = l, B[++len] = r;
    op[++tot] = (opt){pos[i].x - dt, l, r, 1};
    op[++tot] = (opt){pos[i].x + dt + 1, l, r, -1};
  }
  sort(B + 1, B + 1 + len), len = unique(B + 1, B + 1 + len) - B - 1;
  B[len + 1] = B[len];
  build(1, 1, len);
  sort(op + 1, op + 1 + tot, cmp);
  for (int i = 1; i <= tot; i++) {
    if (i > 1) fix(ans += 1ll * Sum[1] * (op[i].x - op[i - 1].x) % P);
    op[i].l = lower_bound(B + 1, B + 1 + len, op[i].l) - B;
    op[i].r = lower_bound(B + 1, B + 1 + len, op[i].r) - B - 1;
    change(1, 1, len, op[i].l, op[i].r, op[i].v);
  }
  return ans;
}
}  // namespace MatSum
using MatSum::solve;
namespace Guass {
const int K = 4;
int a[K][K], b[K];
F2 work() {
  for (int i = 1; i <= 3; i++) {
    for (int j = i + 1; j <= 3 && !a[i][i]; j++)
      if (a[j][i]) swap(a[i], a[j]), swap(b[i], b[j]);
    int inv = qp(a[i][i], P - 2);
    for (int j = i + 1; j <= 3; j++) {
      int ret = 1ll * inv * a[j][i] % P;
      for (int k = i; k < K; k++) fix(a[j][k] += P - 1ll * ret * a[i][k] % P);
      fix(b[j] += P - 1ll * ret * b[i] % P);
    }
  }
  for (int i = 3; i; i--) {
    int inv = qp(a[i][i], P - 2);
    for (int j = i - 1; j; j--)
      fix(b[j] += P - 1ll * b[i] * inv % P * a[j][i] % P);
  }
  F2 tmp;
  tmp.a = 1ll * b[1] * qp(a[1][1], P - 2) % P;
  tmp.b = 1ll * b[2] * qp(a[2][2], P - 2) % P;
  tmp.c = 1ll * b[3] * qp(a[3][3], P - 2) % P;
  return tmp;
}
}  // namespace Guass
signed main() {
  read(n), read(m);
  if (!m) return puts("0"), 0;
  for (int i = 1; i <= n; i++) read(pos[i].x), read(pos[i].y);
  for (int i = 1; i <= n; i++)
    for (int j = i + 1; j <= n; j++)
      tim[++t] =
          (max(abs(pos[i].x - pos[j].x), abs(pos[i].y - pos[j].y)) + 1) / 2;
  tim[++t] = 0;
  tim[++t] = m;
  sort(tim + 1, tim + 1 + t), t = unique(tim + 1, tim + 1 + t) - tim - 1;
  int ans = 1ll * solve(m) * m % P;
  for (int i = 1; tim[i] < m; i++) {
    if (tim[i + 1] - tim[i] > 3) {
      for (int o = 1, j = tim[i]; o <= 3; o++, j++) {
        Guass::a[o][1] = 1ll * j * j % P;
        Guass::a[o][2] = j;
        Guass::a[o][3] = 1;
        Guass::b[o] = solve(j);
      }
      F2 Now = Guass::work();
      for (int j = tim[i]; j < tim[i + 1]; j++) fix(ans += P - Now.f(j));
    } else {
      for (int j = tim[i]; j < tim[i + 1]; j++) fix(ans += P - solve(j));
    }
  }
  std::cout << ans << '\n';
  return 0;
}
