#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>
using namespace std;

ifstream f("pod.in");
ofstream g("pod.out");

const int mod=9901;

vector<int>imposibil;

int mat[25][25], init[25][25], dp[25][25], neutru[25][25];
int n, m, k, x, ind, auxk, dif;

void formare_mat()
{
    for (int i=1; i<=k; ++i)
        for (int j=1; j<=k; ++j)
        mat[i][j]=0;
    mat[1][1]=1;
    mat[1][k]=1;
    for (int i=2; i<=k; ++i)
        mat[i][i-1]=1;
}

void inmultire(int a[25][25], int b[25][25])
{
    int auxmat[25][25];
    for (int i=1; i<=k; ++i)
        for (int j=1; j<=k; ++j)
            auxmat[i][j]=0;
    for (int t=1; t<=k; ++t)
    {
        for (int i=1; i<=k; ++i)
        {
            for (int j=1; j<=k; ++j)
            {
                auxmat[t][i]+=a[t][j]*b[j][i];
                auxmat[t][i]%=mod;
            }
        }
    }
    for (int i=1; i<=k; ++i)
        for (int j=1; j<=k; ++j)
            a[i][j]=auxmat[i][j];
}

void ridicare_putere(int putere)
{
    for (int i=1; i<=k; ++i)
    {
        for (int j=1; j<=k; ++j)
            {
                if (i==j)
                    neutru[i][j]=1;
                else
                    neutru[i][j]=0;
            }

    }
    formare_mat();
    while (putere>1)
    {
        if (putere&1)
            inmultire(neutru,mat);
        inmultire(mat,mat);
        putere>>=1;
    }
    inmultire(neutru,mat);
    inmultire(dp,neutru);
}

void solve()
{
    dp[1][k]=1;
    for (int i=1; i<k; ++i)
    {
        if (imposibil[ind]==i)
        {
            ++ind;
            dp[1][k-i]=0;
        }
        else
            dp[1][k-i]=dp[1][k-i+1];
    }
    int ultim=k-1;
    int h;
    for (int i=0; i<m; ++i)
    {
        if (imposibil[i]<=ultim)
            continue;
        h=imposibil[i];
        ridicare_putere(h-ultim);

        dp[1][1]=0;
        ultim=imposibil[i];

    }

    if (ultim<n)
        ridicare_putere(n-ultim);

    g << dp[1][1];
}

int main( )
{
    f >> n >> m >> k;
    auxk=k+1;
    for (int i=1; i<=m; ++i)
    {
        f >> x;
        imposibil.push_back(x);
    }
    sort(imposibil.begin(),imposibil.end());
    imposibil.push_back(n);
    solve();
    return 0;
}