stablegradients/pie-gem5-bysrc huggingface dataset:
// Original C++ solution (slower):
#include<bits/stdc++.h>

 

#define MAXN 100000

 

int v[MAXN+1];

 

bool cmp(const int &a, const int &b){

    return a>b;

}

 

int main(){

    int n;

    scanf("%d", &n);

 

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

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

 

    std::sort(v+1, v+n+1, cmp);

 

    int p=1;

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

        if(v[i]>=i)

            p=i;

 

    p--;

 

    int q=p+1;

    for(int i=p+2; i<=n; i++)

        if(v[i]>p)

            q=i;

 

    if((q-p)%2+(v[p+1]-p)%2==2) printf("Second\n");

    else printf("First\n");

 

    return 0;

}

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

#include<cstring>

#include<algorithm>

using namespace std;

int n,ans,a[100100];

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;

           }    

    }    

}

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

#define ll long long

using namespace std;

const int N=100005;



int a[N],n;

bool sg;



inline void solve(){

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

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

		sg|=(a[i]-i)&1,puts(sg?"First":"Second");

		break;

	}

}



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);

	

	solve();

	

	return 0;

}

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

#include<cstring>

#include<algorithm>

using namespace std;

int n,ans,a[100100];

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;

           }    

    }    

}

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

using namespace std;

int n,a[100005];

int main() {

	scanf("%d",&n);

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

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

	int p=1;

	while (p<n&&a[p+1]>=p+1) ++p;

	int q=p;

	while (q<n&&a[q+1]==p) ++q;

	if ((q-p&1)||(a[p]-p&1)) puts("First");

	else puts("Second");

}

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

#include<cstring>

#include<algorithm>

using namespace std;

int n,ans,a[100100];

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;

           }    

    }    

}

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



#define f first 

#define s second 

#define pb push_back               

#define mp make_pair 



using namespace std;                    



typedef long long ll;

typedef pair<int, int> pii;

typedef pair<long long, long long> pll;



const int N = (int)1e5 + 123, mod = (int)1e9 + 7;

int n, a[N], dp[100][100], was[100][100];

int get(int i,int j){

	if(was[i][j])

		return dp[i][j];

	was[i][j] = 1;

	if(a[i] <= j){

		dp[i][j] = 1;

		return dp[i][j];

	}

	if(i > 0)

		get(i - 1, j);

	get(i, j + 1);	

	if(i > 0 && dp[i - 1][j] == 0)

		dp[i][j] = 1;

	if(dp[i][j + 1] == 0)

		dp[i][j] = 1;

	return dp[i][j];

}

int main(){

	srand(time(0));



	n = 6;



	cin >> n;

	

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

		//a[i] = rand()%10 + 1 ;

		cin >> a[i];



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

	

	int ans = 0;

	for(int i = n; i >= 0; i--){

		int x = n - i;

        if(x < a[i]){

			ans = a[i] - x + 1;

			//cerr << i << " " << x << " "<< a[i] << endl;

		}

        if(x == a[i]){

			int z = 0;

			for(int j = 0; j <= i; j++)

            	if(a[j] == a[i])

          	       	z++;

			if( (z % 2 == 0) && a[i] < a[i + 1] ){

				if( (a[i + 1] - a[i])&1 )

					ans = z + 1;

				else

					ans = z;		 

			}else

				ans = z;



		}

	}

	ans&=1;

	

	//cout << ans << endl;

    

    if(ans == 1)                    

		cout << "First" << endl;

    else

    	cout << "Second" << endl;

	

	return 0;

	cout << get(n,0) << endl;

	//return 0;

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

		for(int j = 0; j <= 20; j++){

			if(a[i] == j)

				cout<<"%";

            else

            	cout<<get(i,j);

		}

		cout<<endl;

	}

	return 0;

}


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

#include<cstring>

#include<algorithm>

using namespace std;

int n,ans,a[100100];

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;

           }    

    }    

}

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

using namespace std;

int n,m,i,j,a[100005],ans;

int main()

{

	cin>>n;

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

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

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

	for (i=0;i<n&&i<a[i+1];i++);

	bool f=(a[i]-i+1)&1,g=1;

	for (j=i+1;j<=n;j++) if (a[j]>=i) g^=1;

	if (f&&g) cout<<"Second"; else cout<<"First";

	return 0;

}

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

#include<algorithm>

using namespace std;

int n,a[100005];

inline bool cmp(int a,int b){

    return a>b;

}

int main(){

    int dis1=0,dis2=0;

    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(a[i+1]<i+1){

            dis1=a[i]-i;

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

                if(a[j]==i){

                    dis2++;

                }else{

                    break;

                }

            }

            break;

        }

    }

    dis1&=1,dis2&=1;

    printf("%s\n",!(dis1+dis2)?"Second":"First");

    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>

using namespace std;

int n,a[100005];

inline bool cmp(int a,int b){

    return a>b;

}

int main(){

    int dis1=0,dis2=0;

    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(a[i+1]<i+1){

            dis1=a[i]-i;

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

                if(a[j]==i){

                    dis2++;

                }else{

                    break;

                }

            }

            break;

        }

    }

    dis1&=1,dis2&=1;

    printf("%s\n",!(dis1+dis2)?"Second":"First");

    return 0;

}

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

using namespace std;

const int maxn=100000+10;

int n,a[maxn],ans;

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]){

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

				ans^=1;

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

			if(ans&1) printf("First\n");

			else printf("Second\n");

			return 0;

		}

	}

}

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

#include<algorithm>

using namespace std;

int n,a[100005];

inline bool cmp(int a,int b){

    return a>b;

}

int main(){

    int dis1=0,dis2=0;

    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(a[i+1]<i+1){

            dis1=a[i]-i;

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

                if(a[j]==i){

                    dis2++;

                }else{

                    break;

                }

            }

            break;

        }

    }

    dis1&=1,dis2&=1;

    printf("%s\n",!(dis1+dis2)?"Second":"First");

    return 0;

}

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



using namespace std;



#ifdef Lin1043

    #define DEBUG(msg, ...) printf("(%s #%d) " msg, __FUNCTION__, __LINE__, __VA_ARGS__)

    #define massert(...) assert(...)

#else

    #define DEBUG(...)

    #define massert(...)

#endif



#define rep(i , l , r) for(int i = (l) , ___ = (r) ; i <= ___ ; ++i )

#define per(i , r , l) for(int i = (r) , ___ = (l) ; i >= ___ ; --i )



struct iopener

{

    iopener()

    {

#ifdef Lin1043

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

#endif

    }

} iop;



typedef long long LL;



template<typename T>inline bool chkmin(T &x , const T &y) { return x > y ? (x = y , 1) : 0; }

template<typename T>inline bool chkmax(T &x , const T &y) { return x < y ? (x = y , 1) : 0; }



template<typename T>inline T read(T &f)

{

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

    while(!isdigit(c)) x = (c == '-' ? -1 : 1) , c = getchar();

    while(isdigit(c)) (f *= 10) += c & 15 , c = getchar();

    return f = x * f;

}



const int N = 100000 + 5;



int n , A[N];



#ifdef Lin1043

namespace TEST

{

    const int M = 200 + 5;



    int f[M][M] , g[M][M];



    int solve(int x , int y)

    {

        if(g[x][y])

            return 0;

        if(f[x][y] != -1)

            return f[x][y];

        int now = 0;

        if(solve(x + 1 , y) == 0)

            now = 1;

        if(solve(x , y + 1) == 0)

            now = 1;

        return f[x][y] = now;

    }

}

#endif 



int comp(int x , int y)

{

    return x > y;

}



int main()

{

    read(n);

    rep(i , 1 , n) read(A[i]);

    sort(A + 1 , A + 1 + n , comp);

#ifdef Lin1043

    rep(i , 1 , n)

        TEST::g[i][A[i]] = 1;

    memset(TEST::f , -1 , sizeof TEST::f);

    TEST::solve(1 , 0);

    cout << TEST::f[1][0] << endl;

#endif

    rep(i , 1 , n) if(i + 1 > A[i + 1])

    {

        int Ans = 0;

        rep(j , i + 1 , n)

        {

            if(A[j] != i) break;

            Ans ^= 1;

        }

        Ans |= (A[i] - i) % 2;

        if(Ans)

            puts("First");

        else

            puts("Second");

        break ;

    }

    return 0;

}




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

#include<algorithm>

using namespace std;

int n,a[100005];

inline bool cmp(int a,int b){

    return a>b;

}

int main(){

    int dis1=0,dis2=0;

    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(a[i+1]<i+1){

            dis1=a[i]-i;

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

                if(a[j]==i){

                    dis2++;

                }else{

                    break;

                }

            }

            break;

        }

    }

    dis1&=1,dis2&=1;

    printf("%s\n",!(dis1+dis2)?"Second":"First");

    return 0;

}

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

#define res register int

#define ll long long

#define inf 0x3f3f3f3f

#define N 100050

using namespace std;

int a[N],n,m,tot,ans;

inline bool cmp(res x,res y)

{

	return x>y;

}

int main()

{

	scanf("%d",&n);

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

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

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

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

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

                res j=i+1,ans=0;

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

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

                else puts("Second");

                return 0;

            }

}

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

#include<algorithm>

using namespace std;

int n,a[100005];

inline bool cmp(int a,int b){

    return a>b;

}

int main(){

    int dis1=0,dis2=0;

    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(a[i+1]<i+1){

            dis1=a[i]-i;

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

                if(a[j]==i){

                    dis2++;

                }else{

                    break;

                }

            }

            break;

        }

    }

    dis1&=1,dis2&=1;

    printf("%s\n",!(dis1+dis2)?"Second":"First");

    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()

{

	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])

		{

			int ji=i+1,pd=0;

			while(a[ji]==i)

			{

				pd^=1;

				++ji; 

			} 

			if(pd||(a[i]-i)%2==1)

			printf("First\n");

			else

			printf("Second\n");

			break;

		}

	}

	return 0;

}

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

#include<algorithm>

using namespace std;

int n,a[100005];

inline bool cmp(int a,int b){

    return a>b;

}

int main(){

    int dis1=0,dis2=0;

    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(a[i+1]<i+1){

            dis1=a[i]-i;

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

                if(a[j]==i){

                    dis2++;

                }else{

                    break;

                }

            }

            break;

        }

    }

    dis1&=1,dis2&=1;

    printf("%s\n",!(dis1+dis2)?"Second":"First");

    return 0;

}

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

using namespace std;

const int N=100009;

int n,a[N],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;

} 

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

#include<algorithm>

using namespace std;

int n,a[100005];

inline bool cmp(int a,int b){

    return a>b;

}

int main(){

    int dis1=0,dis2=0;

    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(a[i+1]<i+1){

            dis1=a[i]-i;

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

                if(a[j]==i){

                    dis2++;

                }else{

                    break;

                }

            }

            break;

        }

    }

    dis1&=1,dis2&=1;

    printf("%s\n",!(dis1+dis2)?"Second":"First");

    return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

#include <cstdio>

#include <cctype>

#include <algorithm>

#define il inline

#define vd void

#define rg register

#define rep(i,x,y) for(rg int i=x;i<=y;++i)

#define drp(i,x,y) for(rg int i=x;i>=y;--i)

using namespace std;

const int Len=2333333;

char buf[Len],*p1=buf,*p2=buf,duf[Len],*q1=duf;

il char gc(); il int rd(); il vd pc(char c); il vd rt(int x); il vd flush();

int n,a[100005];

int main(){

    n=rd();

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

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

    int i=n,j=1;

    while(a[i-1]>=j+1) --i,++j;

    int k=i;

    while(a[k-1]==j) --k;

    puts(((i-k)&1)||((a[i]-j)&1)?"First":"Second");

    return flush(),0;

}



il char gc(){return p1==p2&&(p2=(p1=buf)+fread(buf,1,Len,stdin),p1==p2)?-1:*p1++;}

il int rd(){char c;

    while(!isdigit(c=gc())&&c!='-');

    int f=c=='-'?c=gc(),1:0,x=c^48;

    while(isdigit(c=gc())) x=((x+(x<<2))<<1)+(c^48);

    return f?-x:x;

}

il vd pc(char c){q1==duf+Len&&fwrite(q1=duf,1,Len,stdout),*q1++=c;}

il vd rt(int x){x<0?pc('-'),x=-x:0,pc((x>=10?rt(x/10),x%10:x)+48);}

il vd flush(){fwrite(duf,1,q1-duf,stdout);}

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

#include<algorithm>

using namespace std;

int n,a[100005];

inline bool cmp(int a,int b){

    return a>b;

}

int main(){

    int dis1=0,dis2=0;

    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(a[i+1]<i+1){

            dis1=a[i]-i;

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

                if(a[j]==i){

                    dis2++;

                }else{

                    break;

                }

            }

            break;

        }

    }

    dis1&=1,dis2&=1;

    printf("%s\n",!(dis1+dis2)?"Second":"First");

    return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

#include <cstdlib>

#include <cstring>

#include <cstdio>

#include <algorithm>



using namespace std;



const int N = 100010;



int a[N];



int main()

{	int n;

	scanf("%d", &n);

	int Max = 0;

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

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

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

	int p = 1;

	while (p <= n && p <= a[p])

		p++;

	p--;

	int x = 1;

	while (p+x <= n && a[p+x] == p)

		x++;

	x--;

	if (((a[p]-p) & 1) || (x & 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<iostream>

#include<cstdio>

#include<algorithm>

using namespace std;

#define MAX 100100

inline int read()

{

	int x=0;bool t=false;char ch=getchar();

	while((ch<'0'||ch>'9')&&ch!='-')ch=getchar();

	if(ch=='-')t=true,ch=getchar();

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

	return t?-x:x;

}

int n,a[MAX],ans;

int main()

{

	n=read();

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

	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;

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

			return 0;

		}

	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;

int n,a[100010];

bool cmp(int a,int b)

{

    return a>b;

}

int main()

{

    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(a[i+1]<i+1)

		{

            int ans=0;

            for(int j=i+1;;j++)

            {

                if(a[j]!=i)

                    break;

                ans^=1;

            }

				

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

            if(ans)

				cout<<"First"<<endl;

            else 

				cout<<"Second"<<endl;

            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;

#define reg register

#define ll long long

inline ll read()

{

    ll x=0,w=0;char ch=getchar();

    while(!isdigit(ch))w|=ch=='-',ch=getchar();

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

    return w?-x:x;

}

bool com(ll x,ll y){return x>y;}

ll n,a[100005];

int main()

{

    n=read();

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

		a[i]=read();

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

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

	{

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

		{

			ll j=i+1,an=0;

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

			an%=2;

			if(an||((a[i]-i)&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: