stablegradients/pie-gem5-bysrc huggingface dataset:
// Original C++ solution (slower):
#include <iostream>

#include <cstring>

#include <vector>

#include <set>

#include <map>

#include <sstream>

#include <cstdio>

#include <algorithm>

#include <stack>

#include <queue>

#include <cmath>

#include <iomanip>

#include <fstream>

//#include <bits/stdc++.h>

using namespace std;

typedef unsigned long long ll;

const ll INF = (1 << 30);

const ll inf = (1LL << 50LL);

const int  maxn = 1e5 + 5;

const int MOD = 1e9 + 7;

int n, k;

int arr[maxn];

int dp[maxn];

int rek(int left){

    if(dp[left] != -1){

        return dp[left];

    }

    int ret = 1;

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

        if(left >= arr[i]){

            ret &= rek(left - arr[i]);

        }

    }

    return dp[left] = !ret;

}

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

    ios_base::sync_with_stdio(false);

//    ifstream cin("in.txt");

    cin >> n >> k;

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

        cin >> arr[i];

    }

    memset(dp, -1, sizeof dp);

    if(rek(k)) {

        cout << "First\n";

    }

    else{

        cout << "Second\n";

    }

    return 0;

}


// Optimized solution to the same problem (faster):
#include <iostream>

#include <cstring>

#include <vector>

#include <set>

#include <map>

#include <sstream>

#include <cstdio>

#include <algorithm>

#include <stack>

#include <queue>

#include <cmath>

#include <iomanip>

#include <fstream>

//#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

const ll INF = (1 << 30);

const ll inf = (1LL << 60LL);

const int  maxn = 1e5 + 5;

int n, k;

int arr[105];

bool dp[maxn];

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

    ios_base::sync_with_stdio(false);

    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] and !dp[stones - arr[i]]){

                dp[stones] = true;

            }

        }

    }

    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;

typedef vector<ll> vi;

typedef pair<ll,ll> pii;

#define fo(i,s,e_ex) for(i=s;i<e_ex;i++)

#define Fo(i,k,n) for(i=k;k<n?i<=n:i>=n;k<n?i+=1:i-=1)

#define endl '\n'

#define MOD 1000000007//998244353

#define pbb push_back

#define mpp make_pair

#define ff first

#define ss second

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

#define mset(arr,val) memset(arr,val,sizeof(arr))

ll n;

ll arr[105];

int dp[100005][2];

bool play(ll k,int pl){//biased for pl=0

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

	bool ans=pl;

	ll i;

	fo(i,0,n){

		if(k>=arr[i]){

			bool myans=play(k-arr[i],1-pl);

			if(pl==0&&myans) ans=true;

			else if(pl==1&&!myans) ans=false;

		}

	}

	return dp[k][pl]=ans;

}

void solve(ll caseno){

	ll i,j,k;

	cin>>n>>k;

	fo(i,0,n) cin>>arr[i];

	mset(dp,-1);

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

}

int main(){

	ios_base::sync_with_stdio(false);

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

	ll t=1;

	//cin>>t;

	for(ll i=1;i<=t;i++){

		solve(i);

	}

	return 0;

}


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

using namespace std;

typedef long long int ll;

typedef vector<ll> vi;

typedef pair<ll,ll> pii;

#define fo(i,s,e_ex) for(i=s;i<e_ex;i++)

#define Fo(i,k,n) for(i=k;k<n?i<=n:i>=n;k<n?i+=1:i-=1)

#define endl '\n'

#define MOD 1000000007//998244353

#define pbb push_back

#define mpp make_pair

#define ff first

#define ss second

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

#define mset(arr,val) memset(arr,val,sizeof(arr))

ll n;

ll arr[105];

int dp[100005];

bool play(ll k){

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

	bool ans=false;

	ll i;

	fo(i,0,n){

		if(k>=arr[i]){

			bool myans=play(k-arr[i]);

			if(myans==false) ans=true;

		}

	}

	return dp[k]=ans;

}

void solve(ll caseno){

	ll i,j,k;

	cin>>n>>k;

	fo(i,0,n) cin>>arr[i];

	// mset(dp,-1);

	// cout<<(play(k)?"First":"Second")<<endl;

	mset(dp,false);

	fo(i,0,k+1){

		fo(j,0,n){

			if(i>=arr[j]){

				bool myans=dp[i-arr[j]];

				if(myans==false) dp[i]=true;

			}

		}

	}

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

}

int main(){

	ios_base::sync_with_stdio(false);

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

	ll t=1;

	//cin>>t;

	for(ll i=1;i<=t;i++){

		solve(i);

	}

	return 0;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
/*

tarun360

IIT Indore

*/

#include <bits/stdc++.h>

using namespace std;

#define ll long long

#define ll_s long

#define mod 1000000007

#define forn(i,start,lim) for(ll i=start;i<lim;i++)

#define forn_d(i,start,lim) for(ll i=start;i>=lim;i--)

#define forn_s(i,start,lim) for(ll_s i=start;i<lim;i++)

#define forn_d_s(i,start,lim) for(ll_s i=start;i>=lim;i--)

#define f first

#define s second

#define pb push_back

#define mp make_pair

#define debug1(a) cout<<a<<endl

#define debug2(a,b) cout<<a<<" "<<b<<endl

#define debug3(a,b,c) cout<<a<<" "<<b<<" "<<c<<endl

#define debug4(a) cout<<"chu "<<a<<endl



ll a[105],amin=1e18,n;

ll memo[100005][2];



bool f(ll k, bool x){

  if(k<amin)

    return !x;

  if(memo[k][x]==0)

    return 0;

  else if(memo[k][x]==1)

    return 1;

  bool ans;

  if(x==1)

    ans=0;

  else

    ans=1;

  forn(i,0,n){

    if(x==1){

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

        ans=(ans||f(k-a[i],!x));

    }else{

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

        ans=(ans&&f(k-a[i],!x));

    }

  }

  if(ans==0) memo[k][x]=0;

  else memo[k][x]=1;

  return ans;

}



int main()

{

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

  forn(i,0,1e5+5) memo[i][0]=memo[i][1]=-1;

  ll k;

  cin>>n>>k;

  forn(i,0,n) {

    cin>>a[i];

    amin=min(amin,a[i]);

  }

  bool ans=f(k,0);

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

  else cout<<"Second"<<endl;

  return 0;

}


// Optimized solution to the same problem (faster):
/*

tarun360

IIT Indore

*/

#include <bits/stdc++.h>

using namespace std;

#define ll long long

#define ll_s long

#define mod 1000000007

#define forn(i,start,lim) for(ll i=start;i<lim;i++)

#define forn_d(i,start,lim) for(ll i=start;i>=lim;i--)

#define forn_s(i,start,lim) for(ll_s i=start;i<lim;i++)

#define forn_d_s(i,start,lim) for(ll_s i=start;i>=lim;i--)

#define f first

#define s second

#define pb push_back

#define mp make_pair

#define debug1(a) cout<<a<<endl

#define debug2(a,b) cout<<a<<" "<<b<<endl

#define debug3(a,b,c) cout<<a<<" "<<b<<" "<<c<<endl

#define debug4(a) cout<<"chu "<<a<<endl



ll a[105];

ll dp[100005];



int main()

{

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

  ll n,k;

  cin>>n>>k;

  forn(i,0,n) {

    cin>>a[i];

  }

  forn(i,1,k+1){

    forn(j,0,n){

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

        dp[i]=dp[i]||(1^dp[i-a[j]]);

    }

  }

  if(dp[k])

    cout<<"First";

  else

    cout<<"Second";

  cout<<endl;

  return 0;

}


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

#include<string.h>

using namespace std;

#define li long long int

#define mod 1000000000+7

li n,k;

li a[105];

li dp[100000+5];

void f()

{

    li i,j;

    dp[0]=0;





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

    {

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

        {

            if(i<a[j])

            {

                continue;

            }

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

            {

                dp[i]=1;



            }

        }

    }





}



int main()

{

    cin>>n>>k;



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

    li i;

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

    {

        cin>>a[i];

    }



    f();



    if(dp[k])

    {

        cout<<"First";

    }

    else

    {

        cout<<"Second";

    }

    return 0;

}


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

using namespace std;

#define li long long int

#define prDouble(x) cout<<fixed<<setprecision(10)<<x;



int main()

{

    li j,i,n,k;

    cin>>n>>k;

    li a[n];

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

    {

        cin>>a[i];

    }

    li dp[k+1];

    dp[0]=0;

    sort(a,a+n);

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

    {

        dp[i]=0;



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

        {

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

            {

                dp[i]=1;

                break;

            }

        }

    }

    if(dp[k])

    {

        cout<<"First";

    }

    else

    {

        cout<<"Second";

    }



    return 0;

}


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

using namespace std;

int n,k,arr[109];

int dp[100009][3];

int bt(int sum,int x){

	int &ret = dp[sum][x];

	if(ret != -1) return ret;

	if(x == 1) ret = 0;

	else ret = 1;

	for(int i=0;i<n&&arr[i]<=sum;i++){

		if(x == 1) ret = max(ret,bt(sum-arr[i],2));

		else ret = min(ret,bt(sum-arr[i],1));

	}

	return ret;

}

int main(){

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

	cin>>n>>k;

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

	sort(arr,arr+n);

	int ans = bt(k,1);

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

	else cout<<"First"<<endl;

}


// Optimized solution to the same problem (faster):
#define fast ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0)

#include <bits/stdc++.h>

using namespace std;

int n,k;

int a[109];

int dp[100009];

int bt(int sum){

    if(sum < 0) return 1;

    int &ret = dp[sum];

    if(ret != -1) return ret;

    ret = 0;

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

        ret = max(ret,1-bt(sum-a[i]));

    }

    return ret;

}

int main(){

    fast,cin>>n>>k;

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

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

    if(bt(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;



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



int getMax(set<int> s)

{

	int max = 0;

	while(s.find(max) != s.end())

		max++;

	return max;

}



int getGrundy(int pos, int *a, int n)

{

	if(grundy[pos] != -1)

		return grundy[pos];

	set<int> s;

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

	{

		if(a[i] > pos)

		break;

		int res = getGrundy(pos - a[i], a, n);

		s.insert(res);

	}

	return grundy[pos] = getMax(s);

}



int main() {

	int n, k;

	cin >> n >> k;

	int a[n];

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

		cin >> a[i];

	sort(a, a + n);

	grundy[0] = 0;

	grundy[k] = getGrundy(k, a, n);

	if(grundy[k])

	cout << "First\n";

	else

	cout << "Second\n";

	

	return 0;

}

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

using namespace std;

int n,k;

int f[100005];

int  a[105];

int main()

{

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

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

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

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

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

			if(i >= a[j]&& !f[i-a[j]]) f[i]=1; 

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

	else printf("Second\n");

    return 0;

}

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



using namespace std;



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

#define allr(v)				((v).rbegin()), ((v).rend())

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

#define ll long long

#define pb					push_back

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



const ll oo = 1e8;

const double pi = 3.1415926535897;





const double EPS = (1e-7);

int dcmp(double x, double y) {	return fabs(x-y) <= EPS ? 0 : x < y ? -1 : 1;	}





typedef vector<int>                vi;

typedef vector<pair<int,int>>      vii;

typedef vector<ll>                 vll;

typedef vector<double>             vd;

typedef vector< vi >               vvi;

typedef vector< vd >               vvd;

typedef vector<string>             vs;

typedef pair<int, int>             pii;



/**

    * PLEASEEE READDD PROBLEEEM CARFULLY ****

    * Always check for OVERFLOW ll vs int

    * Always check for array bounds

    * Check for function return

    * READ OUTPUT SECTION AGAIN!!!

**/



struct edge{

    int from, to, w;



    edge(){}

    edge(int x, int y, int we): from(x), to(y), w(we){}



    bool operator < (const edge &rhs) const{

        return w > rhs.w;

    }



};



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



int dp[K][3];

int a[N];

int n, ans = 0;



int sol(int k, int turn) {

    int f = 1;



    int &ret = dp[k][turn];

    if(ret != -1) return ret;



    ret = !turn;

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

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

            int ch = sol(k - a[i], turn ^ 1);

            if(turn) ret = max(ret, ch);

            else ret = min(ret, ch);

            f = 0;

        }

        else break;

    }



    if(f) {

        if(turn == 0) return 1;

        return 0;

    }



    return ret;

}



int main(){

//    fIO



//    freopen("", "r", stdin);

//    freopen("", "w", stdout);



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

    int k;

    cin >> n >> k;



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



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

}














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

using namespace std;

int n,k;

int f[100005];

int  a[105];

int main()

{

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

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

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

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

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

			if(i >= a[j]&& !f[i-a[j]]) f[i]=1; 

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

	else printf("Second\n");

    return 0;

}

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

vii v;

int dp[2][100001];

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

	if (rem < 0) return player;

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

	if (~ret) return ret;

	bool ok = 0;

	for (i, 0, n) {

		int r = solve((player + 1) % 2, rem - v[i]);

		if (r == player) ok = 1;

	}

	if (ok) return ret = player;

	else return ret = (player + 1) % 2;

}

signed main()

{

	fast;

	///cin>>t;

	while (t--)

	{

		memset(dp, -1, sizeof dp);

		cin >> n >> k;

		v = vii(n);

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

		if (solve(0, k))

			cout << "Second\n";

		else

			cout << "First\n";

	}

}


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



using namespace std;

int n,k,i,j;

int a[105];

int dp[100005];

int main()

{

    cin>>n>>k;

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

        cin>>a[i];



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

    {

        if(!dp[i])

        {

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

            {

                if(i+a[j]>k)

                    break;

                dp[i+a[j]]=1;

            }



        }

    }



    if(dp[k])

        cout<<"First";

    else

        cout<<"Second";

    return 0;

}


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

#include<ext/pb_ds/assoc_container.hpp>

#include<ext/pb_ds/tree_policy.hpp>

#define ll long long

#define M 1000000007

#define sz(a) (ll)a.size()

#define pll pair<ll,ll>

#define rep(i,a,b) for(ll i=(ll)a;i<(ll)b;i++)

#define sep(i,a,b) for(ll i=(ll)a;i>=(ll)b;i--)

#define mll map<ll,ll>

#define vl vector<ll>

#define pb push_back

#define lb lower_bound

#define ub upper_bound

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

#define F first

#define S second

using namespace __gnu_pbds;

using namespace std;

template <typename T>

using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;

ll n,k,dp[100005][2],a[105];

ll f(ll k,ll p)

{

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

		return dp[k][p];

	ll ans=1-p;

	rep(i,0,n)

	{

		if(k-a[i]<0)

			break;

		if(f(k-a[i],1-p)==p)

		{

			ans=p;

			break;

		}

	}

	dp[k][p]=ans;

	return ans;

}

int main()

{

    ios_base::sync_with_stdio(false);

    cin.tie(0);

    cout.tie(0);

    cin>>n>>k;

    rep(i,0,n)

    cin>>a[i];

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

    if(f(k,0)==0)

    	cout<<"First\n";

    else

    	cout<<"Second\n";

}


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

#include<ext/pb_ds/assoc_container.hpp>

#include<ext/pb_ds/tree_policy.hpp>

#define ll long long

#define M 1000000007

#define sz(a) (ll)a.size()

#define pll pair<ll,ll>

#define rep(i,a,b) for(ll i=(ll)a;i<(ll)b;i++)

#define sep(i,a,b) for(ll i=(ll)a;i>=(ll)b;i--)

#define mll map<ll,ll>

#define vl vector<ll>

#define pb push_back

#define lb lower_bound

#define ub upper_bound

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

#define F first

#define S second

using namespace __gnu_pbds;

using namespace std;

template <typename T>

using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;

ll n,k,dp[100005],a[105];

ll f(ll k)

{

    if(dp[k]!=-1)

        return dp[k];

    ll ans=0;

    rep(i,0,n)

    {

        if(k-a[i]<0)

            break;

        if(f(k-a[i])==0)

        {

            ans=1;

            break;

        }

    }

    dp[k]=ans;

    return ans;

}

int main()

{

    ios_base::sync_with_stdio(false);

    cin.tie(0);

    cout.tie(0);

    cin>>n>>k;

    rep(i,0,n)

    cin>>a[i];

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

    if(f(k)==1)

        cout<<"First\n";

    else

        cout<<"Second\n";

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

#include <cstdio>

#include <string>

#include <algorithm>

#include <utility>

#include <cmath>

#include <vector>

#include <queue>

#include <set>

#include <map>

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

using namespace std;

typedef long long ll;

const ll mod = 1000000007;

const int MAX_K = 100010;



vector<int> dp(MAX_K);



int main() {

    int n, k;

    cin >> n >> k;



    vector<int> a(n);

    rep(i, n) {

        cin >> a[i];

    }



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

        rep(j, n) {

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

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

            }

        }

    }



    if(dp[k]) {

        cout << "First";

    }

    else {

        cout << "Second";

    }



    cout << endl;

    return 0;

}

// Optimized solution to the same problem (faster):
#include <iostream>

#include <cstdio>

#include <string>

#include <algorithm>

#include <utility>

#include <cmath>

#include <vector>

#include <queue>

#include <set>

#include <map>

using namespace std;

typedef long long ll;

typedef vector<ll> vl;

typedef vector<vector<ll>> vvl;

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

#define exrep(i, a, b) for(ll i = a; i <= b; i++)

#define out(x) cout << x << endl

#define exout(x) printf("%.10f\n", x)

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

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

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

#define rall(a) a.rbegin(), a.rend()

#define pb push_back

#define re0 return 0

const ll mod = 1000000007;

const ll INF = 1e16;

const ll MAX_N = 100010;



int main() {

    ll n, k;

    cin >> n >> k;



    vl a(n);

    rep(i, n) {

        cin >> a[i];

    } 



    vl dp(k+1);  // dp[i] : 山に石がi個あるとき先手勝ちなら1,後手勝ちなら0

    rep(i, k+1) {  // 山に石がi個あるとき

        rep(j, n) {

            if(i - a[j] >= 0 && dp[i - a[j]] == 0) {  // 遷移先に後手勝ちがあれば先手勝ち

                dp[i] = 1;

            }

        }

    }

    

    if(dp[k] == 1) {

        out("First");

    }

    else {

        out("Second");

    }

    

    re0;

}

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



using namespace std;



vector<int >vp;

int dp[100010][2];

bool visit[3010][3010];

int n;

int  dpp(int p ,int x)

{



  if(dp[p][x]!=-1)

  return dp[p][x];





  int ans;

  ans=(x==0);

  if(x==0)

  {

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

   {

   if(p>=vp[i])

   ans=min(ans,dpp(p-vp[i],1));

   }

   return dp[p][x]=ans;



  }

  else

  {

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

   {

   if(p>=vp[i])

   ans=max(ans,dpp(p-vp[i],0));

   }

   return dp[p][x]=ans;



  }



}



int main()

{



memset(dp,-1,sizeof dp);

 int k;

 cin>>n>>k;

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

    {



        double x;

        cin>>x;

        vp.push_back(x);

    }

    int ans=dpp(k,0);



    if(ans==0)

    cout <<"First";

    else

    cout <<"Second";





}


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

using namespace std;

vector<int> vi;

int n, k, no;

const int MAX=1e5+3;

bool dp[MAX];

int main(){

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

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

        scanf("%d",&no);

        vi.push_back(no);

        dp[no]=1;

    }



    dp[0]=0;



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

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

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

                dp[i]=1;

                break;

            }

        }

    }



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

    else printf("Second\n");







    return 0;

}


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



using namespace std;

typedef long long ll;



const int N = 1e5 + 5 , OO = 0x3F3F3F3F;



int n , k , dp[N][3];

vector < int > a;



bool solve(int rem , bool p){ // rem = 100000 , 0



    //puts("beep beeep");

    if(rem < 0) return p;

    if(rem == 0) return !p;





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

    if(~ret) return ret;



    //ret = 0;

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

        if(solve(rem-a[i] , !p) == p)

            return ret = p;



    return ret = !p;





}





int main()

{





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

    a.resize(n);

    for(int& x : a)

        scanf("%d",&x);

    /*if(n == 1){

        puts("Second");

        return 0;

    }

    */

    memset(dp , -1 , sizeof dp);

    bool ans = solve(k , 0);

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







    return 0;

}


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

using namespace std;

vector<int> vi;

int n, k, no;

const int MAX=1e5+3;

bool dp[MAX];

int main(){

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

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

        scanf("%d",&no);

        vi.push_back(no);

        dp[no]=1;

    }



    dp[0]=0;



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

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

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

                dp[i]=1;

                break;

            }

        }

    }



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

    else printf("Second\n");







    return 0;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<iostream>

#include<cstdio>

#include<algorithm>

#include<cstring>

using namespace std;

typedef long long ll;

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

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

int dfs(int x)

{

	if(~dp[x])return dp[x];

	bool win=0;

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

	{

		if(x-a[i]<0)continue;

		win|=(dfs(x-a[i])==0); 

	}

	return dp[x]=win;

}

int main()

{

	memset(dp,-1,sizeof dp);

	dp[0]=0;//0先手败 大于0先手胜

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

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

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

	puts(dfs(k)?"First":"Second");

	//for(int i=1;i<=5;++i)

	//printf("%d:%d\n",i,dp[i]);

	return 0;

}

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

using namespace std;

vector<int> vi;

int n, k, no;

const int MAX=1e5+3;

bool dp[MAX];

int main(){

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

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

        scanf("%d",&no);

        vi.push_back(no);

        dp[no]=1;

    }



    dp[0]=0;



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

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

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

                dp[i]=1;

                break;

            }

        }

    }



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

    else printf("Second\n");







    return 0;

}


// Fastest known solution for this problem: