stablegradients/pie-gem5-pairs huggingface dataset:
// 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.4581444375897714x):
#include <bits/stdc++.h>

#include <ext/pb_ds/assoc_container.hpp> // Common file

#include <ext/pb_ds/tree_policy.hpp> // Including tree_order_statistics_node_update

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



using namespace std;

using namespace __gnu_pbds;



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

		tree_order_statistics_node_update> ordered_set;



#define el				'\n'

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

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

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



double const EPS = 1e-8, PI = acos(-1);

const int N = 1e5 + 9, M = 100 + 9, OO = (int) 1e6 + 1;

const long long MOD = 998244353;



typedef long long ll;



void OUTPUT() {

	cout << fixed << setprecision(12);

	ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);

}



void INPUT() {

#ifndef ONLINE_JUDGE

	freopen("input.txt", "r", stdin);

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

#endif

}



int main() {

	//INPUT();

	OUTPUT();

	int n, k;

	cin >> n >> k;

	vector<int> a(n);

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

		cin >> a[i];

	}

	vector<bool> dp(k + 1);

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

		for (int x : a) {

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

				dp[stones] = 1;

			}

		}

	}

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



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

#include <ext/pb_ds/assoc_container.hpp> // Common file

#include <ext/pb_ds/tree_policy.hpp> // Including tree_order_statistics_node_update

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



using namespace std;

using namespace __gnu_pbds;



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

		tree_order_statistics_node_update> ordered_set;



#define el				'\n'

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

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

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



double const EPS = 1e-8, PI = acos(-1);

const int N = 1e5 + 9, M = 100 + 9, OO = (int) 1e6 + 1;

const long long MOD = 998244353;



typedef long long ll;



void OUTPUT() {

	cout << fixed << setprecision(12);

	ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);

}



void INPUT() {

#ifndef ONLINE_JUDGE

	freopen("input.txt", "r", stdin);

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

#endif

}



int main() {

	//INPUT();

	OUTPUT();

	int n, k;

	cin >> n >> k;

	vector<int> a(n);

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

		cin >> a[i];

	}

	vector<bool> dp(k + 1);

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

		for (int x : a) {

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

				dp[stones] = 1;

			}

		}

	}

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



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

#include <ext/pb_ds/assoc_container.hpp> // Common file

#include <ext/pb_ds/tree_policy.hpp> // Including tree_order_statistics_node_update

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



using namespace std;

using namespace __gnu_pbds;



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

		tree_order_statistics_node_update> ordered_set;



#define el				'\n'

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

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

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



double const EPS = 1e-8, PI = acos(-1);

const int N = 1e5 + 9, M = 100 + 9, OO = (int) 1e6 + 1;

const long long MOD = 998244353;



typedef long long ll;



void OUTPUT() {

	cout << fixed << setprecision(12);

	ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);

}



void INPUT() {

#ifndef ONLINE_JUDGE

	freopen("input.txt", "r", stdin);

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

#endif

}



int main() {

	//INPUT();

	OUTPUT();

	int n, k;

	cin >> n >> k;

	vector<int> a(n);

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

		cin >> a[i];

	}

	vector<bool> dp(k + 1);

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

		for (int x : a) {

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

				dp[stones] = 1;

			}

		}

	}

	cout << (dp[k] ? "First" : "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.485042421234694x):
#include <bits/stdc++.h>

using namespace std;



#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)

template <typename Arg1>

void __f(const char* name, Arg1&& arg1) {

  cerr << name << " : " << arg1 << "\n";

}

template <typename Arg1, typename... Args>

void __f(const char* na, Arg1&& arg1, Args&&... args) {

  const char* c = strchr(na + 1, ',');

  cerr.write(na, c - na) << " : " << arg1 << " , ";

  __f(c + 1, args...);

}

#define endl "\n"

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

#define UNIQUE(v) sort(all(v)),v.erase(unique(all(v)),v.end())

typedef long long LL;

typedef pair <int,int> pii;

const double pi = acos(-1.0);

const double eps = 1e-8;

const int mod = 1e9 + 7;

const int inf = 1e9;

const LL INF = 1e18;

const int N = 1e5 + 5;



int main() {

  ios_base::sync_with_stdio(false);

  cin.tie(0); cout.tie(0);

  #ifdef LOCAL

    freopen("input.txt", "r", stdin);

  #endif // LOCAL

  int n, tot;

  cin >> n >> tot;

  vector <int> v(n + 1);

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

  vector <bool> win(tot + 1, false);

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

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

      if (v[j] <= i && win[i - v[j]] == 0) {

        win[i] = 1;

      }

    }

  }

  cout << (win[tot] ? "First" : "Second") << endl;

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

using namespace std;



#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)

template <typename Arg1>

void __f(const char* name, Arg1&& arg1) {

  cerr << name << " : " << arg1 << "\n";

}

template <typename Arg1, typename... Args>

void __f(const char* na, Arg1&& arg1, Args&&... args) {

  const char* c = strchr(na + 1, ',');

  cerr.write(na, c - na) << " : " << arg1 << " , ";

  __f(c + 1, args...);

}

#define endl "\n"

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

#define UNIQUE(v) sort(all(v)),v.erase(unique(all(v)),v.end())

typedef long long LL;

typedef pair <int,int> pii;

const double pi = acos(-1.0);

const double eps = 1e-8;

const int mod = 1e9 + 7;

const int inf = 1e9;

const LL INF = 1e18;

const int N = 1e5 + 5;



int main() {

  ios_base::sync_with_stdio(false);

  cin.tie(0); cout.tie(0);

  #ifdef LOCAL

    freopen("input.txt", "r", stdin);

  #endif // LOCAL

  int n, tot;

  cin >> n >> tot;

  vector <int> v(n + 1);

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

  vector <bool> win(tot + 1, false);

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

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

      if (v[j] <= i && win[i - v[j]] == 0) {

        win[i] = 1;

      }

    }

  }

  cout << (win[tot] ? "First" : "Second") << endl;

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

using namespace std;



#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)

template <typename Arg1>

void __f(const char* name, Arg1&& arg1) {

  cerr << name << " : " << arg1 << "\n";

}

template <typename Arg1, typename... Args>

void __f(const char* na, Arg1&& arg1, Args&&... args) {

  const char* c = strchr(na + 1, ',');

  cerr.write(na, c - na) << " : " << arg1 << " , ";

  __f(c + 1, args...);

}

#define endl "\n"

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

#define UNIQUE(v) sort(all(v)),v.erase(unique(all(v)),v.end())

typedef long long LL;

typedef pair <int,int> pii;

const double pi = acos(-1.0);

const double eps = 1e-8;

const int mod = 1e9 + 7;

const int inf = 1e9;

const LL INF = 1e18;

const int N = 1e5 + 5;



int main() {

  ios_base::sync_with_stdio(false);

  cin.tie(0); cout.tie(0);

  #ifdef LOCAL

    freopen("input.txt", "r", stdin);

  #endif // LOCAL

  int n, tot;

  cin >> n >> tot;

  vector <int> v(n + 1);

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

  vector <bool> win(tot + 1, false);

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

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

      if (v[j] <= i && win[i - v[j]] == 0) {

        win[i] = 1;

      }

    }

  }

  cout << (win[tot] ? "First" : "Second") << endl;

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

#define mx 100007

using namespace std;



int arr[107];

int dp[mx];

bool vis[mx];

int n,k;



/// dp[i]= TRUE if it's a wining state for the first player



int main()

{

    cin>>n>>k;



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

        cin>> arr[i];



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

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

            if( stones-arr[i]>=0 and !dp[stones-arr[i]] )

                dp[stones]= 1;



    if( dp[k] )

        cout<<"First\n";

    else

        cout<<"Second\n";

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

#define mx 100007

using namespace std;



int arr[107];

int dp[mx];

bool vis[mx];

int n,k;



/// dp[i]= TRUE if it's a wining state for the first player



int main()

{

    cin>>n>>k;



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

        cin>> arr[i];



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

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

            if( stones-arr[i]>=0 and !dp[stones-arr[i]] )

                dp[stones]= 1;



    if( dp[k] )

        cout<<"First\n";

    else

        cout<<"Second\n";

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

#define mx 100007

using namespace std;



int arr[107];

int dp[mx];

bool vis[mx];

int n,k;



/// dp[i]= TRUE if it's a wining state for the first player



int main()

{

    cin>>n>>k;



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

        cin>> arr[i];



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

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

            if( stones-arr[i]>=0 and !dp[stones-arr[i]] )

                dp[stones]= 1;



    if( dp[k] )

        cout<<"First\n";

    else

        cout<<"Second\n";

}
// 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.3574148501322454x):
#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");

}
// 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.3420969459846535x):
#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");

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

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

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

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

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

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

using namespace std;



typedef long long       ll;

typedef long double     ld;

typedef vector<int>     vi;

typedef vector<double>  vd;

typedef vector< vi >    vii;

typedef vector< vd >    vdd;

typedef vector<string>  vs;





int main()

{

	int n, k;

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

	vector<int>a(n + 2);

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



	vector<bool> dp(k + 3);

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

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

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

				dp[i] = true;

			}

		}

	}

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





	return 0;

}