#define _CRT_SECURE_NO_WARNINGS
#pragma comment(linker, "/stack:64000000")
#include <string>
#include <vector>
#include <map>
#include <list>
#include <iterator>
#include <cassert>
#include <set>
#include <queue>
#include <iostream>
#include <sstream>
#include <stack>
#include <deque>
#include <cmath>
#include <memory.h>
#include <cstdlib>
#include <cstdio>
#include <cctype>
#include <algorithm>
#include <utility>
#include <time.h>
#include <complex>
using namespace std;

#define FOR(i, a, b) for(int i=(a);i<(b);i++)
#define RFOR(i, b, a) for(int i=(b)-1;i>=(a);--i)
#define FILL(A,value) memset(A,value,sizeof(A))

#define ALL(V) V.begin(), V.end()
#define SZ(V) (int)V.size()
#define PB push_back
#define MP make_pair
#define Pi 3.14159265358979
#define x0 ikjnrmthklmnt
#define y0 lkrjhkltr
#define y1 ewrgrg

typedef long long Int;
typedef unsigned long long UInt;
typedef vector<int> VI;
typedef pair<int, int> PII;
typedef pair<Int, Int> PLL;
typedef pair<double, double> PDD;
typedef complex<double> base;

const int INF = 1000000000;
const int BASE = 1000000007;
const int MAX = 107;
const int MAXV = 100007;
const int MAXE = 100000;
const int ADD = 1000000;
const int MOD = 1000000007;
const int CNT = 800;

Int dp[107][37][17][17][4][4];

int main()
{
    //freopen("in.txt", "r", stdin);
    //freopen("distance.in",  "r", stdin);
    //freopen("distance.out", "w", stdout);
    //freopen("out.txt" , "w" , stdout);


	int n , m , k;
	cin >> n >> m >> k;

	dp[0][0][0][0][0][0] = 1;
	FOR(i,0,n)
	{
		int d = 0;
		if (i < n - 1)
			cin >> d;

		FOR(j,0,m)
		{
			FOR(c,0,k + 1)
			{
				FOR(pr , 0 , k + 1)
				{
					FOR(sng ,0, 3)
					{
						FOR(ends,0,3)
						{
							Int val = dp[i][j][c][pr][sng][ends];

							int opens = 2 * pr + sng;

							dp[i + 1][(j + (opens) * d) % m][c][pr][sng][ends] += val;
							dp[i + 1][(j + (opens) * d) % m][c][pr][sng][ends] %= MOD;

							if (ends < 2)
							{
								dp[i + 1][(j + (opens + 1) * d) % m][c + 1][pr][sng + 1][ends + 1] += val;
								dp[i + 1][(j + (opens + 1) * d) % m][c + 1][pr][sng + 1][ends + 1] %= MOD;
							}

							dp[i + 1][(j + (opens + 2) * d) % m][c + 1][pr + 1][sng][ends] += val;
							dp[i + 1][(j + (opens + 2) * d) % m][c + 1][pr + 1][sng][ends] %= MOD;

							dp[i + 1][(j + opens * d) % m][c + 1][pr][sng][ends] += val * (2 * pr + sng);
							dp[i + 1][(j + opens * d) % m][c + 1][pr][sng][ends] %= MOD;

							if (ends < 2)
							{
								if (pr > 0)
								{
									dp[i + 1][(j + (opens - 1) * d) % m][c + 1][pr - 1][sng + 1][ends + 1] += val * pr;
									dp[i + 1][(j + (opens - 1) * d) % m][c + 1][pr - 1][sng + 1][ends + 1] %= MOD;
								}
								if (sng > 0 && pr == 0 && c + 1 == k)
								{
									dp[i + 1][j][c + 1][0][sng - 1][ends + 1] += val;
									dp[i + 1][j][c + 1][0][sng - 1][ends + 1] %= MOD;
								}
							}

							if (pr == 0 && sng == 2 && c + 1 == k && ends == 2)
							{
								dp[i + 1][j][c + 1][0][0][ends] += val;
								dp[i + 1][j][c + 1][0][0][ends] %= MOD;
							}
							if (pr == 1 && sng == 0 && c + 1 == k && ends == 2)
							{
								dp[i + 1][j][c + 1][0][0][ends] += val;
								dp[i + 1][j][c + 1][0][0][ends] %= MOD;
							}

							if (pr > 0 && sng > 0)
							{
								dp[i + 1][(j + (opens - 2) * d) % m][c + 1][pr - 1][sng][ends] += val * pr * sng;
								dp[i + 1][(j + (opens - 2) * d) % m][c + 1][pr - 1][sng][ends] %= MOD;
							}

							if (pr > 1)
							{
								dp[i + 1][(j + (opens - 2) * d) % m][c + 1][pr - 1][sng][ends] += val * pr * (pr - 1);
								dp[i + 1][(j + (opens - 2) * d) % m][c + 1][pr - 1][sng][ends] %= MOD;
							}

						}
					}
				}
			}

		}

	}

	cout << dp[n][0][k][0][0][2] * 2 % MOD << endl;

    return 0;
}