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

#define ll long long int

#define ld long double

#define pb push_back

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

#define ff first

#define ss second

#define mod 1000000007

using namespace std;



int dp[100002];

int n;

vector<int> a;



int fun(int k){

	if(dp[k]!=-1)

		return dp[k];

	int mx = 0;

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

		if(k-a[i]<0)

			continue;

		mx = max(mx,(1+fun(k-a[i]))%2);

	}

	return dp[k]=mx;

}



int main(){

	ios_base::sync_with_stdio(false); 

	cin.tie(NULL);cout.tie(NULL);

	int k;

	cin>>n>>k;

	a.resize(n);

	memset(dp,-1,sizeof dp);

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

	{

		cin>>a[i];

	}

	if(fun(k))

		cout<<"First";

	else

		cout<<"Second";

	// cerr<< '\n' << "Time elapsed :" << clock() * 1000.0 / CLOCKS_PER_SEC << " ms\n" ;

	return 0;

}

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

#define ll long long int

#define ld long double

#define pb push_back

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

#define ff first

#define ss second

#define mod 1000000007

using namespace std;



int main(){

	ios_base::sync_with_stdio(false); 

	cin.tie(NULL);cout.tie(NULL);

	int n,k;

	cin>>n>>k;

	vector<int>a(n),dp(k+1,0);

	

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

	{

		cin>>a[i];

	}

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

		for(auto j: a){

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

				dp[i] = 1;

		}

	}

	if(dp[k])

		cout<<"First";

	else

		cout<<"Second";

	// cerr<< '\n' << "Time elapsed :" << clock() * 1000.0 / CLOCKS_PER_SEC << " ms\n" ;

	return 0;

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

#include <vector>

#include <algorithm>

#include <cmath>

#include <queue>

#include <string>

#include <map>

#include <set>

#include <stack>

#include <tuple>

#include <deque>

#include <numeric>

#include <bitset>

#include <iomanip>

#include <cassert>

#include <chrono>

#include <random>

#include <limits>

#include <iterator>

#include <functional>

#include <sstream>

#include <complex>

using namespace std;



typedef long long ll;

typedef uint64_t ull;

typedef pair<int, int> P;

constexpr double PI = 3.1415926535897932;   // acos(-1)

constexpr double EPS = 1e-9;

constexpr int INF = 1001001001;

constexpr int mod = 1000000007;

// constexpr int mod = 998244353;



#define chmax(x, y) x = max(x, y)

#define chmin(x, y) x = min(x, y)



int n, k;

vector<int> a;

vector<int> dp(100005, -1);



int memo_rec(int rest = k){

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

    if(rest == 0)   return dp[rest] = 0;



    int is_win = 1;

    bool is_possible = false;

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

        if(a[i] > rest) continue;

        is_possible = true;

        is_win &= memo_rec(rest - a[i]);

    }

    cerr << is_win << endl;

    if(!is_possible)    return dp[rest] = 0;

    return dp[rest] = is_win ^ 1;

}



int main(){

    ios::sync_with_stdio(false);

    cin.tie(nullptr);



    cin >> n >> k;

    a.resize(n);

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



    if(memo_rec())  cout << "First\n";

    else    cout << "Second\n";

}

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

#include <vector>

#include <algorithm>

#include <cmath>

#include <queue>

#include <string>

#include <map>

#include <set>

#include <stack>

#include <tuple>

#include <deque>

#include <numeric>

#include <bitset>

#include <iomanip>

#include <cassert>

#include <chrono>

#include <random>

#include <limits>

#include <iterator>

#include <functional>

#include <sstream>

#include <complex>

using namespace std;



using ll = long long;

using ull = uint64_t;

using P = pair<int, int>;

constexpr double EPS = 1e-9;

constexpr int INF = 1001001001;

constexpr int mod = 1777777777;

// constexpr int mod = 1000000007;

// constexpr int mod = 998244353;



template<class T>

inline bool chmax(T& x, T y){

    if(x < y){

        x = y;

        return true;

    }

    return false;

}

template<class T>

inline bool chmin(T& x, T y){

    if(x > y){

        x = y;

        return true;

    }

    return false;

}



int main(){

    ios::sync_with_stdio(false);

    cin.tie(nullptr);



    int N, K;

    cin >> N >> K;

    vector<int> a(N);

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



    vector<int> dp(K + 1);

    dp[0] = 0;

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

        int c = 0;

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

            if(i - a[j] >= 0 && !dp[i - a[j]])  ++c;

        }

        dp[i] = c > 0;

    }



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

    else    cout << "Second\n";

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

#include <vector>

#include <algorithm>

#include <cmath>

#include <queue>

#include <string>

#include <map>

#include <set>

#include <stack>

#include <tuple>

#include <deque>

#include <numeric>

#include <bitset>

#include <iomanip>

#include <cassert>

#include <chrono>

#include <random>

#include <limits>

#include <iterator>

#include <functional>

#include <sstream>

#include <complex>

using namespace std;



typedef long long ll;

typedef uint64_t ull;

typedef pair<int, int> P;

constexpr double PI = 3.1415926535897932;   // acos(-1)

constexpr double EPS = 1e-9;

constexpr int INF = 1001001001;

constexpr int mod = 1000000007;

// constexpr int mod = 998244353;



#define chmax(x, y) x = max(x, y)

#define chmin(x, y) x = min(x, y)



int n, k;

vector<int> a;

vector<int> dp(100005, -1);



int memo_rec(int rest = k){

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

    if(rest == 0)   return dp[rest] = 0;



    int is_win = 1;

    bool is_possible = false;

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

        if(a[i] > rest) continue;

        is_possible = true;

        is_win &= memo_rec(rest - a[i]);

    }

    if(!is_possible)    return dp[rest] = 0;

    return dp[rest] = is_win ^ 1;

}



int main(){

    ios::sync_with_stdio(false);

    cin.tie(nullptr);



    cin >> n >> k;

    a.resize(n);

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



    if(memo_rec())  cout << "First\n";

    else    cout << "Second\n";

}

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

#include <vector>

#include <algorithm>

#include <cmath>

#include <queue>

#include <string>

#include <map>

#include <set>

#include <stack>

#include <tuple>

#include <deque>

#include <numeric>

#include <bitset>

#include <iomanip>

#include <cassert>

#include <chrono>

#include <random>

#include <limits>

#include <iterator>

#include <functional>

#include <sstream>

#include <complex>

using namespace std;



using ll = long long;

using ull = uint64_t;

using P = pair<int, int>;

constexpr double EPS = 1e-9;

constexpr int INF = 1001001001;

constexpr int mod = 1777777777;

// constexpr int mod = 1000000007;

// constexpr int mod = 998244353;



template<class T>

inline bool chmax(T& x, T y){

    if(x < y){

        x = y;

        return true;

    }

    return false;

}

template<class T>

inline bool chmin(T& x, T y){

    if(x > y){

        x = y;

        return true;

    }

    return false;

}



int main(){

    ios::sync_with_stdio(false);

    cin.tie(nullptr);



    int N, K;

    cin >> N >> K;

    vector<int> a(N);

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



    vector<int> dp(K + 1);

    dp[0] = 0;

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

        int c = 0;

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

            if(i - a[j] >= 0 && !dp[i - a[j]])  ++c;

        }

        dp[i] = c > 0;

    }



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

    else    cout << "Second\n";

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

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

#define pb(q) push_back(q)

typedef long long ll;

using namespace std;

#define doublecout(a) cout<<fixed<<setprecision(10)<<a<<endl;

int n,a[101],dp[100001][3];

int solve(int i,int j){

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

    int res=0;

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

		if (a[k]<=i){

			if (!solve(i-a[k],j^1)){

				res=1;

				break;

			}

		}

	}

	return dp[i][j]=res;

}



int main(){

	int k;

	cin>>n>>k;

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

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

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

	return 0;

}


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

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

#define pb(q) push_back(q)

typedef long long ll;

using namespace std;

#define doublecout(a) cout<<fixed<<setprecision(10)<<a<<endl;

int n,a[101],dp[100001];

int solve(int i,int j){

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

    int res=0;

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

		if (a[k]<=i){

			if (!solve(i-a[k],j)){

				res=1;

				break;

			}

		}

	}

	return dp[i]=res;

}



int main(){

	int k;

	cin>>n>>k;

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

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

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

	return 0;

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

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

#define pb(q) push_back(q)

typedef long long ll;

using namespace std;

#define doublecout(a) cout<<fixed<<setprecision(10)<<a<<endl;

int n,a[101],dp[100001][3];

int solve(int i,int j){

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

    int res=0;

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

		if (a[k]<=i){

			if (!solve(i-a[k],j^1)){

				res=1;

				break;

			}

		}

	}

	return dp[i][j]=res;

}



int main(){

	int k;

	cin>>n>>k;

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

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

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

	return 0;

}


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

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

#define pb(q) push_back(q)

typedef long long ll;

using namespace std;

#define doublecout(a) cout<<fixed<<setprecision(10)<<a<<endl;

int n,a[101],dp[100001];

int solve(int i){

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

    int res=0;

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

		if (a[k]<=i){

			if (!solve(i-a[k])){

				res=1;

				break;

			}

		}

	}

	return dp[i]=res;

}



int main(){

	int k;

	cin>>n>>k;

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

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

	cout <<(solve(k)?"First":"Second")<<std::endl;

	return 0;

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

#include <ext/pb_ds/assoc_container.hpp>

#define F first

#define S second

#define PB push_back

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

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

using namespace __gnu_pbds;

using namespace std;



typedef long long ll;

typedef vector<int> vi;

typedef pair<int,int> pi;

typedef tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update> indexed_set;



const int OO = 1e9+7;

const int MOD = 1e9+7;

const int N = 1e5+7;



int n,k;

int a[N];

int mem[2][N];



int dp(bool p,int sum)

{

    if (sum < 0) return p;

    int &ret = mem[p][sum];

    if (ret != -1) return ret;

    if (sum == 0) return ret = !p;

    ret = !p;

    if (!p)

    {

        REP(i,0,n-1)

        {

            ret = min(ret,dp(!p,sum-a[i]));

        }

    }

    else

    {

        REP(i,0,n-1)

        {

            ret = max(ret,dp(!p,sum-a[i]));

        }

    }

    return ret;

}



int main()

{

    ios::sync_with_stdio(0);

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

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

    //freopen("teleport.out","w",stdout);

    memset(mem,-1,sizeof mem);

    cin >> n >> k;

    REP(i,0,n-1) cin >> a[i];

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

    else cout << "Second" << endl;

    return 0;

}


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

#include <ext/pb_ds/assoc_container.hpp>

#define F first

#define S second

#define PB push_back

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

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

using namespace __gnu_pbds;

using namespace std;



typedef long long ll;

typedef vector<int> vi;

typedef pair<int,int> pi;

typedef tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update> indexed_set;



const int OO = 1e9+7;

const int MOD = 1e9+7;

const int N = 1e5+7;



int n,k;

int a[N];

int dp[N][2];



int main()

{

    ios::sync_with_stdio(0);

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

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

    //freopen("teleport.out","w",stdout);



    cin >> n >> k;

    REP(i,0,n-1) cin >> a[i];



    // dp[k][p] = the player who wins if there are k stones and p starts



    REP(i,0,k)

    {

        dp[i][0] = 1;

        REP(j,0,n-1)

        {

            if (i-a[j] >= 0) dp[i][0] = min(dp[i][0],dp[i-a[j]][1]);

        }



        dp[i][1] = 0;

        REP(j,0,n-1)

        {

            if (i-a[j] >= 0) dp[i][1] = max(dp[i][1],dp[i-a[j]][0]);

        }

    }



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

    else cout << "Second" << endl;



    return 0;

}
// Slower C++ solution:
//Inbornhandsome

#include <bits/stdc++.h>

using namespace std;



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



#define endl '\n'

#define int long long



const int K = 1e5+5, N = 105;

int dp[K][2], a[N], n, k;



int solve(int cur_stones, int cur_player) {

	int &ans = dp[cur_stones][cur_player];

	if(ans != -1) 

		return ans;

	ans = cur_player ^ 1;

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

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

			if(solve(cur_stones - a[i], cur_player ^ 1) == cur_player)

				ans = cur_player;

	}

	return ans;

}



int32_t main()

{

	IOS;



	cin >> n >> k;

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

		cin >> a[i];

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

	int ans = solve(k, 0);



	if(!ans)	

		cout << "First";

	else 

		cout << "Second";



	return 0;

}


// Faster C++ solution for the same problem (measured speedup: 1.5177855011367225x):
//Inbornhandsome

#include <bits/stdc++.h>

using namespace std;



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



#define endl '\n'

#define int long long



const int N = 1e5+5;

int dp[N];



int32_t main()

{

	IOS;



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

	int a[n+5];

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

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

		cin >> a[i];

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

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

			if(stones - a[j] >= 0 and ! dp[stones - a[j]]) dp[stones] = 1;

		}

	}

	

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

	else cout << "Second" << endl;



	return 0;

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



using namespace std;

int a[1000],dp[100009][3],n,k;

int sol(int x,int tu)

{

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

    if (tu==2) dp[x][tu]=1;

    else dp[x][tu]=0;

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

    {

        if (tu==1) dp[x][tu]=max(sol(x-a[i],2),dp[x][tu]);

        else dp[x][tu]=min(sol(x-a[i],1),dp[x][tu]);

    }

    return dp[x][tu];

}

int main()

{

    cin>>n>>k;

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

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

    {

        cin>>a[i];

    }

    sort(a,a+n);

    int ans=sol(k,1);

    if (ans==0) cout<<"Second";

    else cout<<"First";

    return 0;

}


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

using namespace std;

int n,k;

int arr[109];

int dp[100009];

int main(){

    cin>>n>>k;

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

        cin>>arr[i];

    }

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

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

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

                dp[i] = 1;

            }

        }

    }

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

    else cout<<"Second"<<endl;

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

using namespace std;



#define mp(x, y) make_pair(x, y)

#define pb(x) push_back(x)





typedef long long ll;

typedef long double ld;



typedef pair<int, int> pii;

typedef pair<ll, ll> pll;

typedef vector<pii> vii;

typedef vector<pll> vll;



template <class T>

using pqueue = priority_queue<T>;

template <class T>

using rpqueue = priority_queue<T, vector<T>, greater<T> >;





int sint() { int x; scanf("%d", &x); return x; }

ll sll() { ll x; scanf("%lld", &x); return x; }

double sdb() { double x; scanf("%lf", &x); return x; }





int arr[200];

bool memo[101000][5];



int main() {

	memset(memo, false, sizeof(memo));

	int n, k;

	n = sint();

	k = sint();

	

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

		arr[i] = sint();

	}

	

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

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

			bool check = false;

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

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

					if(memo[i-arr[l]][1-j] == false) {

						check = true;

					}

				}

			}

			memo[i][j] = check;

		}

	}

	

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

//		printf("%d %d\n", memo[i][0], memo[i][1]);

//	}

	

	if(memo[k][0]) {

		printf("First\n");

	} else {

		printf("Second\n");

	}

}

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

using namespace std;



#define mp(x, y) make_pair(x, y)

#define pb(x) push_back(x)





typedef long long ll;

typedef long double ld;



typedef pair<int, int> pii;

typedef pair<ll, ll> pll;

typedef vector<pii> vii;

typedef vector<pll> vll;



template <class T>

using pqueue = priority_queue<T>;

template <class T>

using rpqueue = priority_queue<T, vector<T>, greater<T> >;





int sint() { int x; scanf("%d", &x); return x; }

ll sll() { ll x; scanf("%lld", &x); return x; }

double sdb() { double x; scanf("%lf", &x); return x; }





int arr[200];

bool memo[101000];



int main() {

	memset(memo, false, sizeof(memo));

	int n, k;

	n = sint();

	k = sint();

	

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

		arr[i] = sint();

	}

	

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

		bool check = false;

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

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

				if(memo[i-arr[l]] == false) {

					check = true;

				}

			}

		}

		memo[i] = check;

	}

	

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

//		printf("%d %d\n", memo[i][0], memo[i][1]);

//	}

	

	if(memo[k]) {

		printf("First\n");

	} else {

		printf("Second\n");

	}

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

#include <algorithm>

#include <numeric>

#include <cmath>

#include <string>

#include <vector>

#include <queue>

#include <deque>

#include <stack>

#include <map>

#include <set>

#include <unordered_map>

#include <unordered_set>

#include <iomanip>

#include <functional>

using namespace std;

#define int long long

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

int dy[4] = {-1,0,1,0};

int dx[4] = {0,1,0,-1};

int Dy[8] = {-1,-1,0,1,1,1,0,-1};

int Dx[8] = {0,1,1,1,0,-1,-1,-1};

const int mod = 1000000007;

const int inf = mod*mod;

const int d5 = 100100;

signed main(){

    ios::sync_with_stdio(false);

    cin.tie(0);

    int n,k;

    cin>>n>>k;

    vector<int> a(n);

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

    int dp[d5];

    //dp[i]:石が残りi個の状態から始めたときに勝つ方

    //1:First,0:second;

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

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

        for(auto it:a){

            if(i-it<0)continue;

            if(dp[i-it]==0)dp[i]=1;

        }

    }

    //for(int i=0;i<10;i++)cout<<dp[i];

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

    else cout<<"Second"<<endl;

}

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

#include <algorithm>

#include <numeric>

#include <cmath>

#include <string>

#include <vector>

#include <queue>

#include <deque>

#include <stack>

#include <map>

#include <set>

#include <unordered_map>

#include <unordered_set>

#include <iomanip>

#include <functional>

using namespace std;

#define int long long

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

int dy[4] = {-1,0,1,0};

int dx[4] = {0,1,0,-1};

int Dy[8] = {-1,-1,0,1,1,1,0,-1};

int Dx[8] = {0,1,1,1,0,-1,-1,-1};

const int mod = 1000000007;

const int inf = mod*mod;

const int d5 = 100100;

signed main(){

    int n,k;

    cin>>n>>k;

    vector<int> a(n);

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

    bool dp[d5];

    for(int i=0;i<d5;i++)dp[i]=false;

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

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

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

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

            }

        }

    }

    //for(int i=0;i<=k;i++)cout<<dp[i]<<' ';

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

    else cout<<"Second"<<endl;

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

using namespace std;

int dp[2][100001];

bool util(int arr[], int n, int k, int p){

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

    bool flag = false;

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

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

            bool next = util(arr, n, k - arr[i], 1 - p);

            if(next == false){

                flag = true;

                break;

            }

        }

    }

    dp[p][k] = flag;

    return flag;

}

int main(){

    int n, k;

    cin>>n>>k;

    int arr[n];

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

        cin>>arr[i];

    }

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

    bool res = util(arr, n, k, 0);

    if(res){

        cout<<"First";

    }else cout<<"Second";

}

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

using namespace std;

int dp[100001];

bool util(int arr[], int n, int k){

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

    bool flag = false;

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

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

            bool next = util(arr, n, k - arr[i]);

            if(next == false){

                flag = true;

                break;

            }

        }

    }

    dp[k] = flag;

    return flag;

}

int main(){

    int n, k;

    cin>>n>>k;

    int arr[n];

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

        cin>>arr[i];

    }

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

    bool res = util(arr, n, k);

    if(res){

        cout<<"First";

    }else cout<<"Second";

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

using namespace std;



typedef long long  ll;

typedef pair<ll,ll> pll;

typedef vector<ll> vll;



#define INPUT(arr,n) for(ll i = 0;i<n;i++) cin>>arr[i];

#define PRINT(arr,n) for(ll i = 0;i<=n;i++) printf("%lld ",arr[i]);printf("\n");

#define MEM(var,val) memset(var,(val),sizeof(var))

#define MAX(a,b) ((a) > (b) ? (a) : (b))

#define MIN(a,b) ((a) < (b) ? (a) : (b))

#define mp make_pair

#define pb push_back



const ll NMAX = 100000+7;

const ll MOD = 1000*1000*1000+7;

const ll INT_BITS = 32 ;

ll arr[NMAX];

ll dp[NMAX];



inline ll add(ll a, ll b) {

  ll r = a + b;

  return (r >= MOD ? r - MOD : r);

}



inline ll sub(ll a, ll b) {

  ll r = a - b;

  return (r < 0 ? r + MOD : r);

}



inline ll mul(ll a, ll b) {

  ll r = a * b;

  return (r >= MOD ? r % MOD : r);

}



ll N,K;



bool check(ll a){

	return a%2==1;

}





int func(ll k){

	if(k<=0)return 0;

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

	int losin=1;

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

		if(k>=arr[i]){

		    // cout<<k<<" "<<i<<" "<<arr[i]<<endl;

			losin = losin and func(k - arr[i]);

		}

	}

	// cout<<k<<" "<<1-losin<<endl;

	dp[k]=1-losin;

	return 1-losin;

}



int main(int argc, char const *argv[])

{

	cin>>N>>K;

	INPUT(arr,N);

	MEM(dp,-1);

	if(func(K))

		cout<<"First\n";

	else

		cout<<"Second\n";

	return 0;

}

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

using namespace std;

typedef long long ll;

ll N,K;

ll arr[105];

ll dp[100*1000+5];



int main(){

	cin>>N>>K;

	

	for(ll k = 1;k<=K;k++)dp[k] = 0;

	ll mk = 1e8;

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

		cin>>arr[i];

		dp[arr[i]] = 1;

		mk = min(mk, arr[i]);

	}

	

	for(ll k = mk;k<=K;k++){

		ll f = 1;

		for(ll i = 0;i<N;i++)

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

				f &= dp[k-arr[i]];

		dp[k] |= !f;

	}

	

	//for(ll k = 1;k<=K;k++)cout<<dp[k]<<" ";

	//cout<<endl;

	

	if(dp[K])

		cout<<"First\n";

	else

		cout<<"Second\n";

  return 0;

}