stablegradients/pie-gem5-bysrc huggingface dataset:
// Original C++ solution (slower):
/*======================

 * Author : ylsoi

 * Problem : AGC02E

 * Algorithm : SG

 * Time : 2018.6.2

 * ===================*/

#include<iostream>

#include<algorithm>

#include<cstring>

#include<cmath>

#include<cstdio>

#include<climits>

using namespace std;

void File(){

    freopen("AGC02E.in","r",stdin);

    freopen("AGC02E.out","w",stdout);

}

template<typename T>bool chkmax(T &_,T __){return _<__ ? (_=__,1) : 0;}

template<typename T>bool chkmin(T &_,T __){return _>__ ? (_=__,1) : 0;}

#define REP(i,a,b) for(register int i=a;i<=b;++i)

#define DREP(i,a,b) for(register int i=a;i>=b;--i)

#define MREP(i,x) for(register int i=beg[x];i;i=E[i].last)

#define mem(a) memset(a,0,sizeof(a))

#define inf INT_MAX

const int maxn=1e5+10;

int n,a[maxn],SG[1010][1010];

bool cmp(int _,int __){return _>__;}

bool judge(int x,int y){return x<=n && y<=a[x];}    

int main(){

    scanf("%d",&n);

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

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

    int px=1,py=1,step1=0,step2=0;

    while(judge(px+1,py+1))++px,++py;

    while(judge(px+step1,py))++step1;

    while(judge(px,py+step2))++step2;

    if(step1%2==0 || step2%2==0)puts("First");

    else puts("Second");

    return 0;

}


// Optimized solution to the same problem (faster):
#include <cstdio>

#include <algorithm>

#include <cctype>

using namespace std;

inline int read(int f = 1, int x = 0, char ch = ' ')

{

    while(!isdigit(ch = getchar())) if(ch == '-') f = -1;

    while(isdigit(ch)) x = x*10+ch-'0', ch = getchar();

    return f*x;

}

const int N = 2e5+5;

int n, a[N];

int main()

{

    n = read();

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

    sort(a+1, a+1+n); reverse(a+1, a+1+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 ^= 1;

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

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

            return 0;

        }

    return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
// https://blog.csdn.net/forever_shi/article/details/83189155 

#include<bits/stdc++.h>

using namespace std;

const int N=1e5+10;

int n,j,ans,a[N];

int main()

{

    scanf("%d",&n);

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

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

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

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

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

	{

    	j=i+1,ans=0; 

		while (a[j]==i) ans++,j++;

		if (ans%2==1 || (a[i]-i)%2==1) puts("First");

		else puts("Second");

		return 0;

    }

}

// Optimized solution to the same problem (faster):
#include <cstdio>

#include <algorithm>

#include <cctype>

using namespace std;

inline int read(int f = 1, int x = 0, char ch = ' ')

{

    while(!isdigit(ch = getchar())) if(ch == '-') f = -1;

    while(isdigit(ch)) x = x*10+ch-'0', ch = getchar();

    return f*x;

}

const int N = 2e5+5;

int n, a[N];

int main()

{

    n = read();

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

    sort(a+1, a+1+n); reverse(a+1, a+1+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 ^= 1;

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

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

            return 0;

        }

    return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>



using namespace std;



bool cmp(int a,int b) {

    return a>b;

}

int x[100010];



int main() {

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

    int n;

    cin>>n;

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

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

    }

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

    int i;

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

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

    }

    int sg=0;

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

        sg^=1;

    sg|=(x[i]-i)&1;

    if(sg)

        cout<<"First"<<endl;

    else

        cout<<"Second"<<endl;



    return 0;

}


// Optimized solution to the same problem (faster):
#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;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
// In the name of God 

#include <bits/stdc++.h>



using namespace std ;





#define int long long

#define all(v) v.begin() , v.end()



template<typename T> inline bool smin(T &a, const T &b){ return b < a ? a = b,1:0;}

template<typename T> inline bool smax(T &a, const T &b){ return a < b ? a = b,1:0;}



const int N = ( int ) 1e5 + 10 ;



int n , a [ N ] ; 



int32_t main()

{

	ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);

	cin >> n ;

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

		cin >> a [ i ] ;

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

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

	int id = 0 ;

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

		if ( a [ j ] >= j )

			id = j ;

	//cout << id << '\n' ; 

	int res = 0 , rem = a [ id ] - id + 1 ;

	res |= rem % 2 == 0 ;

	int found = 0 ; 

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

		if ( a [ i ] >= id ) {

			found = i ; 

		}

	}

	//cout << rem << ' ' << found << '\n' ; 

	if ( found ) 

		res |= ( found - id + 1 ) % 2 == 0 ;

	cout << ( res ? "First" : "Second" ) << '\n' ; 

}


// Optimized solution to the same problem (faster):
#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;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

using namespace std ;



const int MAXN = 1e5 + 100 ; 



int n , a[MAXN] ; 



int main()

{

	cin >> n ; 

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

		cin >> a[i] ;

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

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

	int pos = 1 ;  

	for(;pos<=n ; pos++)

		if(a[pos]<pos)

			break ; 

	pos-- ; 

//	cout << pos << endl ; 

	int pos2 = pos ; 

	for(;pos2<=n ; pos2++)

		if(a[pos2] < pos)

			break ; 

	pos2--;

//	cout << pos2 << endl ; 

	cout << ( ((pos2-pos)%2||(a[pos]-pos)%2) ? "First" : "Second" )<< endl ; 

	

}

// Optimized solution to the same problem (faster):
#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;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;}

// Optimized solution to the same problem (faster):
#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;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#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");

}

// Optimized solution to the same problem (faster):
#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;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;

}

// Optimized solution to the same problem (faster):
#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;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;

            

		}

	}

}

// Optimized solution to the same problem (faster):
#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;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;

}

// Optimized solution to the same problem (faster):
#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;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;

}

// Optimized solution to the same problem (faster):
#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;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;

}


// Optimized solution to the same problem (faster):
#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;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
/*

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;

}


// Optimized solution to the same problem (faster):
#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;

        }

    }

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;

	}

}

// Optimized solution to the same problem (faster):
#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;

        }

    }

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;

}

// Optimized solution to the same problem (faster):
#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;

        }

    }

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;

            

		}

	}

}

// Optimized solution to the same problem (faster):
#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;

        }

    }

}

// Fastest known solution for this problem: