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

/*
    Coded by : Dip Turkar
    
    {TIPS WHILE STARTING}
    --check if you have to input t or not
    --check for long long overflows
    --figure out logic first, then start writing pls!!!!!!!
*/
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define MOD 1000000007

#define nl "\n"
#define fastio() ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);

#define cerr if(0)cerr //quickly remove debug statements

#define ff first
#define ss second
#define pb push_back
#define mp make_pair
#define FOR(a, b, c) for(int(a) = (b); (a) < (c); ++(a))
#define REP(i,n) FOR(i,0,n)
#define scan(arr,n) REP(i,n)cin>>arr[i];
#define setbits(x) __builtin_popcountll(x)
#define all(v) v.begin(),v.end()
#define rall(v) v.rbegin(),v.rend()
#define watch(x) cerr << "\n" << (#x) << " is " << (x) << endl
#define YES() cout<<"YES\n";return
#define Yes() cout<<"Yes\n";return
#define yes() cout<<"yes\n";return
#define NO() cout<<"NO\n";return
#define no() cout<<"no\n";return
#define No() cout<<"No\n";return

typedef unsigned long long int ulli;
typedef long long int lli;
typedef long long ll;
typedef long double lld;

typedef vector<string> vs;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<vi> vii;
typedef vector<vl> vll;
typedef vector<pii> vpii;
typedef vector<pll> vpll;
typedef pair<string, string> pss; 
typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> indexed_set;
//member functions :
//1. order_of_key(k) : number of elements strictly lesser than k
//2. find_by_order(k) : k-th element in the set

lld pi = 3.1415926535897932;

// Seive
bool prime[1000001];
void primesTable(){
    memset(prime, true, sizeof(prime));
    for (int p = 2; p * p <= 1000001; p++){
        if (prime[p] == true){
            for (int i = p * p; i <= 1000001; i += p)
                prime[i] = false;
        }
    }            
}
//hashes pair for unordered set and any other use
struct hash_pair{ 
    template <class T1, class T2> 
    size_t operator()(const pair<T1, T2>& p) const{ 
        auto hash1 = hash<T1>{}(p.first); 
        auto hash2 = hash<T2>{}(p.second); 
        return hash1 ^ hash2; 
    } 
};
//gcd 
ll gcd(ll a, ll b){
    if (!b)
        return a;
    return gcd(b, a % b);
}
//power
ll power(ll x, ll y, ll p){
    ll res = 1;
    x %= p;
    while (y > 0){
        if (y & 1)
            res = (res * x) % p;
        y = y >> 1;
        x = (x * x) % p;
    }
    return res;
}
//lcm
ll lcm(ll a, ll b) { return (a * b) / gcd(a, b); }

/*!!!!!!!!!!START CODING HERE!!!!!!!!!!*/
void testcase(){
    ll n,m,k;
    cin>>n>>m>>k;
    ll s[m];
    scan(s,m);
    ll x = 1;
    ll div = (s[0]-x)/k;
    ll cnt = 1;
    ll ans = 0;
    FOR(i,1,m){
        int curr_div = (s[i]-x)/k;
        watch(curr_div);
        watch(div);

        if(curr_div==div){
            cnt++;
        }else{
            ans++;
            x += cnt;
            cnt = 1;
            div = (s[i]-x)/k;
        }
        watch(ans);
    }
    ans++;
    x += cnt;
    cout<<ans<<nl;
}

int main() {
    fastio();
	int t=1;
	// cin>>t;
	while(t--){
	    testcase();
	} 
    cerr << "\nTime elapsed : " << 1000 * clock() / CLOCKS_PER_SEC << " ms\n";
}
