10 5 5
2 3 4 5 6
 1 1 1
1
 1000000000000000000 10 68
9818112234872670 233245257111863071 266483628625876079 375103213040049805 431982380866113633 489732004669478331 501030096787260719 541800997319766183 551892546260532408 696178619227890200
 1000000000000000000 2 1
1 1000000000000000000
 33 32 1
1 2 3 4 5 6 7 8 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33
 101 55 10
1 3 5 7 8 9 10 16 18 21 22 23 24 25 27 30 32 35 36 37 38 39 40 43 45 47 49 50 51 52 54 57 59 61 64 66 67 68 69 70 71 72 73 80 83 86 87 88 89 90 91 92 96 97 98
 1000000000000000000 5 1000
1 1000000000 1000000000000 1000000000000000 1000000000000001
 15 15 15
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
 21 21 20
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
 45 43 2
1 2 3 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45
 107 20 13
5 9 20 25 26 30 37 45 51 58 62 73 82 87 89 90 99 101 104 106
 3 2 1
1 2
 1000000000 2 1000000000
1 1000000000
 11 7 3
2 3 4 5 6 7 11
 13 9 4
1 2 3 6 7 8 11 12 13
 1000000000000000000 2 1000000000
102306300054748096 267367244641009859
 16 7 5
2 3 4 5 6 15 16
 35 35 1
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35
 1000000000000000000 20 365
31881893160049984 103938857870698567 103962228223609431 140762820261865064 175962215264653912 239086305245565642 354522451098745823 383839975876242372 443471287955807705 478923027151493682 511195154588214957 619570919279066139 677571312513476877 705864797651447277 789633853044745934 867300890280086078 883297431113041450 891736036124527038 937306858250803630 990892290394455512

2
 1
 10
 2
 32
 15
 4
 1
 2
 35
 9
 2
 1
 4
 4
 2
 4
 35
 20

#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 100;
long long arr[N];
long long dat[N];
int Left[N], Right[N];
long long flag[N];
void build(int p, int l, int r) {
  Left[p] = l;
  Right[p] = r;
  if (l == r) {
    dat[p] = arr[l];
    return;
  }
  int mid = (l + r) >> 1;
  build(2 * p, l, mid);
  build(2 * p + 1, mid + 1, r);
  dat[p] = dat[2 * p] + dat[2 * p + 1];
}
void spread(int p) {
  if (!flag[p]) return;
  dat[2 * p] += flag[p] * (Right[2 * p] - Left[p * 2] + 1);
  dat[2 * p + 1] += flag[p] * (Right[2 * p + 1] - Left[p * 2 + 1] + 1);
  flag[2 * p] += flag[p];
  flag[2 * p + 1] += flag[p];
  flag[p] = 0;
}
void change(int p, int l, int r, long long v) {
  if (l <= Left[p] && r >= Right[p]) {
    dat[p] += v * (Right[p] - Left[p] + 1);
    flag[p] += v;
    return;
  }
  int mid = (Left[p] + Right[p]) >> 1;
  spread(p);
  if (l <= mid) change(p * 2, l, r, v);
  if (r > mid) change(2 * p + 1, l, r, v);
  dat[p] = dat[p * 2] + dat[2 * p + 1];
}
long long ask(int p, int l, int r) {
  if (l <= Left[p] && r >= Right[p]) return dat[p];
  int mid = (Left[p] + Right[p]) >> 1;
  long long val = 0;
  spread(p);
  if (l <= mid) val += ask(p * 2, l, r);
  if (r > mid) val += ask(2 * p + 1, l, r);
  return val;
}
void update(int x, int y, long long num) { change(1, x, y, -num); }
int main() {
  long long n, m, k, group, pre, ans, num;
  while (cin >> n >> m >> k) {
    memset(arr, 0, sizeof(arr));
    for (int i = 1; i <= m; i++) cin >> arr[i];
    memset(dat, 0, sizeof(dat));
    memset(Left, 0, sizeof(Left));
    memset(Right, 0, sizeof(Right));
    memset(flag, 0, sizeof(flag));
    sort(arr + 1, arr + 1 + m);
    build(1, 1, m);
    pre = num = ans = 0;
    for (int i = 1; i <= m; i++) {
      long long tmp = ask(1, 1, i) - ask(1, 1, i - 1);
      group = tmp / k;
      if (tmp % k != 0) group++;
      num++;
      if (group != pre) {
        ans++;
        update(i, m, num - 1);
        tmp = ask(1, 1, i) - ask(1, 1, i - 1);
        group = tmp / k;
        if (tmp % k != 0) group++;
        pre = group;
        num = 1;
      }
    }
    cout << ans << endl;
  }
  return 0;
}
