Recently, Tokitsukaze found an interesting game. Tokitsukaze had n items at the beginning of this game. However, she thought there were too many items, so now she wants to discard m (1 ≤ m ≤ n) special items of them.

These n items are marked with indices from 1 to n. In the beginning, the item with index i is placed on the i-th position. Items are divided into several pages orderly, such that each page contains exactly k positions and the last positions on the last page may be left empty.

Tokitsukaze would do the following operation: focus on the first special page that contains at least one special item, and at one time, Tokitsukaze would discard all special items on this page. After an item is discarded or moved, its old position would be empty, and then the item below it, if exists, would move up to this empty position. The movement may bring many items forward and even into previous pages, so Tokitsukaze would keep waiting until all the items stop moving, and then do the operation (i.e. check the special page and discard the special items) repeatedly until there is no item need to be discarded.

<image> Consider the first example from the statement: n=10, m=4, k=5, p=[3, 5, 7, 10]. The are two pages. Initially, the first page is special (since it is the first page containing a special item). So Tokitsukaze discards the special items with indices 3 and 5. After, the first page remains to be special. It contains [1, 2, 4, 6, 7], Tokitsukaze discards the special item with index 7. After, the second page is special (since it is the first page containing a special item). It contains [9, 10], Tokitsukaze discards the special item with index 10.

Tokitsukaze wants to know the number of operations she would do in total.

Input

The first line contains three integers n, m and k (1 ≤ n ≤ 10^{18}, 1 ≤ m ≤ 10^5, 1 ≤ m, k ≤ n) — the number of items, the number of special items to be discarded and the number of positions in each page.

The second line contains m distinct integers p_1, p_2, …, p_m (1 ≤ p_1 < p_2 < … < p_m ≤ n) — the indices of special items which should be discarded.

Output

Print a single integer — the number of operations that Tokitsukaze would do in total.

Examples

Input


10 4 5
3 5 7 10


Output


3


Input


13 4 5
7 8 9 10


Output


1

Note

For the first example:

  * In the first operation, Tokitsukaze would focus on the first page [1, 2, 3, 4, 5] and discard items with indices 3 and 5; 
  * In the second operation, Tokitsukaze would focus on the first page [1, 2, 4, 6, 7] and discard item with index 7; 
  * In the third operation, Tokitsukaze would focus on the second page [9, 10] and discard item with index 10. 



For the second example, Tokitsukaze would focus on the second page [6, 7, 8, 9, 10] and discard all special items at once.
import java.io.*;
import java.util.*;

public class Main
 {
//     class Reader 
//     {
//         final private int BUFFER_SIZE = 1 << 100000000;
//         private DataInputStream din;
//         private byte[] buffer;
//         private int bufferPointer, bytesRead;
 
//         public Reader()
//         {
//             din = new DataInputStream(System.in);
//             if (System.getProperty("ONLINE_JUDGE") == null) 
//             {
//             try 
//             {
//                 System.setOut(new PrintStream(new FileOutputStream("output.txt")));
//                 din = new DataInputStream(new FileInputStream("input.txt"));
//             }
//               catch (Exception e) {
//             }
//         }
//             buffer = new byte[BUFFER_SIZE];
//             bufferPointer = bytesRead = 0;
//         }
 
//         public Reader(String file_name) throws IOException
//         {
//             din = new DataInputStream(
//                 new FileInputStream(file_name));
//             buffer = new byte[BUFFER_SIZE];
//             bufferPointer = bytesRead = 0;
//         }
 
//         public String readLine() throws IOException
//         {
//             byte[] buf = new byte[100000000]; // line length
//             int cnt = 0, c;
//             while ((c = read()) != -1) {
//                 if (c == '\n') {
//                     if (cnt != 0) {
//                         break;
//                     }
//                     else {
//                         continue;
//                     }
//                 }
//                 buf[cnt++] = (byte)c;
//             }
//             return new String(buf, 0, cnt);
//         }
 
//         public int nextInt() throws IOException
//         {
//             int ret = 0;
//             byte c = read();
//             while (c <= ' ') {
//                 c = read();
//             }
//             boolean neg = (c == '-');
//             if (neg)
//                 c = read();
//             do {
//                 ret = ret * 10 + c - '0';
//             } while ((c = read()) >= '0' && c <= '9');
 
//             if (neg)
//                 return -ret;
//             return ret;
//         }
 
//         public long nextLong() throws IOException
//         {
//             long ret = 0;
//             byte c = read();
//             while (c <= ' ')
//                 c = read();
//             boolean neg = (c == '-');
//             if (neg)
//                 c = read();
//             do {
//                 ret = ret * 10 + c - '0';
//             } while ((c = read()) >= '0' && c <= '9');
//             if (neg)
//                 return -ret;
//             return ret;
//         }
 
//         public double nextDouble() throws IOException
//         {
//             double ret = 0, div = 1;
//             byte c = read();
//             while (c <= ' ')
//                 c = read();
//             boolean neg = (c == '-');
//             if (neg)
//                 c = read();
 
//             do {
//                 ret = ret * 10 + c - '0';
//             } while ((c = read()) >= '0' && c <= '9');
 
//             if (c == '.') {
//                 while ((c = read()) >= '0' && c <= '9') {
//                     ret += (c - '0') / (div *= 10);
//                 }
//             }
 
//             if (neg)
//                 return -ret;
//             return ret;
//         }
 
//         private void fillBuffer() throws IOException
//         {
//             bytesRead = din.read(buffer, bufferPointer = 0,
//                                  BUFFER_SIZE);
//             if (bytesRead == -1)
//                 buffer[0] = -1;
//         }
 
//         private byte read() throws IOException
//         {
//             if (bufferPointer == bytesRead)
//                 fillBuffer();
//             return buffer[bufferPointer++];
//         }
 
//         public void close() throws IOException
//         {
//             if (din == null)
//                 return;
//             din.close();
//         }

//     }
    public String ns() throws IOException
    {
        return(read.nextLine());
    }
    public String wrd() throws IOException
    {
        return(read.next());
    }
    public int ni() throws IOException
    {
        return(read.nextInt());
    }
    public double nd() throws IOException
    {
        return(read.nextDouble());
    }
    public long nl() throws IOException
    {
        return(read.nextLong());
    }
    public int[] ai(int n) throws IOException
    {
        int arr[] = new int[n];
        for(int i = 0; i<n; i++)
            arr[i] = read.nextInt();
        return(arr);
    }
    public double[] ad(int n) throws IOException
    {
        double arr[] = new double[n];
        for(int i = 0; i<n; i++)
            arr[i] = read.nextDouble();
        return(arr);
    }
    public long[] al(int n) throws IOException
    {
        long arr[] = new long[n];
        for(int i = 0; i<n; i++)
            arr[i] = read.nextLong();
        return(arr);
    }

// Reader read;

    class FastReader 
    {
        BufferedReader br;
        StringTokenizer st;

        public FastReader()
        {
            br = new BufferedReader(new InputStreamReader(System.in));
            if (System.getProperty("ONLINE_JUDGE") == null) 
            {
                 try 
                {
                    InputStream inputStream = new FileInputStream("input.txt");
                    InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
                    System.setOut(new PrintStream(new FileOutputStream("output.txt")));
                     br = new BufferedReader(inputStreamReader);
                }
               catch (Exception e) 
               {
                e.printStackTrace();
               }
            }
        }

    String next()
    {
        while (st == null || !st.hasMoreElements()) 
        {
            try 
            {
                st = new StringTokenizer(br.readLine());
            }
            catch (IOException e) 
            {
                e.printStackTrace();
            }
        }
        return st.nextToken();
    }

    int nextInt() { return Integer.parseInt(next()); }

    long nextLong() { return Long.parseLong(next()); }

    double nextDouble(){return Double.parseDouble(next());}

    String nextLine()
    {
        String str = "";
        try 
        {
            str = br.readLine();
        }
        catch (IOException e) 
        {
            e.printStackTrace();
        }
        return str;
        }
    }
public static void main(String[] args) throws IOException
    
    {
        Main obj = new Main();
        obj.solve();
        //obj.read = new Reader();
        
    }
        public int getParent(int parent[], int src)
    {
        if(parent[src] != src)
        {
            int ultimateparent = getParent(parent, parent[src]);
            parent[src] = ultimateparent;
            return ultimateparent;
        }
        return src;
    }

    public void union(int parent[], int i, int j, int rank[])
    {

        int root1 = getParent(parent, i);
        int root2 = getParent(parent, j);
        if(rank[root1] == rank[root2])
        {
            parent[root1] = root2;
            rank[root2]++ ;
        }
        else if(rank[root1] > rank[root2])
        {
            parent[root2] = root1;
        }
        else // rank[root2] > rank[root1]
        {
            parent[root1] = root2;
        }
    }


    public int log(long x)
    {
        return (int) (Math.log(x) / Math.log(2) + 1e-10);
    }

    public long binomial1(long n, long r)
    {
        // when   n-r > r
        long ans = 1;
        for(long i = (n-r+1); i<=n; i++)
            ans *= i;

        for(long i = 2; i<=r; i++)
            ans /= i;

        return ans;
    }
    public long binomial2(long n, long r)
    {
        //when   r > n-r
        long ans = 1;
        for(long i = r+1; i<=n; i++)
            ans *= i;

        for(long i = 2; i<=(n-r); i++)
            ans /= i;

        return ans; 
    }

    public long binomial(int n, int r, long dp[][])
    {
        // if(n-r > r)
        //     return(binomial1(n, r));
        // else
        //     return(binomial2(n, r));
        if(dp[n][r] != 0l)
            return dp[n][r];
        if(r == 0)
            return 1;
        if(n < r)
            return 0;
        dp[n][r] = ( ((n*1l)* binomial(n-1, r-1, dp) )/ r);
        return(dp[n][r]);
        
    }
    long gcd (long a, long b) 
    {
        //System.out.print("GCD OF "+a+" , "+b+" = ");
      long r, i;
      while(b!=0)
      {
        r = a % b;
        a = b;
        b = r;
      }
      //System.out.println(" "+a);
      return a;
    }
    public int getParent(int root, int parent[])
    {
        if(parent[root] == root)
        {
            return(root);
        }
        parent[root] = getParent(parent[root], parent);
        return(parent[root]);
    }

    public void buildtree(long segmentTree[], int idx, int start, int end, long arr[])
    {
        if(start == end)
        {
            segmentTree[idx] = arr[start];
            return;
        }

        int mid = (end + start)/2;

        buildtree(segmentTree, 2*idx, start, mid, arr);
        buildtree(segmentTree, 2*idx + 1, mid+1, end, arr);

        segmentTree[idx] = gcd(segmentTree[2*idx] , segmentTree[2*idx +1]);
    }

    public long query(long segmentTree[] , int idx, int start, int end, int querystart, int queryend)
    {
        if(start >= querystart && end <= queryend)
            return(segmentTree[idx]);
        else if(end < querystart || start > queryend)
            return 0;
        else
        {
            int mid = (end + start)/2;
            long leftQuery = query(segmentTree, 2*idx, start, mid, querystart, queryend);
            long rightQuery = query(segmentTree, 2*idx + 1, mid+1, end, querystart, queryend);
            return(gcd(leftQuery , rightQuery));
        }
    }

    

//--------------------------------------------------------------------------------------------------------------
    private double getPage(long n, int del, long k)
    {

        double nn = n;
        double kk = k;
        long dj = n - del;
        nn -= del;
        double qq = Math.floor(nn/kk);
        
        long rem = dj%k;
        if(rem != 0)
            qq++;
        //System.out.println("N = "+n+"  AFTER DEL = "+dj+" PAGE  =  "+ qq);
        return((qq));
    }

    long MODULO = 1000000007;
    FastReader read;

    public void solve() throws IOException
    {

        read = new FastReader();

        long n = nl();
        int m = ni();
        long k = nl();

        long special[] = new long[m];

        for(int i = 0; i<m; i++)
        special[i] = nl();

        int deleted = 0;

        int op = 0;

        int idx = 0;
        while(idx < m)
        {
            //System.out.println("idx = "+idx);
            op++;
            double page = getPage(special[idx], deleted, k);

            int idx2 = idx;
            int delkaro = 0;
            while( idx2 < m && ( getPage(special[idx2], deleted, k)   ==  page)  )
                {
                    //System.out.println("DEL  = "+deleted);
                    delkaro++;
                    //System.out.println("1 -> "+ special[idx2] );
                    //System.out.println("PAGE -> "+getPage(special[idx2], deleted, k));
                    idx2++;
                }
            deleted+= delkaro;
            idx = idx2;
        } 

        System.out.println(op); 

        }

        
    
    

}

