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

using namespace std;

#define  ll long long int

#define mx 100007

ll dp[mx];

ll a[mx];



int main()

{

    ll n,k;

    cin>>n>>k;

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



    memset(dp,0,sizeof(dp));

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

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

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

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

                    dp[i]=1;

                    break;

                }

            }

        }

    }

    if(dp[k]==1) cout<<"First"<<endl;

    else cout<<"Second"<<endl;

}


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

using namespace std;

bool dp[100005];

vector <int> a;

int N, K, temp;

int main(){

	scanf("%d%d", &N, &K);

	memset(dp, 0, sizeof(dp));

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

		scanf("%d", &temp);

		a.push_back(temp);

		dp[temp] = true;

	}

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

		bool win = false;

		for(auto j : a){

			if(i - j < 0) continue;

			if(dp[i-j] == false){

				win = true;

				break;

			}

		}

		if(win) dp[i] = true;

	}

	if(dp[K]) cout <<"First"<<endl;

	else cout << "Second"<<endl;





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

using namespace std;

#define  ll long long int

#define mx 1000007

ll dp[mx];

ll a[mx];



int main()

{

    ll n,k;

    cin>>n>>k;

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



    memset(dp,0,sizeof(dp));

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

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

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

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

                    dp[i]=1;

                    break;

                }

            }

        }

    }

    if(dp[k]==1) cout<<"First"<<endl;

    else cout<<"Second"<<endl;

}

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

using namespace std;

bool dp[100005];

vector <int> a;

int N, K, temp;

int main(){

	scanf("%d%d", &N, &K);

	memset(dp, 0, sizeof(dp));

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

		scanf("%d", &temp);

		a.push_back(temp);

		dp[temp] = true;

	}

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

		bool win = false;

		for(auto j : a){

			if(i - j < 0) continue;

			if(dp[i-j] == false){

				win = true;

				break;

			}

		}

		if(win) dp[i] = true;

	}

	if(dp[K]) cout <<"First"<<endl;

	else cout << "Second"<<endl;





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

//#define int long long

#define fast ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0)

using namespace std;

#define endl '\n'

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

#define vii vector<int>

int n, k;

int v[110];

int dp[100005][3];

int solve(int rem=k, bool player=0) {///0 for First ,1 for Second

	//if (rem < 0) return player;

	int& ret = dp[rem][player];

	if (~ret) return ret;

	ret = !player;

	for (i, 0, n) {

		if (v[i] <= rem) {

			if (solve(rem - v[i], !player) == player) {

				ret = player;

			}

		}

	}

	return ret;

}

signed main()

{

	   fast;

  

	cin >> n >> k;

	for (i, 0, n) cin >> v[i];

	memset(dp, -1, sizeof dp);

	int sol = solve();

	if (!sol) cout << "First\n";

	else cout << "Second\n";

}


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

using namespace std;

bool dp[100005];

vector <int> a;

int N, K, temp;

int main(){

	scanf("%d%d", &N, &K);

	memset(dp, 0, sizeof(dp));

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

		scanf("%d", &temp);

		a.push_back(temp);

		dp[temp] = true;

	}

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

		bool win = false;

		for(auto j : a){

			if(i - j < 0) continue;

			if(dp[i-j] == false){

				win = true;

				break;

			}

		}

		if(win) dp[i] = true;

	}

	if(dp[K]) cout <<"First"<<endl;

	else cout << "Second"<<endl;





}
// 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.877361182985191x):
#include<bits/stdc++.h>

using namespace std;

const int N = 1e2+3;

const int K = 1e5+5;

bool dp[K];

int a[N];

int main() {

	int n, k;

	cin >> n >> k;

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

		cin >> a[i];

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

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

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

				dp[j] |= !dp[j-a[i]];

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



	return 0;

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

#include <map>

#include <unordered_map>

#include <string>

#include <vector>

#include <queue>

#include <stack>

#include <algorithm>

using namespace std;



int main() {

    int n, k;

		cin >> n >> k;

		vector<int> dp(100005); int a[105];

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

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

		}

		dp[0] = 2;

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

			bool OK = false;

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

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

					if (dp[i - a[j]] == 2 || i - a[j] == 0) {

						dp[i] = 1;

						OK = true;

						break;

					}

				}

			}

			if (!OK) dp[i] = 2;

		}

        if (dp[k] == 1) printf("First\n"); 

		else printf("Second\n");

		return 0;

}

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

using namespace std;

#define BIGINF (int) 4e18 + 7

#define MOD7 1000000007

#define MOD9 1e9 + 9

#define INF  (int)2e9 + 7

#define SCD(t) scanf("%d",&t)

#define SCLD(t) scanf("%ld",&t)

#define SCLLD(t) scanf("%lld",&t)

#define SCC(t) scanf("%c",&t)

#define SCS(t) scanf("%s",t)

#define SCF(t) scanf("%f",&t)

#define SCLF(t) scanf("%lf",&t)

#define MEM(a, b) memset(a, (b), sizeof(a))

typedef long long ll;

typedef long double ld;

typedef string str;

typedef double d;

typedef unsigned u;

typedef unsigned long long ull;



int main () {

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

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

    int n, k;

    cin >> n >> k;

    int a[105];

    bool dp[100005];

    memset(dp, false, sizeof(dp));

    dp[0] = false;

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

    	cin >> a[i];

    }



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

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

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

    			if (dp[i - a[j]] == false) {

    				dp[i] = true;

    				break;

    			}

    		}

    	}

    }

    if (dp[k]) printf("First");

    else printf("Second");



    return 0;

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

#include <algorithm>

#include <vector>

#include <set>

#include <cmath>

#include <deque>

#include <iterator>

#include <map>

#include <queue>

#include <string>

#include <tuple>

#include <utility>

#include <limits>

#include <iomanip>

using namespace std;



using ll=long long;

template<class T> using V = vector<T>;

template<class T, class U> using P = pair<T, U>;

using vll = V<ll>;

using vvll = V<vll>;

#define rep(i, k, n) for (ll i=k; i<(ll)n; ++i)

#define REP(i, n) rep(i, 0, n)

template<class T> inline bool chmax(T& a, T b) {if (a<b) {a=b; return true;} return false;}

template<class T> inline bool chmin(T& a, T b) {if (a>b) {a=b; return true;} return false;}



int main() {

  ll n, k; cin >> n >> k;

  vll a(n); REP(i, n) cin >> a.at(i);

  vll dp(100005, 0);

  rep(i, 1, k+1) {

    rep(j, 0, n) {

      if (i-a.at(j)>=0 && dp.at(i-a.at(j))==0) dp.at(i)=1;

    }

  }

  if (dp.at(k) == 1) cout << "First" << endl;

  else cout << "Second" << endl;

  return 0;

}


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

#include <array>

#include <algorithm>

#include <vector>

#include <set>

#include <unordered_set>

#include <cmath>

#include <complex>

#include <deque>

#include <iterator>

#include <numeric>

#include <map>

#include <unordered_map>

#include <queue>

#include <stack>

#include <string>

#include <tuple>

#include <utility>

#include <limits>

#include <iomanip>

using namespace std;



using ll=long long;

template<class T> using V = vector<T>;

template<class T, class U> using P = pair<T, U>;

using vll = V<ll>;

using vvll = V<vll>;

#define rep(i, k, n) for (ll i=k; i<(ll)n; ++i)

#define REP(i, n) rep(i, 0, n)

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

template<class T> inline bool chmax(T& a, T b) {if (a<b) {a=b; return true;} return false;}

template<class T> inline bool chmin(T& a, T b) {if (a>b) {a=b; return true;} return false;}



const ll MOD = 1000000007;

const ll HIGHINF = (ll)1e18;



int main() {

    cin.tie(0);

    ios::sync_with_stdio(false);

    ll n, k; cin >> n >> k;

    vll a(n); REP(i, n) cin >> a[i];

    vll dp(k+1, 0);

    rep(i, 1, k+1) REP(j, n) if (i-a[j]>=0 && dp[i-a[j]]==0) dp[i]=1;

    if (dp[k] == 1) cout << "First\n";

    else cout << "Second\n";

    return 0;

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

#include <algorithm>

#include <vector>

#include <set>

#include <cmath>

#include <deque>

#include <iterator>

#include <map>

#include <queue>

#include <string>

#include <tuple>

#include <utility>

#include <limits>

#include <iomanip>

using namespace std;



using ll=long long;

template<class T> using V = vector<T>;

template<class T, class U> using P = pair<T, U>;

using vll = V<ll>;

using vvll = V<vll>;

#define rep(i, k, n) for (ll i=k; i<(ll)n; ++i)

#define REP(i, n) rep(i, 0, n)

template<class T> inline bool chmax(T& a, T b) {if (a<b) {a=b; return true;} return false;}

template<class T> inline bool chmin(T& a, T b) {if (a>b) {a=b; return true;} return false;}



int main() {

  ll n, k; cin >> n >> k;

  vll a(n); REP(i, n) cin >> a.at(i);

  vll dp(100005, 0);

  rep(i, 1, k+1) {

    rep(j, 0, n) {

      if (i-a.at(j)>=0 && dp.at(i-a.at(j))==0) dp.at(i)=1;

    }

  }

  if (dp.at(k) == 1) cout << "First" << endl;

  else cout << "Second" << endl;

  return 0;

}


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

#include <array>

#include <algorithm>

#include <vector>

#include <bitset>

#include <set>

#include <unordered_set>

#include <cmath>

#include <complex>

#include <deque>

#include <iterator>

#include <numeric>

#include <map>

#include <unordered_map>

#include <queue>

#include <stack>

#include <string>

#include <tuple>

#include <utility>

#include <limits>

#include <iomanip>

#include <functional>

#include <cassert>

using namespace std;



using ll=long long;

template<class T> using V = vector<T>;

template<class T, class U> using P = pair<T, U>;

using vll = V<ll>;

using vvll = V<vll>;

#define rep(i, k, n) for (ll i=k; i<(ll)n; ++i)

#define REP(i, n) rep(i, 0, n)

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

template < class T > inline bool chmax(T& a, T b) {if (a < b) { a=b; return true; } return false; }

template < class T > inline bool chmin(T& a, T b) {if (a > b) { a=b; return true; } return false; }

#define DEBUG_VLL(vec) REP(sz, vec.size()) std::cerr<<vec[sz]<<(sz==vec.size()-1?'\n':' ');



const long long MOD = 1000000007;

const long long HIGHINF = (long long)1e18;

const int INF = (int)1e9;



int main() {

    cin.tie(0);

    ios::sync_with_stdio(false);

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

    V<int> a(n);

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

    V<bool> dp(k + 1, false);

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

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

            if (i + a[j] > k) continue;

            if (!dp[i]) dp[i + a[j]] = true;

        }

    }

    if (dp[k]) cout << "First\n";

    else cout << "Second\n";

    return 0;

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

#include <algorithm>

#include <vector>

#include <set>

#include <cmath>

#include <deque>

#include <iterator>

#include <map>

#include <queue>

#include <string>

#include <tuple>

#include <utility>

#include <limits>

#include <iomanip>

using namespace std;



using ll=long long;

template<class T> using V = vector<T>;

template<class T, class U> using P = pair<T, U>;

using vll = V<ll>;

using vvll = V<vll>;

#define rep(i, k, n) for (ll i=k; i<(ll)n; ++i)

#define REP(i, n) rep(i, 0, n)

template<class T> inline bool chmax(T& a, T b) {if (a<b) {a=b; return true;} return false;}

template<class T> inline bool chmin(T& a, T b) {if (a>b) {a=b; return true;} return false;}



int main() {

  ll n, k; cin >> n >> k;

  vll a(n); REP(i, n) cin >> a.at(i);

  vll dp(100005, 0);

  rep(i, 1, k+1) {

    rep(j, 0, n) {

      if (i-a.at(j)>=0 && dp.at(i-a.at(j))==0) dp.at(i)=1;

    }

  }

  if (dp.at(k) == 1) cout << "First" << endl;

  else cout << "Second" << endl;

  return 0;

}


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

#include <array>

#include <algorithm>

#include <vector>

#include <bitset>

#include <set>

#include <unordered_set>

#include <cmath>

#include <complex>

#include <deque>

#include <iterator>

#include <numeric>

#include <map>

#include <unordered_map>

#include <queue>

#include <stack>

#include <string>

#include <tuple>

#include <utility>

#include <limits>

#include <iomanip>

#include <functional>

#include <cassert>

using namespace std;



using ll=long long;

template<class T> using V = vector<T>;

template<class T, class U> using P = pair<T, U>;

using vll = V<ll>;

using vvll = V<vll>;

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

template < class T > inline bool chmax(T& a, T b) {if (a < b) { a=b; return true; } return false; }

template < class T > inline bool chmin(T& a, T b) {if (a > b) { a=b; return true; } return false; }

#define DEBUG_VLL(vec) for(int sz=0;sz<int(vec.size());sz++) std::cerr<<vec[sz]<<(sz==vec.size()-1?'\n':' ');



const long long MOD = 1000000007;

const long long HIGHINF = (long long)1e18;

const int INF = (int)1e9;



int main() {

    cin.tie(0);

    ios::sync_with_stdio(false);

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

    V<int> a(n);

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

    V<bool> dp(k + 1, false);

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

        if (dp[i]) continue;

        for (auto &ta: a) {

            if (i + ta > k) continue;

            dp[i + ta] = true;

        }

    }

    

    if (dp[k]) cout << "First\n";

    else cout << "Second\n";

    return 0;

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

using namespace std;

#define ll long long 

#define pb push_back 

const int mod=1e9+7;\

int dp[100005];

 int solve(int b[],int k,int n){

          if(k<0)

          return 1;

          

          if(k==0)

          return dp[k]=0;

         if(dp[k]!=-1)

          return dp[k];  

          

        int sum=1;

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

		 int t=solve(b,k-b[i],n);

		   sum=sum && t;

		}

		if(sum)

		return  dp[k]=0;

		return dp[k]=1;

        

}

int main(){

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

       int n,k;

         cin>>n>>k;

         memset(dp,-1,sizeof(dp));

        int b[n];

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

          cin>>b[i]; 

           

           if(solve(b,k,n))

             cout<<"First\n";

          else

             cout<<"Second\n";

             

    }


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

using namespace std;

#define ll long long 

#define pb push_back 

const int mod=1e9+7;

 /*int solve(int b[],int k,int n){

          if(k<0)

          return 1;

          

          if(k==0)

          return dp[k]=0;

         if(dp[k]!=-1)

          return dp[k];  

          

        int sum=1;

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

		 int t=solve(b,k-b[i],n);

		   sum=sum && t;

		}

		if(sum)

		return  dp[k]=0;

		return dp[k]=1;

        

}*/

int main(){

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

       int n,k;

         cin>>n>>k;

        // memset(dp,-1,sizeof(dp));

        int b[n];

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

          cin>>b[i]; 

           

            vector<int>dp(k+1);

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

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

				   if(i>=b[j] && !(dp[i-b[j]]))

				    dp[i]=1;

				 }

			}

           if(dp[k])

             cout<<"First\n";

          else

             cout<<"Second\n";

             

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

using namespace std;



int N, K, a[110];

bool dp[100100], cek[100100];



bool f(int k) {

	if (k==0) return 0;

	if (cek[k]) return dp[k];

	dp[k] = 0;

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

		if (k - a[i] >= 0) {

			dp[k] |= !f(k - a[i]);

		}

	}

	cek[k] = 1;

	return dp[k];

}



int main () {

	cin >> N >> K;

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

		cin >> a[i];

	memset(cek, 0, sizeof(cek));

	if (f(K))

		cout << "First" << endl;

	else

		cout << "Second" << endl;

}

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

#include<string.h>

#include<time.h>

#include<math.h>

#include<stdlib.h>

#include<iostream>

#include<iomanip>

#include<utility>

#include<algorithm>

#include<stack>

#include<queue>

#include<map>

#include<set>

#define ll long long

#define fi first

#define sec second

#define pb push_back

#define mp make_pair

#define rep(a,b,c) for(int a=1;a<=b;a+=c)

#define repp(a,b,c,d) for(int a=b;a<=c;a+=d)



const double PI=acos(-1);

const double EPS=1e-12;

const int MOD=1e9+7;

const int INF=1<<30;





using namespace std;



bool vis[10000005];

int dat[105];



int main(){

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

	int in,n;

	bool fl;

	cin>>in>>n;

	rep(i,in,1){

		cin>>dat[i];

	}

	repp(i,0,n,1){

		fl=vis[i]^true;

		rep(j,in,1){

			if(i+dat[j]<=n){

				vis[i+dat[j]]|=fl;

			}

		}

	}

	if(vis[n])cout<<"First"<<endl;

	else cout<<"Second"<<endl;

	return 0;

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

using namespace std;



int N, K, a[110];

bool dp[100100], cek[100100];



bool f(int k) {

	if (k==0) return 0;

	if (cek[k]) return dp[k];

	dp[k] = 0;

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

		if (k - a[i] >= 0) {

			dp[k] |= !f(k - a[i]);

		}

	}

	cek[k] = 1;

	return dp[k];

}



int main () {

	cin >> N >> K;

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

		cin >> a[i];

	memset(cek, 0, sizeof(cek));

	if (f(K))

		cout << "First" << endl;

	else

		cout << "Second" << endl;

}

// Faster C++ solution for the same problem (measured speedup: 1.0794022894938395x):
/*|In The Name Of Allah|*/



#include <bits/stdc++.h>



using namespace std;



const int N = 1e2+5;

const int M = 1e5+5;

const int mod = 1e9+7;



int n;

int k;

int mn;

int pile[N];

bool has[M];

bool vis[M][2];

bool mem[M][2];



//taro's trn is 1

bool go(int stones , int trn){

    //cout << stones << " " << trn << endl;

    if(stones < mn){

        return 0;

    }

    if(vis[stones][trn])

        return mem[stones][trn];

    bool state = 0;

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

        if(pile[i] <= stones){

            state |= !go(stones - pile[i] , 1 - trn);

        }

    }

    vis[stones][trn] = true;

    return mem[stones][trn] = state;

}



int main(){

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

    mn = 1e5+5;

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

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

        mn = min(mn , pile[i]);

    }

    if(go(k , 1)){

        puts("First");

    } else {

        puts("Second");

    }

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

using namespace std;



int N, K, a[110];

bool dp[100100], cek[100100];



bool f(int k) {

	if (k==0) return 0;

	if (cek[k]) return dp[k];

	dp[k] = 0;

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

		if (k - a[i] >= 0) {

			dp[k] |= !f(k - a[i]);

		}

	}

	cek[k] = 1;

	return dp[k];

}



int main () {

	cin >> N >> K;

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

		cin >> a[i];

	memset(cek, 0, sizeof(cek));

	if (f(K))

		cout << "First" << endl;

	else

		cout << "Second" << endl;

}

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

#include <ext/pb_ds/assoc_container.hpp>

#include <ext/pb_ds/tree_policy.hpp>

#include <ext/pb_ds/detail/standard_policies.hpp>

using namespace std;

using namespace __gnu_pbds;

typedef tree<pair<int,int>, null_type, less<pair<int,int>>, rb_tree_tag,

		tree_order_statistics_node_update> ordered_set;



int n , k;

int mem[100005];

bool vis[100005];

int arr[105];

int sol(int rem , bool ff){



	if(vis[rem])

		return mem[rem];

	vis[rem] = true;

	int ret = 0;

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

		if(rem-arr[i]>=0){

			ret|=sol(rem-arr[i],ff^1)==0;

		}

		else break;

	}

	return mem[rem] = ret;

}

int main(){

	cin>>n>>k;

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

		cin>>arr[i];

	}

	sort(arr,arr+n);

	sol(k,false);

	if(mem[k])

		cout<<"First";

	else cout<<"Second";

	return 0;

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

using namespace std;



int N, K, a[110];

bool dp[100100], cek[100100];



bool f(int k) {

	if (k==0) return 0;

	if (cek[k]) return dp[k];

	dp[k] = 0;

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

		if (k - a[i] >= 0) {

			dp[k] |= !f(k - a[i]);

		}

	}

	cek[k] = 1;

	return dp[k];

}



int main () {

	cin >> N >> K;

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

		cin >> a[i];

	memset(cek, 0, sizeof(cek));

	if (f(K))

		cout << "First" << endl;

	else

		cout << "Second" << endl;

}

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

#include <iostream>



using namespace std;



const int MAXN = 110;

const int MAXK = 100010;



int n, k, a[MAXN];

bool sg[MAXK];



int main()

{

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

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

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

	sg[0] = 0;

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

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

			if(i >= a[j]) sg[i] |= !sg[i-a[j]];

		}

	}

	if(sg[k]) puts("First");

	else puts("Second");

	return 0;

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

using namespace std;



int const N=1e2+5, M=1e5+5, OO = 0x3f3f3f3f;





int n,k;

int arr[N];

int mem[M][2];

int solve(int rem, bool last)

{

    if(rem<0)

        return !last;

    if(mem[rem][last]!=-1)

        return mem[rem][last];

    int ret;

    bool f;

    if(last)

    {

        ret=0;

        f=0;

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

        {

            if(rem-arr[i]>=0)

            {

                ret=max(ret,solve(rem-arr[i],0));

                f=1;

            }

            else

                break;

        }

        if(!f)

            ret=0;

    }

    else

    {

        f=0;

        ret=1;

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

        {

            if(rem-arr[i]>=0)

            {

                ret=min(ret,solve(rem-arr[i],1));

                f=1;

            }

            else

                break;

        }

        if(!f)

            ret=1;

    }

    return mem[rem][last]=ret;

}





int main()

{

//    freopen("input.txt","rt",stdin);

//    freopen("output.txt","wt",stdout);

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

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

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

    memset(mem, -1, sizeof mem);

    if(solve(k,1))

        puts("First");

    else

        puts("Second");



}


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

using namespace std;



int main()

{

    int n,k;

    cin>>n>>k;

    vector<int>a(n);

    for(int& x:a)

        scanf("%d",&x);

    vector<bool>dp(k+1);

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

    {

        for(int x:a)

        {

            if(i>=x&&!dp[i-x])

            {

                dp[i]=true;

            }

        }

    }

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





}