stablegradients/pie-gem5-pairs huggingface dataset:
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;

#define rint register int

inline int rf(){int r;int s=0,c;for(;!isdigit(c=getchar());s=c);for(r=c^48;isdigit(c=getchar());(r*=10)+=c^48);return s^45?r:-r;}

int a[100005], n; bool W(int i){bool U = (a[i+1]-i)&1, R = 0; for(rint j = i+1; j <= n && a[j]>i; R ^= 1, j++); return U&R;}

int main(){n = rf(); generate(a+1,a+n+1,rf); sort(a+1,a+n+1,greater<int>()); for(rint i = 2; i <= n+1; i++) if(a[i]<i) return puts(W(i-2)?"Second":"First"),0;}

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

#include <algorithm>



const int MAXN = 1e5 + 5;



template<typename _T>

void read( _T &x )

{

	x = 0; char s = getchar(); int f = 1;

	while( s < '0' || '9' < s ) { f = 1; if( s == '-' ) f = -1; s = getchar(); }

	while( '0' <= s && s <= '9' ) { x = ( x << 1 ) + ( x << 3 ) + s - '0', s = getchar(); }

	x *= f;

}



template<typename _T>

void write( _T x )

{

	if( x < 0 ) { putchar( '-' ), x = -x; }

	if( 9 < x ) write( x / 10 );

	putchar( x % 10 + '0' );

}



int a[MAXN];

int N;



bool cmp( const int &a, const int &b ) { return a > b; }



int main()

{

	read( N );

	for( int i = 1 ; i <= N ; i ++ ) read( a[i] );

	std :: sort( a + 1, a + 1 + N, cmp );

	int fir = 1;

	for( ; fir <= N && fir + 1 <= a[fir + 1] ; fir ++ );

	bool up = ( a[fir] - fir + 1 ) & 1, rig = true;

	for( int i = fir + 1 ; i <= N && a[i] >= fir ; i ++, rig ^= 1 );

	bool tag = ! ( up & rig );

	puts( tag ? "First" : "Second" );

	return 0;

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

#include<cstdio>

#include<algorithm>

#define N 100100

using namespace std;



int n,num[N];



inline bool cmp(int u,int v)

{

	return u>v;

}



int main()

{

	int i,j;

	cin>>n;

	for(i=1;i<=n;i++)

	{

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

	}

	sort(num+1,num+n+1,cmp);

	for(i=1;i<=n;i++)

	{

		if(i>num[i]) break;

	}

	i--;

	if((num[i]-i)&1)

	{

		puts("First");

		return 0;

	}

	for(j=i+1;num[j]==i;j++);

	j--;

	if((j-i)&1)

	{

		puts("First");

		return 0;

	}

	puts("Second");

}

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

#include <algorithm>



const int MAXN = 1e5 + 5;



template<typename _T>

void read( _T &x )

{

	x = 0; char s = getchar(); int f = 1;

	while( s < '0' || '9' < s ) { f = 1; if( s == '-' ) f = -1; s = getchar(); }

	while( '0' <= s && s <= '9' ) { x = ( x << 1 ) + ( x << 3 ) + s - '0', s = getchar(); }

	x *= f;

}



template<typename _T>

void write( _T x )

{

	if( x < 0 ) { putchar( '-' ), x = -x; }

	if( 9 < x ) write( x / 10 );

	putchar( x % 10 + '0' );

}



int a[MAXN];

int N;



bool cmp( const int &a, const int &b ) { return a > b; }



int main()

{

	read( N );

	for( int i = 1 ; i <= N ; i ++ ) read( a[i] );

	std :: sort( a + 1, a + 1 + N, cmp );

	int fir = 1;

	for( ; fir <= N && fir + 1 <= a[fir + 1] ; fir ++ );

	bool up = ( a[fir] - fir + 1 ) & 1, rig = true;

	for( int i = fir + 1 ; i <= N && a[i] >= fir ; i ++, rig ^= 1 );

	bool tag = ! ( up & rig );

	puts( tag ? "First" : "Second" );

	return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

int n,a[100100];

bool cmp(int x,int y)

{

	return x>y;

}

int main()

{

	cin>>n;

	for (int i=1;i<=n;i++)

	{

		cin>>a[i];

	}

	sort(a+1,a+n+1,cmp);

	int x=0,y=0;

    while (y+1<n&&x+1<a[y+2]&&x+1<a[y+1])

    {

    	x++;y++;

    }

    //走到边界处 

	int xx=(a[y+1]-x)%2,yy=1;

	//xx+1即为由上走出界的步数，yy同理 

	for (int i=x;i<=n;i++)

	{

		yy^=1;

		if (x>=a[i+1]) break;

	}

	if ((!xx)||(!yy)) cout<<"First\n";else cout<<"Second";

	return 0;

}

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

#include <algorithm>

#include <cstring>

using namespace std;

int n,a[100100];

bool cmp(int a,int b){

    return a>b;

}

int main(){

    scanf("%d",&n);

    for(int i=1;i<=n;i++)

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

    sort(a+1,a+n+1,cmp);

    for(int i=1;i<=n;i++){

        if(i+1>a[i+1]){

            int ans=0;

            for(int j=i+1;a[j]==i;j++)

                ans^=1;

            if(ans||((a[i]-i)&1))

                printf("First\n");

            else

                printf("Second\n");

            return 0;

        }

    }

    return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

int n,a[100010];

int main()

{

    cin>>n;

    for(int i=1;i<=n;++i)scanf("%d",a+i);

    sort(a+1,a+n+1,greater<int>());

    for(int i=1;i<=n;++i){

        if(i+1>a[i+1]){

        	int ans=0;

            for(int j=i+1;a[j]==i;++j)ans^=1;

            ans|=(a[i]-i)&1;

            if(ans)puts("First");

            else puts("Second");

            return 0;

            

		}

	}

}

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

#include <algorithm>

#include <cstring>

using namespace std;

int n,a[100100];

bool cmp(int a,int b){

    return a>b;

}

int main(){

    scanf("%d",&n);

    for(int i=1;i<=n;i++)

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

    sort(a+1,a+n+1,cmp);

    for(int i=1;i<=n;i++){

        if(i+1>a[i+1]){

            int ans=0;

            for(int j=i+1;a[j]==i;j++)

                ans^=1;

            if(ans||((a[i]-i)&1))

                printf("First\n");

            else

                printf("Second\n");

            return 0;

        }

    }

    return 0;

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

#include<iomanip>

#include<cstring>

#include<cstdio>

#include<cmath>

#include<algorithm>

#include<stack>

using namespace std;

int n,a[100005];

bool cmp(const int x,const int y){

	return x>y;

}

int main(){

	scanf("%d",&n);

    for(int i=1;i<=n;i++)scanf("%d",&a[i]);

    sort(a+1,a+n+1,cmp);

    for(int i=1;i<=n;i++)

        if(a[i+1]<i+1){

            int ans=0;

            for(int j=i+1;a[j]==i;j++)ans^=1;

            ans|=(a[i]-i)%2;

            if(ans>0)printf("First");

            else printf("Second");

            exit(0);

    }

    return 0;

}

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

#include <algorithm>

#include <cstring>

using namespace std;

int n,a[100100];

bool cmp(int a,int b){

    return a>b;

}

int main(){

    scanf("%d",&n);

    for(int i=1;i<=n;i++)

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

    sort(a+1,a+n+1,cmp);

    for(int i=1;i<=n;i++){

        if(i+1>a[i+1]){

            int ans=0;

            for(int j=i+1;a[j]==i;j++)

                ans^=1;

            if(ans||((a[i]-i)&1))

                printf("First\n");

            else

                printf("Second\n");

            return 0;

        }

    }

    return 0;

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

#include <cstdio>

#include <cstring>

#include <algorithm>



#define MAXN 100010

#define ri register int



using namespace std;



int N;

int a[MAXN];



inline int read_int()

{

	register int ret = 0, f = 1; register char c = getchar();

	while(c < '0' || c > '9') {if(c == '-') f = -1; c = getchar();}

	while(c >= '0' && c <= '9') {ret = (ret << 1) + (ret << 3) + int(c - 48); c = getchar();}

	return ret * f;

}



inline bool cmp(int x, int y) {return x > y;}



inline void init()

{

	N = read_int();

	for(ri i = 1; i <= N; i++)

		a[i] = read_int();

	sort(a + 1, a + N + 1, cmp);

}



inline void dp()

{

	for(ri i = 1; i <= N; i++)

	{

		if(i + 1 > a[i + 1])

		{

			ri j = i + 1, ans = 0;

			while(a[j] == i)

				ans ^= 1, j++;

			if((ans || ((a[i] - i) & 1)))

				puts("First");

			else

				puts("Second");

			return;

		}

	}

}



int main()

{

	init();

	dp();

	return 0;

}

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

#include <algorithm>

#include <cstring>

using namespace std;

int n,a[100100];

bool cmp(int a,int b){

    return a>b;

}

int main(){

    scanf("%d",&n);

    for(int i=1;i<=n;i++)

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

    sort(a+1,a+n+1,cmp);

    for(int i=1;i<=n;i++){

        if(i+1>a[i+1]){

            int ans=0;

            for(int j=i+1;a[j]==i;j++)

                ans^=1;

            if(ans||((a[i]-i)&1))

                printf("First\n");

            else

                printf("Second\n");

            return 0;

        }

    }

    return 0;

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

#include <algorithm>



using namespace std;



int hrpe[100005];



int main() {

	int n;

	cin >> n;

	for (int i=0;i<n;i++) cin >> hrpe[i];

	sort (hrpe, hrpe+n);

	int zadnji = -1;

	for (int i=0;i<n;i++) {

		int b = hrpe[i]-1;

		int u = n-i-1;

		if ((b+u) % 2 == 0) {

			if (u <= (b+u)/2) {

				if (zadnji == -1) {

					cout << "Second";

					break;

				}

				else if (hrpe[i-1] != hrpe[i]) {

					cout << "Second";

					break;

				}

				else if (!zadnji) {

					cout << "Second";

					break;

				}

			}

		}

		else {

			if (u <= (b+u)/2+1) {

				if (zadnji == -1) {

					cout << "First";

					break;

				}

				else if (hrpe[i-1] != hrpe[i]) {

					cout << "First";

					break;

				}

				else if (zadnji) {

					cout << "First";

					break;

				}

			}

		}

		if (i != 0) {

			if (hrpe[i-1] != hrpe[i]) {

				zadnji = (b+u)%2;

			}

		}

		else {

			zadnji = (b+u) % 2;

		}

	}

	return 0;

}


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

#include <algorithm>

#include <cstring>

using namespace std;

int n,a[100100];

bool cmp(int a,int b){

    return a>b;

}

int main(){

    scanf("%d",&n);

    for(int i=1;i<=n;i++)

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

    sort(a+1,a+n+1,cmp);

    for(int i=1;i<=n;i++){

        if(i+1>a[i+1]){

            int ans=0;

            for(int j=i+1;a[j]==i;j++)

                ans^=1;

            if(ans||((a[i]-i)&1))

                printf("First\n");

            else

                printf("Second\n");

            return 0;

        }

    }

    return 0;

}
// Slower C++ solution:
/*

by.YXH_XianYu

 */

#include<algorithm>

#include<iostream>

#include<cstring>

#include<cstdio>

#include<cmath>

#define MXN 100003



int n,

	a[MXN];

bool naive;



bool comp(int a, int b){

	return a>b;

}



int main(){



	scanf("%d",&n);

	for(int i=1;i<=n;i++)

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

	std::sort(a+1,a+n+1,comp);

	

	int i,j;

	for(i=1;i<=n;i++)

		if(a[i]<i)

			break;

	i--;

	for(j=i;j<=n;j++)

		if(i>a[j])

			break;

	j--;

	//printf("i=%d a[i]=%d j=%d\n",i,a[i],j);

	if(((j-i)&1) || ((a[i]-i)&1))

		printf("First\n");

	else

		printf("Second\n");



	//system("pause");

	return 0;

}


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

#include<algorithm>

using namespace std;

int N,A[100010];

bool Cmp(const int &X,const int &Y){

	return X>Y;

}

int main(){

	scanf("%d",&N);

    for(int i=1;i<=N;i++){

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

	}

    sort(A+1,A+N+1,Cmp);

    /*

    for(int i=1;i<=N;i++){

    	printf("%d ",A[i]);

	}

	printf("\n");

	*/

    for(int i=1;i<=N;i++){

        if(i+1>A[i+1]){

            int Ans=0;

            for(int j=i+1;A[j]==i;j++){

            	Ans=Ans^1;

			}

            Ans=Ans|((A[i]-i)&1);

            if(Ans){

            	printf("First\n");

			}else{

				printf("Second\n");

			}

            return 0;

        }

    }

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

int n,a[100050],ans=0;

bool cmp(int a,int b){return a>b;}

int main()

{

	scanf("%d",&n);

	for(int i=1;i<=n;i++)scanf("%d",&a[i]);

	sort(a+1,a+1+n,cmp);

	for(int i=1;i<=n;i++)if(i+1>a[i+1])

	{

		for(int j=i+1;a[j]==i;j++)ans^=1;

		ans|=(a[i]-i)&1;

		if(ans)printf("First");

		else printf("Second");

		return 0;

	}

}

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

#include<algorithm>

using namespace std;

int N,A[100010];

bool Cmp(const int &X,const int &Y){

	return X>Y;

}

int main(){

	scanf("%d",&N);

    for(int i=1;i<=N;i++){

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

	}

    sort(A+1,A+N+1,Cmp);

    /*

    for(int i=1;i<=N;i++){

    	printf("%d ",A[i]);

	}

	printf("\n");

	*/

    for(int i=1;i<=N;i++){

        if(i+1>A[i+1]){

            int Ans=0;

            for(int j=i+1;A[j]==i;j++){

            	Ans=Ans^1;

			}

            Ans=Ans|((A[i]-i)&1);

            if(Ans){

            	printf("First\n");

			}else{

				printf("Second\n");

			}

            return 0;

        }

    }

}
// Slower C++ solution:
#include <bits/stdc++.h>

#define res register int

#define N 100005

using namespace std;

int n,ans,a[100100];

inline int read()

{

  int X=0,w=0;

  char ch=0;

  while(!isdigit(ch))

  {

    w|=ch=='-';

    ch=getchar();

  }

  while(isdigit(ch)) X=(X<<3)+(X<<1)+(ch^48),ch=getchar();

  return w?-X:X;

}

inline bool cmp(int x,int y)

{

  return x>y;

}

int main()

{

  n=read();

  for(res i=1; i<=n; i++)

    a[i]=read();

  sort(a+1,a+n+1,cmp);

  for(res i=1; i<=n; i++)

    if(i+1>a[i+1])

    {

      for(res j=i+1; a[j]==i; j++) ans^=1;

      ans|=(a[i]-i)&1;

      puts(ans? "First":"Second");

      return 0;

    }

  return 0;

}

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

#include<algorithm>

using namespace std;

int N,A[100010];

bool Cmp(const int &X,const int &Y){

	return X>Y;

}

int main(){

	scanf("%d",&N);

    for(int i=1;i<=N;i++){

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

	}

    sort(A+1,A+N+1,Cmp);

    /*

    for(int i=1;i<=N;i++){

    	printf("%d ",A[i]);

	}

	printf("\n");

	*/

    for(int i=1;i<=N;i++){

        if(i+1>A[i+1]){

            int Ans=0;

            for(int j=i+1;A[j]==i;j++){

            	Ans=Ans^1;

			}

            Ans=Ans|((A[i]-i)&1);

            if(Ans){

            	printf("First\n");

			}else{

				printf("Second\n");

			}

            return 0;

        }

    }

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

int n,a[100010];

int main()

{

    cin>>n;

    for(int i=1;i<=n;++i)scanf("%d",a+i);

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

    reverse(a+1,a+n+1);

    for(int i=1;i<=n;++i){

        if(i+1>a[i+1]){

        	int ans=0;

            for(int j=i+1;a[j]==i;++j)ans^=1;

            ans|=(a[i]-i)&1;

            if(ans)puts("First");

            else puts("Second");

            return 0;

            

		}

	}

}

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

#include<algorithm>

using namespace std;

int N,A[100010];

bool Cmp(const int &X,const int &Y){

	return X>Y;

}

int main(){

	scanf("%d",&N);

    for(int i=1;i<=N;i++){

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

	}

    sort(A+1,A+N+1,Cmp);

    /*

    for(int i=1;i<=N;i++){

    	printf("%d ",A[i]);

	}

	printf("\n");

	*/

    for(int i=1;i<=N;i++){

        if(i+1>A[i+1]){

            int Ans=0;

            for(int j=i+1;A[j]==i;j++){

            	Ans=Ans^1;

			}

            Ans=Ans|((A[i]-i)&1);

            if(Ans){

            	printf("First\n");

			}else{

				printf("Second\n");

			}

            return 0;

        }

    }

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;



int a[100005];



int main(){

	int n,i,j,win=0;cin>>n;

	for(i=1;i<=n;++i) cin>>a[i];

	sort(a+1,a+n+1,greater<int>());

	for(i=1;i<=n;++i){

		if(a[i+1]<i+1 && a[i]>=i){

			j=i+1;

			while(a[j]==i) j++,win^=1;

			win|=((a[i]-i)&1);

			if(win) puts("First");

			else puts("Second");

		}

	}

}

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

#include<algorithm>

using namespace std;

int N,A[100010];

bool Cmp(const int &X,const int &Y){

	return X>Y;

}

int main(){

	scanf("%d",&N);

    for(int i=1;i<=N;i++){

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

	}

    sort(A+1,A+N+1,Cmp);

    /*

    for(int i=1;i<=N;i++){

    	printf("%d ",A[i]);

	}

	printf("\n");

	*/

    for(int i=1;i<=N;i++){

        if(i+1>A[i+1]){

            int Ans=0;

            for(int j=i+1;A[j]==i;j++){

            	Ans=Ans^1;

			}

            Ans=Ans|((A[i]-i)&1);

            if(Ans){

            	printf("First\n");

			}else{

				printf("Second\n");

			}

            return 0;

        }

    }

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

#define il inline

#define re register

#define debug printf("Now is Line : %d\n",__LINE__)

#define file(a) freopen(#a".in","r",stdin);freopen(#a".out","w",stdout)

//#define int long long

#define D double

#define inf 123456789

#define mod 1000000007

il int read() {

    re int x = 0, f = 1; re char c = getchar();

    while(c < '0' || c > '9') { if(c == '-') f = -1; c = getchar();}

    while(c >= '0' && c <= '9') x = x * 10 + c - 48, c = getchar();

    return x * f;

}

#define rep(i, s, t) for(re int i = s; i <= t; ++ i)

#define drep(i, s, t) for(re int i = t; i >= s; -- i)

#define Next(i, u) for(re int i = head[u]; i; i = e[i].next)

#define mem(k, p) memset(k, p, sizeof(k))

#define lb(x) (x)&(-(x))

#define ls k * 2

#define rs k * 2 + 1

#define maxn 100005

int n, m, a[maxn];

il bool cmp(int a, int b) {

	return a > b;

}

il int doit(int x, int y) {

	int ans = 0;

	while(a[x + 1] == y) ans ^= 1, ++ x;

	return ans;

}

int main() {

	//file(a);

	n = read();

	rep(i, 1, n) a[i] = read();

	sort(a + 1, a + n + 1, cmp);

	int nx = 0;

	while(1) {

		if(a[nx + 1] < nx + 1) break;

		++ nx;

	}

	if(((a[nx] - nx) & 1) || doit(nx, nx)) printf("First");

	else printf("Second");

	return 0;

}

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

#include<algorithm>

using namespace std;

int N,A[100010];

bool Cmp(const int &X,const int &Y){

	return X>Y;

}

int main(){

	scanf("%d",&N);

    for(int i=1;i<=N;i++){

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

	}

    sort(A+1,A+N+1,Cmp);

    /*

    for(int i=1;i<=N;i++){

    	printf("%d ",A[i]);

	}

	printf("\n");

	*/

    for(int i=1;i<=N;i++){

        if(i+1>A[i+1]){

            int Ans=0;

            for(int j=i+1;A[j]==i;j++){

            	Ans=Ans^1;

			}

            Ans=Ans|((A[i]-i)&1);

            if(Ans){

            	printf("First\n");

			}else{

				printf("Second\n");

			}

            return 0;

        }

    }

}
// Slower C++ solution:
#include<bits/stdc++.h>

#define bug puts("QWQ")

#define huan putchar('\n')

#define kong putchar(' ')

using namespace std;



inline void read(int  &x)

{

	int pd=1;

	register char ch=getchar();x=0;

	while(ch<'0'||ch>'9'){if(ch=='-')pd=-pd;ch=getchar();}

 	while(ch>='0'&&ch<='9'){x=(x*10+ch-'0');ch=getchar();}

 	x*=pd;

}



void write(int x)

{

	if(x<0)x=-x,putchar('-');

	if(x<10)putchar(x+'0');

	else write(x/10),putchar(x%10+'0');

}



inline void wrl(int x)

{

	write(x);

	puts("");

}



inline void wrs(int x)

{

	write(x);

	putchar(' ');

}



/*

¿¼ÂÇÃ»ÓÐÄÃ×ßÒ»¶ÑµÄ²Ù×÷£¬ÄÇÃ´ÏÈÊÖ±Ø°ÜµÄÌõ¼þÊÇMX(A[I])ÊÇÆæÊý



¿¼ÂÇÃ»ÓÐ¼õÒ»µÄ²Ù×÷£¬ÄÇÃ´ÏÈÊÖ±Ø°ÜµÄÌõ¼þÊÇNÊÇÆæÊý 

*/



const int N=1e5+233;

int n,a[N];

inline bool check()

{

    for(register int i=1;i<=n;++i)

    {

        if(a[i])return 1;

    }

    return 0;

}

bool dfs(int s)

{

    if(!check())

    {

        return 1;

    }

    

    bool flag=1;

    bool vis[20];

    memset(vis,0,sizeof(vis));

    for(register int i=1;i<=n;++i)

    {

        if(a[i])

        --a[i],vis[i]=1;

    }

    flag&=dfs(s+1);

    for(register int i=1;i<=n;++i)

    {

        if(vis[i])

        ++a[i],vis[i]=0;

    }

    int now;

    for(register int i=1;i<=n;++i)

    {

        if(a[i])

        {

            now=a[i];

            a[i]=0;

            flag&=dfs(s+1);

            a[i]=now;

            break;

        }

    }

    return flag^1;

}





int main()

{

//    freopen("t1.in","r",stdin);

//    freopen("t1.out","w",stdout);

	int T;

//	read(T);

//	while(T--)

	{

		memset(a,0,sizeof(a));

		read(n);

		for(register int i=1;i<=n;++i)

		{

			read(a[i]);

		}

		sort(a+1,a+n+1,greater<int> ());

		for(register int i=1;i<=n;++i)

		{

			if(i>=a[i+1])

			{

				int ans=0;

				for(register int j=i+1;a[j]==i;++j)ans^=1;

				if(ans||((a[i]-i)&1))puts("First");

				else puts("Second");

				break;

			}

		}

	}

    return 0;

}

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

#include<algorithm>

using namespace std;

int a[100001];

bool cmp(int a,int b)

{

	return a>b;

}

int main()

{

    int n;cin>>n;

    for(int i=1;i<=n;i++)

		cin>>a[i];

    sort(a+1,a+n+1,cmp);

    for(int i=1;i<=n;i++)

		if(i+1>a[i+1])

		{

			int sum=0;

			for(int j=i+1;a[j]==i;j++)

				sum++;

			if(sum%2||(a[i]-i)%2)cout<<"First";else cout<<"Second";

			return 0;

		}

}
// Slower C++ solution:
#define _CRT_SECURE_NO_WARNINGS

#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>

#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 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 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 = 1000 * 100 + 47;

const int MAX1 = 1000 * 100 + 47;



int A[MAX];



int main()

{

	//freopen("in.txt", "r", stdin);

	//freopen("out.txt", "w", stdout);

	ios::sync_with_stdio(false); cin.tie(0);

	int n;

	cin >> n;

	FOR(i, 0, n) cin >> A[i];

	sort(A, A + n);

	reverse(A, A + n);

	int x = 0, y = 1;

	FOR(i, 0, n + 1)

	{

		if (i + 1 > A[i])

		{

			x = i - 1;

			y = i;

			break;

		}

	}



	//cout << "*" << x << " " << y << endl;



	bool v1 = (A[x] - y + 1) % 2;

	int cnt = 0;

	FOR(i, x + 1, n)

	{

		cnt += A[i] == y;

	}



	//cout << "!!" << cnt << endl;

	bool v2 = (cnt + 1) % 2;

	//cout << "!!" << v1 << " " << v2 << endl;

	if (!v1 || !v2)

	{

		cout << "First" << endl;

		return 0;

	}



	cout << "Second" << endl;

}

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

#include <algorithm>



#define Int register int



const int MAXN = 1e5;

int n, a[MAXN + 5];



inline void Work () {

	scanf ( "%d", &n );

	for ( Int i = 1; i <= n; ++ i ) scanf ( "%d", &a[i] );

	std :: sort ( a + 1, a + n + 1, []( const int x, const int y ) { return x > y; } );

	for ( Int i = 1; i <= n; ++ i ) {

		if ( i + 1 > a[i + 1] ) {

			int du = a[i] - i, dr = 0;

			for ( ; a[i + dr + 1] == i; ++ dr );

			puts ( du & 1 || dr & 1 ? "First" : "Second" );

			break;

		}

	}

}



int main () {

	Work ();

	return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>



using namespace std;



int n,a[100010],ans;



int main()

{

	scanf("%d",&n);

	for(int i=1; i<=n; i++)

	{

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

	}

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

	reverse(a+1,a+n+1);

	for(int i=1; i<=n; i++)

	{

		if(i+1>a[i+1])

		{

			for(int j=i+1; a[j]==i; j++)ans^=1;

			ans|=(a[i]-i)&1;

			puts(ans?"First":"Second");

			return 0;

		}

	}

	return 0;

}

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

#include <algorithm>



#define Int register int



const int MAXN = 1e5;

int n, a[MAXN + 5];



inline void Work () {

	scanf ( "%d", &n );

	for ( Int i = 1; i <= n; ++ i ) scanf ( "%d", &a[i] );

	std :: sort ( a + 1, a + n + 1, []( const int x, const int y ) { return x > y; } );

	for ( Int i = 1; i <= n; ++ i ) {

		if ( i + 1 > a[i + 1] ) {

			int du = a[i] - i, dr = 0;

			for ( ; a[i + dr + 1] == i; ++ dr );

			puts ( du & 1 || dr & 1 ? "First" : "Second" );

			break;

		}

	}

}



int main () {

	Work ();

	return 0;

}