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

using namespace std;



#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);

#define debug(a) cerr << #a << ": " << a << endl

#define endl '\n'

#define int long long



const int N = 1e5+5;



int  n, k;

int a[N];

int cache[N];



int dp(int curr)

{

      int &res = cache[curr];

      if(res != -1) return res;



      res =0;

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

      {

            int rem = curr - a[i];

            if(rem<0) break;

            res |= (dp(rem)==0);

      }

      return res;

}





int32_t main()

{

      IOS;



      cin>>n>>k;

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



      memset(cache, -1, sizeof cache);



      if(dp(k)) cout<<"First"<<endl;

      else cout<<"Second"<<endl;



      return 0;

}






// Faster C++ solution for the same problem (measured speedup: 1.6531084104525418x):
#include <bits/stdc++.h>

#define eps 1e-3

#define pi acos(-1.0)

#define inf 0x3f

#define INF 0x3f3f3f3f

#define pb push_back

#define debug1 cout<<"&&";

#define debug2 cout<<"**";

#define ms(a, x) memset(a, x, sizeof(a))

#define for0(i, n) for(int i = 0; i < n; ++i)

#define for1(i, n) for(int i = 1; i <= n; ++i)

using namespace std;

typedef double db;

typedef long long ll;

typedef unsigned long long ull;

typedef pair<int, int> pii;

typedef pair<long long, int> pli;

typedef pair<long long, long long> pll;

const int mod = 1e9 + 7;

const int N = 1e5+10;

const int M = 1e6+10;

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



int n, k, a[200], dp[N][2], p;



bool dfs(int num, int person) {

   if(dp[num][person]) return dp[num][person];

   int ans=0;

   for1(i, n) {

      if(a[i] <= num) ans |= !dfs(num - a[i], person^1);

   }

   dp[num][person] = ans;

   return ans;

}





int main() {

   scanf("%d %d", &n, &k);

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

   bool ans = dfs(k, 1);

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

   return 0;

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

using namespace std;



typedef long long int ll;





int dp[100010];

int arr[100010];

int n;



int go(int val){

    if(val == 0)    return 0;

    if(dp[val] != -1)   return dp[val];

    int pos = 0;

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

        if(val >= arr[i]){

            int tval = go(val-arr[i]);

            if(tval == 0){

                pos = 1;

            }

        }

    }

    return dp[val] = pos;

}

int main(){

    memset(dp,-1,sizeof dp);

    int k;

    scanf("%d %d",&n,&k);

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

        scanf("%d",arr+i);

    }

    int ans = go(k);

    if(ans == 0){

        printf("Second\n");

    }

    else{

        printf("First\n");

    }

    //printf("%.10f\n",ans);

}


// Faster C++ solution for the same problem (measured speedup: 1.461536845307976x):
#define IOS ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);

#include<bits/stdc++.h>  

#define endl "\n"

using namespace std;

	typedef long long ll;

	const int maxn=100050;

	const int inf=0x3f3f3f3f;

	int dp[maxn];

	int a[105];

	int n,m;

	

	int main(){

		IOS

		cin>>n>>m;

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

			cin>>a[i];

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

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

			bool b=0;

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

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

					b=1;

					dp[i]=1;

					break;

				}

			}

			if(!b)

				dp[i]=0;

		}

		map<int,string>mp;

		mp[1]="First";

		mp[0]="Second";

		cout<<mp[dp[m]];

		return 0;

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

using namespace std;

int arr[200],dp[200000],n,k;



int stone(int a){

	if(a == 0) return 2;

	if(dp[a] != 0) return dp[a];

	else{

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

			if(arr[i] > a) break;

			if(stone(a - arr[i]) == 2){

				dp[a] = 1;

				break;

			}

		}

		if(dp[a] == 0) dp[a] = 2;

	}

	

	return dp[a];

}

int main (){

	memset(dp,0,sizeof dp);

	cin >> n >> k;

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

		cin >> arr[i]; 

	}

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

	

	int ans = stone(k);

	

	if(ans == 1)cout << "First" << endl;

	else cout << "Second" << endl;

}

// Faster C++ solution for the same problem (measured speedup: 1.8350521993467974x):
#define IOS ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);

#include<bits/stdc++.h>  

#define endl "\n"

using namespace std;

	typedef long long ll;

	const int maxn=100050;

	const int inf=0x3f3f3f3f;

	int dp[maxn];

	int a[105];

	int n,m;

	

	int main(){

		IOS

		cin>>n>>m;

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

			cin>>a[i];

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

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

			bool b=0;

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

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

					b=1;

					dp[i]=1;

					break;

				}

			}

			if(!b)

				dp[i]=0;

		}

		map<int,string>mp;

		mp[1]="First";

		mp[0]="Second";

		cout<<mp[dp[m]];

		return 0;

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

#include <ext/numeric>



using namespace std;

using namespace __gnu_cxx;



#define sz(v)           ((int)((v).size()))

#define clr(v, d)       memset(v, d, sizeof(v))

#define rep(i, v)       for(int i=0; i<sz(v); ++i)

#define lp(i, n)        for(int i=0; i<(int)(n); ++i)

#define lpi(i, j, n)    for(int i=(j); i<(int)(n); ++i)

#define lpd(i, j, n)    for(int i=(j); i>=(int)(n); --i)

//#define INF             1000000000

//#define INF             100000000000000



typedef long long ll;

typedef pair<int, int> ii;

typedef vector<ii> vii;

typedef vector<int> vi;



void init(){

	std::ios_base::sync_with_stdio(false);

	cin.tie(NULL);

	cout.tie(NULL);

}



const int N = 1e5+5;

const int M = 104;



int dp[N][2];



int arr[M];



int n, k;



bool solve(int cur_k, bool turn){

	if(cur_k < 0)

		return turn;

	int & cur = dp[cur_k][turn];

	if(cur != -1)

		return cur;

	lp(i, n)

		if(solve(cur_k - arr[i], !turn) == turn)

			return (cur = turn);

	return (cur = !turn);

}



int main()

{

	clr(dp, -1);

	cin >> n >> k;

	lp(i, n)

		cin >> arr[i];

	cout << (solve(k, 0)?"Second":"First");

	return 0;

}


// Faster C++ solution for the same problem (measured speedup: 1.8172759734564783x):
#define IOS ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);

#include<bits/stdc++.h>  

#define endl "\n"

using namespace std;

	typedef long long ll;

	const int maxn=100050;

	const int inf=0x3f3f3f3f;

	int dp[maxn];

	int a[105];

	int n,m;

	

	int main(){

		IOS

		cin>>n>>m;

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

			cin>>a[i];

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

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

			bool b=0;

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

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

					b=1;

					dp[i]=1;

					break;

				}

			}

			if(!b)

				dp[i]=0;

		}

		map<int,string>mp;

		mp[1]="First";

		mp[0]="Second";

		cout<<mp[dp[m]];

		return 0;

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



using namespace std;

typedef long long ll;

typedef unsigned long long ull;

typedef double dd;

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

#define endl "\n"

#define clr(n, r) memset(n,r,sizeof(n));



void fast() {

    cin.tie(0);

    cin.sync_with_stdio(0);

}











int main() {

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

int arr[n];

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

        cin>>arr[i];

    }

    int dp[100009];

    clr(dp,0);

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

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

            if (arr[i] <= j) {

                if (!dp[j - arr[i]]) {

                        dp[j] = 1;

                        break;

                    }

                }

            }

        }

    cout<<(dp[k]?"First":"Second");

}

// Faster C++ solution for the same problem (measured speedup: 1.351872789050465x):
#define IOS ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);

#include<bits/stdc++.h>  

#define endl "\n"

using namespace std;

	typedef long long ll;

	const int maxn=100050;

	const int inf=0x3f3f3f3f;

	int dp[maxn];

	int a[105];

	int n,m;

	

	int main(){

		IOS

		cin>>n>>m;

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

			cin>>a[i];

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

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

			bool b=0;

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

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

					b=1;

					dp[i]=1;

					break;

				}

			}

			if(!b)

				dp[i]=0;

		}

		map<int,string>mp;

		mp[1]="First";

		mp[0]="Second";

		cout<<mp[dp[m]];

		return 0;

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

using namespace std;



#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);

#define debug(a) cerr << #a << ": " << a << endl

#define endl '\n'

#define int long long



const int N = 1e5+5;



int  n, k;

int a[N];

int cache[N];



int dp(int curr)

{

      int &res = cache[curr];

      if(res != -1) return res;



      res =0;

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

      {

            int rem = curr - a[i];

            if(rem<0) break;

            res |= (dp(rem)==0);

      }

      return res;

}





int32_t main()

{

      IOS;



      cin>>n>>k;

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



      memset(cache, -1, sizeof cache);



      if(dp(k)) cout<<"First"<<endl;

      else cout<<"Second"<<endl;



      return 0;

}






// Faster C++ solution for the same problem (measured speedup: 1.840192068399142x):
#define IOS ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);

#include<bits/stdc++.h>  

#define endl "\n"

using namespace std;

	typedef long long ll;

	const int maxn=100050;

	const int inf=0x3f3f3f3f;

	int dp[maxn];

	int a[105];

	int n,m;

	

	int main(){

		IOS

		cin>>n>>m;

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

			cin>>a[i];

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

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

			bool b=0;

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

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

					b=1;

					dp[i]=1;

					break;

				}

			}

			if(!b)

				dp[i]=0;

		}

		map<int,string>mp;

		mp[1]="First";

		mp[0]="Second";

		cout<<mp[dp[m]];

		return 0;

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

using namespace std;



typedef long long int ll;





int dp[100010];

int arr[100010];

int n;



int go(int val){

    if(val == 0)    return 0;

    if(dp[val] != -1)   return dp[val];

    int pos = 0;

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

        if(val >= arr[i]){

            int tval = go(val-arr[i]);

            if(tval == 0){

                pos = 1;

            }

        }

    }

    return dp[val] = pos;

}

int main(){

    memset(dp,-1,sizeof dp);

    int k;

    scanf("%d %d",&n,&k);

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

        scanf("%d",arr+i);

    }

    int ans = go(k);

    if(ans == 0){

        printf("Second\n");

    }

    else{

        printf("First\n");

    }

    //printf("%.10f\n",ans);

}


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

const int MAX_N = 305;

bool dp[10000025][2];//dp[i][j]代表还剩i个石头，当前为k进行操作时会输还是会赢，0代表第一个人first，1代表第二个人second 

int arr[MAX_N],n;

bool dfs(int k,int t)

{

	//初始条件为dp[0][0]=0,dp[0][1]=0 

    if(dp[k][t]>0)

	  return dp[k][t];

    bool ans=0;

    for(int i=1;i<=n;++i)//遍历n个可以移除石子的数量 

      if(k>=arr[i])//只要当前剩余石子数量大于可以移除石子的数量 

	    ans|=!dfs(k-arr[i],!t);//若上一状态对手赢(1)，则当前状态自己输(0)，上一状态对手输(0)则当前状态自己赢(1)

        //这里用或运算，因为只要有能赢的情况就会选择能赢的情况 

	return dp[k][t]=ans;

}

int main()

{

    int k;

    scanf("%d%d",&n,&k);

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

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

    if(dfs(k,0)==false)

	  printf("Second\n");

    else printf("First\n");

    return 0;

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

using namespace std;

int arr[200],dp[200000],n,k;



int stone(int a){

	if(a == 0) return 2;

	if(dp[a] != 0) return dp[a];

	else{

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

			if(arr[i] > a) break;

			if(stone(a - arr[i]) == 2){

				dp[a] = 1;

				break;

			}

		}

		if(dp[a] == 0) dp[a] = 2;

	}

	

	return dp[a];

}

int main (){

	memset(dp,0,sizeof dp);

	cin >> n >> k;

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

		cin >> arr[i]; 

	}

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

	

	int ans = stone(k);

	

	if(ans == 1)cout << "First" << endl;

	else cout << "Second" << endl;

}

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

const int MAX_N = 305;

bool dp[10000025][2];//dp[i][j]代表还剩i个石头，当前为k进行操作时会输还是会赢，0代表第一个人first，1代表第二个人second 

int arr[MAX_N],n;

bool dfs(int k,int t)

{

	//初始条件为dp[0][0]=0,dp[0][1]=0 

    if(dp[k][t]>0)

	  return dp[k][t];

    bool ans=0;

    for(int i=1;i<=n;++i)//遍历n个可以移除石子的数量 

      if(k>=arr[i])//只要当前剩余石子数量大于可以移除石子的数量 

	    ans|=!dfs(k-arr[i],!t);//若上一状态对手赢(1)，则当前状态自己输(0)，上一状态对手输(0)则当前状态自己赢(1)

        //这里用或运算，因为只要有能赢的情况就会选择能赢的情况 

	return dp[k][t]=ans;

}

int main()

{

    int k;

    scanf("%d%d",&n,&k);

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

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

    if(dfs(k,0)==false)

	  printf("Second\n");

    else printf("First\n");

    return 0;

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

#include <ext/numeric>



using namespace std;

using namespace __gnu_cxx;



#define sz(v)           ((int)((v).size()))

#define clr(v, d)       memset(v, d, sizeof(v))

#define rep(i, v)       for(int i=0; i<sz(v); ++i)

#define lp(i, n)        for(int i=0; i<(int)(n); ++i)

#define lpi(i, j, n)    for(int i=(j); i<(int)(n); ++i)

#define lpd(i, j, n)    for(int i=(j); i>=(int)(n); --i)

//#define INF             1000000000

//#define INF             100000000000000



typedef long long ll;

typedef pair<int, int> ii;

typedef vector<ii> vii;

typedef vector<int> vi;



void init(){

	std::ios_base::sync_with_stdio(false);

	cin.tie(NULL);

	cout.tie(NULL);

}



const int N = 1e5+5;

const int M = 104;



int dp[N][2];



int arr[M];



int n, k;



bool solve(int cur_k, bool turn){

	if(cur_k < 0)

		return turn;

	int & cur = dp[cur_k][turn];

	if(cur != -1)

		return cur;

	lp(i, n)

		if(solve(cur_k - arr[i], !turn) == turn)

			return (cur = turn);

	return (cur = !turn);

}



int main()

{

	clr(dp, -1);

	cin >> n >> k;

	lp(i, n)

		cin >> arr[i];

	cout << (solve(k, 0)?"Second":"First");

	return 0;

}


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

const int MAX_N = 305;

bool dp[10000025][2];//dp[i][j]代表还剩i个石头，当前为k进行操作时会输还是会赢，0代表第一个人first，1代表第二个人second 

int arr[MAX_N],n;

bool dfs(int k,int t)

{

	//初始条件为dp[0][0]=0,dp[0][1]=0 

    if(dp[k][t]>0)

	  return dp[k][t];

    bool ans=0;

    for(int i=1;i<=n;++i)//遍历n个可以移除石子的数量 

      if(k>=arr[i])//只要当前剩余石子数量大于可以移除石子的数量 

	    ans|=!dfs(k-arr[i],!t);//若上一状态对手赢(1)，则当前状态自己输(0)，上一状态对手输(0)则当前状态自己赢(1)

        //这里用或运算，因为只要有能赢的情况就会选择能赢的情况 

	return dp[k][t]=ans;

}

int main()

{

    int k;

    scanf("%d%d",&n,&k);

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

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

    if(dfs(k,0)==false)

	  printf("Second\n");

    else printf("First\n");

    return 0;

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



using namespace std;

typedef long long ll;

typedef unsigned long long ull;

typedef double dd;

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

#define endl "\n"

#define clr(n, r) memset(n,r,sizeof(n));



void fast() {

    cin.tie(0);

    cin.sync_with_stdio(0);

}











int main() {

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

int arr[n];

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

        cin>>arr[i];

    }

    int dp[100009];

    clr(dp,0);

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

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

            if (arr[i] <= j) {

                if (!dp[j - arr[i]]) {

                        dp[j] = 1;

                        break;

                    }

                }

            }

        }

    cout<<(dp[k]?"First":"Second");

}

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

const int MAX_N = 305;

bool dp[10000025][2];//dp[i][j]代表还剩i个石头，当前为k进行操作时会输还是会赢，0代表第一个人first，1代表第二个人second 

int arr[MAX_N],n;

bool dfs(int k,int t)

{

	//初始条件为dp[0][0]=0,dp[0][1]=0 

    if(dp[k][t]>0)

	  return dp[k][t];

    bool ans=0;

    for(int i=1;i<=n;++i)//遍历n个可以移除石子的数量 

      if(k>=arr[i])//只要当前剩余石子数量大于可以移除石子的数量 

	    ans|=!dfs(k-arr[i],!t);//若上一状态对手赢(1)，则当前状态自己输(0)，上一状态对手输(0)则当前状态自己赢(1)

        //这里用或运算，因为只要有能赢的情况就会选择能赢的情况 

	return dp[k][t]=ans;

}

int main()

{

    int k;

    scanf("%d%d",&n,&k);

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

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

    if(dfs(k,0)==false)

	  printf("Second\n");

    else printf("First\n");

    return 0;

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

using namespace std;



#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);

#define debug(a) cerr << #a << ": " << a << endl

#define endl '\n'

#define int long long



const int N = 1e5+5;



int  n, k;

int a[N];

int cache[N];



int dp(int curr)

{

      int &res = cache[curr];

      if(res != -1) return res;



      res =0;

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

      {

            int rem = curr - a[i];

            if(rem<0) break;

            res |= (dp(rem)==0);

      }

      return res;

}





int32_t main()

{

      IOS;



      cin>>n>>k;

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



      memset(cache, -1, sizeof cache);



      if(dp(k)) cout<<"First"<<endl;

      else cout<<"Second"<<endl;



      return 0;

}






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

const int MAX_N = 305;

bool dp[10000025][2];//dp[i][j]代表还剩i个石头，当前为k进行操作时会输还是会赢，0代表第一个人first，1代表第二个人second 

int arr[MAX_N],n;

bool dfs(int k,int t)

{

	//初始条件为dp[0][0]=0,dp[0][1]=0 

    if(dp[k][t]>0)

	  return dp[k][t];

    bool ans=0;

    for(int i=1;i<=n;++i)//遍历n个可以移除石子的数量 

      if(k>=arr[i])//只要当前剩余石子数量大于可以移除石子的数量 

	    ans|=!dfs(k-arr[i],!t);//若上一状态对手赢(1)，则当前状态自己输(0)，上一状态对手输(0)则当前状态自己赢(1)

        //这里用或运算，因为只要有能赢的情况就会选择能赢的情况 

	return dp[k][t]=ans;

}

int main()

{

    int k;

    scanf("%d%d",&n,&k);

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

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

    if(dfs(k,0)==false)

	  printf("Second\n");

    else printf("First\n");

    return 0;

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

using namespace std;



typedef long long int ll;





int dp[100010];

int arr[100010];

int n;



int go(int val){

    if(val == 0)    return 0;

    if(dp[val] != -1)   return dp[val];

    int pos = 0;

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

        if(val >= arr[i]){

            int tval = go(val-arr[i]);

            if(tval == 0){

                pos = 1;

            }

        }

    }

    return dp[val] = pos;

}

int main(){

    memset(dp,-1,sizeof dp);

    int k;

    scanf("%d %d",&n,&k);

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

        scanf("%d",arr+i);

    }

    int ans = go(k);

    if(ans == 0){

        printf("Second\n");

    }

    else{

        printf("First\n");

    }

    //printf("%.10f\n",ans);

}


// Faster C++ solution for the same problem (measured speedup: 1.3721388911483463x):
#include<bits/stdc++.h>

using namespace std;

void Fast() {

	ios::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);

}

int main() {

	Fast();

	int n, i, k;

	cin >> n >> k;

	int* v = new int[n];

	bool** dp = new bool* [k+1];

	for (i = 0; i <= k; i++)dp[i] = new bool[2];

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

	for (i = 0; i <= k; i++) {

		dp[i][0] = 1, dp[i][1] = 0;

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

			if (i - v[j] >= 0)dp[i][1] |= dp[i - v[j]][0];

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

		}

	}

	cout << (dp[k][1] ? "First" : "Second");

	delete[]v;

	for (i = 0; i <= k; i++)delete[]dp[i];

	delete[]dp;

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

using namespace std;

int arr[200],dp[200000],n,k;



int stone(int a){

	if(a == 0) return 2;

	if(dp[a] != 0) return dp[a];

	else{

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

			if(arr[i] > a) break;

			if(stone(a - arr[i]) == 2){

				dp[a] = 1;

				break;

			}

		}

		if(dp[a] == 0) dp[a] = 2;

	}

	

	return dp[a];

}

int main (){

	memset(dp,0,sizeof dp);

	cin >> n >> k;

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

		cin >> arr[i]; 

	}

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

	

	int ans = stone(k);

	

	if(ans == 1)cout << "First" << endl;

	else cout << "Second" << endl;

}

// Faster C++ solution for the same problem (measured speedup: 1.7860181221908114x):
#include<bits/stdc++.h>

using namespace std;

void Fast() {

	ios::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);

}

int main() {

	Fast();

	int n, i, k;

	cin >> n >> k;

	int* v = new int[n];

	bool** dp = new bool* [k+1];

	for (i = 0; i <= k; i++)dp[i] = new bool[2];

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

	for (i = 0; i <= k; i++) {

		dp[i][0] = 1, dp[i][1] = 0;

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

			if (i - v[j] >= 0)dp[i][1] |= dp[i - v[j]][0];

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

		}

	}

	cout << (dp[k][1] ? "First" : "Second");

	delete[]v;

	for (i = 0; i <= k; i++)delete[]dp[i];

	delete[]dp;

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

#include <ext/numeric>



using namespace std;

using namespace __gnu_cxx;



#define sz(v)           ((int)((v).size()))

#define clr(v, d)       memset(v, d, sizeof(v))

#define rep(i, v)       for(int i=0; i<sz(v); ++i)

#define lp(i, n)        for(int i=0; i<(int)(n); ++i)

#define lpi(i, j, n)    for(int i=(j); i<(int)(n); ++i)

#define lpd(i, j, n)    for(int i=(j); i>=(int)(n); --i)

//#define INF             1000000000

//#define INF             100000000000000



typedef long long ll;

typedef pair<int, int> ii;

typedef vector<ii> vii;

typedef vector<int> vi;



void init(){

	std::ios_base::sync_with_stdio(false);

	cin.tie(NULL);

	cout.tie(NULL);

}



const int N = 1e5+5;

const int M = 104;



int dp[N][2];



int arr[M];



int n, k;



bool solve(int cur_k, bool turn){

	if(cur_k < 0)

		return turn;

	int & cur = dp[cur_k][turn];

	if(cur != -1)

		return cur;

	lp(i, n)

		if(solve(cur_k - arr[i], !turn) == turn)

			return (cur = turn);

	return (cur = !turn);

}



int main()

{

	clr(dp, -1);

	cin >> n >> k;

	lp(i, n)

		cin >> arr[i];

	cout << (solve(k, 0)?"Second":"First");

	return 0;

}


// Faster C++ solution for the same problem (measured speedup: 1.7757869540406597x):
#include<bits/stdc++.h>

using namespace std;

void Fast() {

	ios::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);

}

int main() {

	Fast();

	int n, i, k;

	cin >> n >> k;

	int* v = new int[n];

	bool** dp = new bool* [k+1];

	for (i = 0; i <= k; i++)dp[i] = new bool[2];

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

	for (i = 0; i <= k; i++) {

		dp[i][0] = 1, dp[i][1] = 0;

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

			if (i - v[j] >= 0)dp[i][1] |= dp[i - v[j]][0];

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

		}

	}

	cout << (dp[k][1] ? "First" : "Second");

	delete[]v;

	for (i = 0; i <= k; i++)delete[]dp[i];

	delete[]dp;

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



using namespace std;

typedef long long ll;

typedef unsigned long long ull;

typedef double dd;

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

#define endl "\n"

#define clr(n, r) memset(n,r,sizeof(n));



void fast() {

    cin.tie(0);

    cin.sync_with_stdio(0);

}











int main() {

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

int arr[n];

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

        cin>>arr[i];

    }

    int dp[100009];

    clr(dp,0);

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

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

            if (arr[i] <= j) {

                if (!dp[j - arr[i]]) {

                        dp[j] = 1;

                        break;

                    }

                }

            }

        }

    cout<<(dp[k]?"First":"Second");

}

// Faster C++ solution for the same problem (measured speedup: 1.3776265980718803x):
#include<bits/stdc++.h>

using namespace std;

void Fast() {

	ios::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);

}

int main() {

	Fast();

	int n, i, k;

	cin >> n >> k;

	int* v = new int[n];

	bool** dp = new bool* [k+1];

	for (i = 0; i <= k; i++)dp[i] = new bool[2];

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

	for (i = 0; i <= k; i++) {

		dp[i][0] = 1, dp[i][1] = 0;

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

			if (i - v[j] >= 0)dp[i][1] |= dp[i - v[j]][0];

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

		}

	}

	cout << (dp[k][1] ? "First" : "Second");

	delete[]v;

	for (i = 0; i <= k; i++)delete[]dp[i];

	delete[]dp;

}