stablegradients/pie-gem5-bysrc huggingface dataset:
// Original C++ solution (slower):
#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;

}


// Optimized solution to the same problem (faster):
#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;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
//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;

}


// Optimized solution to the same problem (faster):
//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;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;

}


// Optimized solution to the same problem (faster):
#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;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#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");

	}

}

// Optimized solution to the same problem (faster):
#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");

	}

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;

}

// Optimized solution to the same problem (faster):
#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;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#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";

}

// Optimized solution to the same problem (faster):
#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";

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;

}

// Optimized solution to the same problem (faster):
#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;

}

			

			

	

	

// Fastest known solution for this problem:
// Original C++ solution (slower):
#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);

}


// Optimized solution to the same problem (faster):
#include<bits/stdc++.h>

using namespace std;

const int N=105,K=100005;

int a[N],dp[K];

vector<int>q;

int main()

{

	int n,k;

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

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

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

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

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

		dp[i]=0;

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

	{

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

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

				dp[i]=1;

		

	}

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

	return 0;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;

}

// Optimized solution to the same problem (faster):
#include<bits/stdc++.h>

using namespace std;

const int N=105,K=100005;

int a[N],dp[K];

vector<int>q;

int main()

{

	int n,k;

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

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

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

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

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

		dp[i]=0;

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

	{

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

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

				dp[i]=1;

		

	}

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

	return 0;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;

}


// Optimized solution to the same problem (faster):
#include<bits/stdc++.h>

using namespace std;

const int N=105,K=100005;

int a[N],dp[K];

vector<int>q;

int main()

{

	int n,k;

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

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

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

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

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

		dp[i]=0;

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

	{

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

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

				dp[i]=1;

		

	}

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

	return 0;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#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");

}

// Optimized solution to the same problem (faster):
#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;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;

}






// Optimized solution to the same problem (faster):
#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;

}


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



#define Fast cin.tie(0), ios::sync_with_stdio(0)

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

#define louisfghbvc int t; cin >> t; while(t--)

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

using namespace std;

typedef long long LL;

typedef pair<LL, LL> ii;

typedef vector<LL> vi;



template<typename T> ostream& operator<<(ostream &os, const vector<T> &v) { os << '{'; string sep = ""; for(const auto &x : v) os << sep << x, sep = ", "; return os << '}'; }

template<typename A, typename B> ostream& operator<<(ostream &os, const pair<A, B> &p) { return os << '(' << p.first << ", " << p.second << ')'; }



void dbg_out() { cerr << "\n"; }

template<typename Head, typename... Tail> void dbg_out(Head H, Tail... T) { cerr << ' ' << H; dbg_out(T...); }



const int K = 1e5+5;

int arr[105];

int dp[K];

int n, k;



int dfs(int remain){

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

    bool res = 0;

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

        if(remain >= arr[i]) res |= (dfs(remain-arr[i]) == 0);

    }

    return dp[remain] = res;

}



void solve(){

    cin >> n >> k;

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

    memset(dp, -1, sizeof dp);



    cout << (dfs(k)==1 ? "First": "Second") << "\n";

}



int main()

{

    Fast;

    //louisfghbvc{

        solve();

    //}

    return 0;

}


// Optimized solution to the same problem (faster):
#include <bits/stdc++.h>

using namespace std;

const int maxk = 1e5+5;

const int maxn = 100+5;

int A[maxn];

bool dp[maxk];

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

{

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

	memset(dp, false, sizeof dp);

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

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

		dp[A[i]] = true;

	}



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

		if(!dp[i]){

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

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

					dp[i] = true;

					break;

				}

			}

		}

	}



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

	else printf("Second\n");

	return 0;

}

// Fastest known solution for this problem: