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>
namespace ioSubmission {
template <typename T>
inline T read() {
  T input;
  std::string line;
  getline(std::cin, line);
  std::istringstream iss(line);
  iss >> input;
  return input;
};
template <>
inline std::string read() {
  std::string line;
  getline(std::cin, line);
  return line;
}
template <typename T>
inline void write(T x) {
  std::cout << x << std::endl;
}
template <typename T>
inline std::vector<T> readColumn(unsigned int nbLines) {
  std::vector<T> result(nbLines);
  for (int i = 0; i < nbLines; ++i) {
    result[i] = read<T>();
  }
  return result;
}
template <typename T>
inline std::vector<T> readLine() {
  std::vector<T> result;
  std::string line;
  getline(std::cin, line);
  std::istringstream iss(line);
  T input;
  while (iss >> input) {
    result.push_back(input);
  }
  return result;
}
namespace GJam {
static int nbSol = 1;
template <typename T>
inline void writeSol(T x) {
  std::cout << "Case #" << nbSol << ": " << x << std::endl;
  nbSol++;
}
}  // namespace GJam
}  // namespace ioSubmission
namespace io = ioSubmission;
struct Submission {
  void run() {
    auto inputs = io::readLine<unsigned long long int>();
    auto specials = io::readLine<unsigned long long int>();
    auto page = inputs[2];
    auto n = inputs[0];
    size_t curSpecials = 0;
    unsigned long long int first = 1;
    unsigned long long int last = first + page - 1;
    bool isReplacing = false;
    unsigned long long int nbOps = 0;
    unsigned long long int nbDestructions = 0;
    while (first <= n || isReplacing) {
      if (specials[curSpecials] >= first && specials[curSpecials] <= last) {
        curSpecials++;
        if (curSpecials == specials.size()) {
          nbOps++;
          break;
        }
        nbDestructions++;
        isReplacing = true;
      } else {
        if (isReplacing) {
          nbOps++;
          isReplacing = false;
          last = std::min(last + nbDestructions, n);
          nbDestructions = 0;
        } else {
          first = last + 1;
          first += ((specials[curSpecials] - first) / page) * page;
          last = std::min(first + page - 1, n);
        }
      }
    }
    io::write(nbOps);
  }
};
int main() {
  Submission submission;
  submission.run();
  return 0;
}
static int fastio = []() {
  std::ios::sync_with_stdio(false);
  std::cin.tie(NULL);
  std::cout.tie(0);
  return 0;
}();
