#include <bits/stdc++.h>
using namespace std;
void read_file(bool outToFile = true) {}
int n, first;
int maxU;
int A[(30000 + 1)];
map<pair<int, int>, int> dp;
int dir[3] = {-1, 0, 1};
int limit;
int suff[(30000 + 1)];
int memo[(30000 + 1)][555];
int find_lim(int u, int last) {
  if (u > maxU) return 0;
  if (last <= 2) return suff[u];
  return A[u] + find_lim(u + last - 1, last - 1);
}
void rec(int u, int last, int sumSoFar) {
  if (u >= 15001 && last >= u) {
    limit = max(limit, sumSoFar + A[u]);
    return;
  }
  if (sumSoFar + suff[u] <= limit) return;
  if (u > maxU) {
    limit = sumSoFar;
    return;
  }
  if (last <= 2) {
    limit = sumSoFar + suff[u];
    return;
  }
  if (dp.count(make_pair(u, last))) return;
  dp[make_pair(u, last)];
  for (int d = 0; d < 3; d++) {
    if (last + dir[d] > 0)
      rec(u + last + dir[d], last + dir[d], A[u] + sumSoFar);
  }
}
int DFS(int u, int last) {
  if (u >= maxU) return A[u];
  if (last <= 2) return suff[u];
  if (u + last - 1 >= maxU) {
    return A[u];
  }
  if (dp.count(make_pair(u, last))) return dp[make_pair(u, last)];
  int &ret = dp[make_pair(u, last)];
  ret = 0;
  if (last == 3) {
    return ret = A[u] + DFS(u + 2, 2);
  }
  if (last == 4) {
    int them = 0;
    if (u + 3 <= maxU) them += A[u + 3];
    if (u + 5 <= maxU) them += A[u + 5];
    if (u + 6 <= maxU) them += A[u + 6];
    if (u + 4 <= maxU && A[u + 4] > them) ret = DFS(u + 4, 4);
    ret = max(ret, DFS(u + 3, 3));
    ret += A[u];
    return ret;
  }
  if (last == 5) {
    return 0;
  }
  for (int d = 0; d < 3; d++) {
    ret = max(ret, DFS(u + last + dir[d], last + dir[d]));
  }
  ret += A[u];
  return ret;
}
int DFS1(int u, int last) {
  if (u > maxU) return 0;
  if (last <= 2) return suff[u];
  if (u + last - 1 > maxU) {
    return A[u];
  }
  int idx = last - first + 250;
  assert(0 <= idx && idx <= 500);
  int &ret = memo[u][idx];
  if (ret != -1) return ret;
  ret = 0;
  if (last == 3) {
    return ret = A[u] + DFS1(u + 2, 2);
  }
  if (last == 4) {
    int them = 0;
    if (u + 3 <= maxU) them += A[u + 3];
    if (u + 5 <= maxU) them += A[u + 5];
    if (u + 6 <= maxU) them += A[u + 6];
    if (u + 4 <= maxU && A[u + 4] > them) ret = DFS1(u + 4, 4);
    ret = max(ret, DFS1(u + 3, 3));
    ret += A[u];
    return ret;
  }
  for (int d = 0; d < 3; d++) {
    ret = max(ret, DFS1(u + last + dir[d], last + dir[d]));
  }
  ret += A[u];
  return ret;
}
int DFS2(int u, int last) {
  if (u >= (30000 + 1)) return 0;
  int idx = last - first + 250;
  assert(0 <= idx && idx <= 500);
  int &ret = memo[u][idx];
  if (ret != -1) return ret;
  ret = 0;
  for (int d = 0; d < 3; d++) {
    if (last + dir[d] > 0)
      ret = max(ret, DFS2(u + last + dir[d], last + dir[d]));
  }
  ret += A[u];
  return ret;
}
struct state {
  int first, second;
  bool childrenAreCalculated;
  state(int i, int j) {
    first = i, second = j;
    childrenAreCalculated = false;
  }
};
void stack_handle(int u, int last) {
  stack<state> st;
  st.push(state(u, last));
  while (!st.empty()) {
    state cur = st.top();
    st.pop();
    u = cur.first;
    last = cur.second;
    if (dp.count(make_pair(u, last))) continue;
    if (u > maxU)
      dp[make_pair(u, last)] = 0;
    else if (last <= 2) {
      int ret = 0;
      for (int i = u; i <= maxU; i++) ret += A[i];
      dp[make_pair(u, last)] = ret;
    } else if (!cur.childrenAreCalculated) {
      cur.childrenAreCalculated = true;
      st.push(cur);
      for (int d = 0; d < 3; d++) {
        if (last + dir[d] > 0) st.push(state(u + last + dir[d], last + dir[d]));
      }
    } else {
      int &ret = dp[make_pair(u, last)];
      for (int d = 0; d < 3; d++) {
        if (last + dir[d] > 0)
          ret = max(ret, DFS(u + last + dir[d], last + dir[d]));
      }
      ret += A[u];
    }
  }
}
int main() {
  read_file();
  while (scanf("%d %d", &n, &first) != EOF) {
    memset(A, 0, sizeof A);
    maxU = 0;
    for (int i = 0; i < n; i++) {
      int x;
      scanf("%d", &x);
      A[x]++;
      maxU = max(maxU, x);
    }
    suff[(30000 + 1) - 1] = A[(30000 + 1) - 1];
    for (int i = (30000 + 1) - 2; i >= 0; i--) suff[i] = suff[i + 1] + A[i];
    limit = find_lim(first, first);
    int ans;
    memset(memo, -1, sizeof memo);
    ans = DFS1(first, first);
    printf("%d\n", ans);
  }
}
