// Slower C++ solution:
#include <iostream>

#include <sstream>

#include <iomanip>

#include <cstdio>

#include <cstdlib>

#include <cmath>

#include <cctype>

#include <cstring>

#include <vector>

#include <list>

#include <queue>

#include <deque>

#include <stack>

#include <map>

#include <set>

#include <algorithm>

#include <iterator>

#include <bitset>

#include <ctime>

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 ITER(it,a) for (__typeof(a.begin()) it = a.begin(); it != a.end(); it++)

#define FILL(a,value) memset(a, value, sizeof(a))



#define SZ(a) (int)a.size()

#define ALL(a) a.begin(), a.end()

#define PB push_back

#define MP make_pair



typedef long long LL;

typedef vector<int> VI;

typedef pair<int, int> PII;



const double PI = acos(-1.0);

const int INF = 1000 * 1000 * 1000 + 7;

const LL LINF = INF * (LL) INF;



const int MAX = 111;

const double EPS = 1e-8;

const int MOD = 1000 * 1000 * 1000 + 7;





int A[MAX];

int DP[MAX][MAX][MAX];





int main()

{

    int n;

    scanf("%d", &n);

    int N = n + n - 1;

    FOR (i, 0, N)

        scanf("%d", &A[i]);

    sort(A, A + N);

    

    DP[0][1][0] = 1;

    FOR(i, 0, n)

    {

        FOR(j, 0, N + 1)

        {

            FOR(k, 0, j)

            {

                if (DP[i][j][k] == 0)continue;

                

                int l = n - i - 1;

                int r = n + i;

                

                int jj = j + (l > 0 && A[l] != A[l-1]) + (r < N && A[r] != A[r-1]);

                int kk = k + (l > 0 && A[l] != A[l-1]);

                

                FOR(x, 0, jj)

                {

                    int jjj = jj - max(0, abs(x - kk) - 1);

                    int kkk = min(x, kk + 1);

                    

                    DP[i+1][jjj][kkk] += DP[i][j][k];

                    if (DP[i+1][jjj][kkk] >= MOD)

                        DP[i+1][jjj][kkk] -= MOD;

                }

                

                

                

            }

        }

    }

    int res = 0;

    FOR(i, 0, N + 1)

        FOR(j, 0, i)

    {

        res += DP[n-1][i][j];

        if (res >= MOD)res -= MOD;

    }

    

    cout << res << endl;

    

    

}

    

    


// Faster C++ solution for the same problem (measured speedup: 3.785270346062737x):
#include<cstdio>

#include<cstring>

#include<algorithm>

#define MAXN 100

#define MO 1000000007

using namespace std;

typedef long long LL;

int a[MAXN+5],n;

LL f[MAXN+5][MAXN+5][MAXN+5];

int main()

{

	scanf("%d",&n);

	for(int i=1;i<=2*n-1;i++)

		scanf("%d",&a[i]);

	sort(a+1,a+2*n);

	f[n][1][0]=1;

	LL t;

	for(int i=n-1;i>=1;i--)

	{

		int al=(a[i]!=a[i+1]),ar=(a[2*n-i]!=+a[2*n-i-1]);

		for(int l=0;l<=2*n-1;l++)

			for(int r=0;l+r<=2*n-1;r++)

				if(f[i+1][l][r])

				{

					t=f[i+1][l][r];

					for(int dl=1;dl<=l+al;dl++)

					{

						f[i][l+al-dl+1][r+ar+(dl>1)]+=t;

						f[i][l+al-dl+1][r+ar+(dl>1)]%=MO;

					}

					for(int dr=1;dr<=r+ar;dr++)

					{

						f[i][l+al+1][r+ar-dr]+=t;

						f[i][l+al+1][r+ar-dr]%=MO;

					}

				}

	}

	LL ans=0;

	for(int l=0;l<=2*n-1;l++)

		for(int r=0;l+r<=2*n-1;r++)

			ans=(1LL*ans+1LL*f[1][l][r])%MO;

	printf("%lld\n",ans);

	return 0;

}