stablegradients/pie-gem5-pairs huggingface dataset:
// Slower C++ solution:
#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;

}

// Faster C++ solution for the same problem (measured speedup: 1.4954040179047359x):
#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;

}
// Slower C++ solution:
#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";

}














// Faster C++ solution for the same problem (measured speedup: 2.2701961005552502x):
#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;

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

#define int long long

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

using namespace std;

#define endl '\n'

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

#define vii vector<int>

int 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";

	}

}


// Faster C++ solution for the same problem (measured speedup: 2.757141170090653x):
#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;

}
// Slower C++ solution:
#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";

}


// Faster C++ solution for the same problem (measured speedup: 1.4462057713430023x):
#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";

}
// Slower C++ solution:
#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;

}

// Faster C++ solution for the same problem (measured speedup: 1.3672827391326698x):
#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;

}
// Slower C++ solution:
#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";





}


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

using namespace std;

#define N (int)2e5

int n,k,a[N];

bool memo[N],vis[N];



bool dp(int rem) {

    if (rem == 0) return false;

    bool &sol = memo[rem];

    if (vis[rem]) return sol;

    vis[rem] = true;

    bool win = false;

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

        if (rem >= a[i]) {

            bool DP = dp(rem - a[i]);

            if (!DP) win = true;

        }

    return sol = win;

}



int main() {

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

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

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

    bool DP = dp(k);

    printf(DP ? "First\n" : "Second\n");

}
// Slower C++ solution:
#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";





}


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

#define ll long long

using namespace std;

int main(){

    ll dp[100099],n,k,a[100099];

    cin >> n >> k;

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

    dp[0]=0;

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

        bool z=0;

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

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

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

                    z=1;

                    break;

                }

            }

        }

        if(z)dp[i]=1;

        else dp[i]=0;

    }

    string s[2]={"Second\n","First"};

    cout << s[dp[k]];

    

}
// Slower C++ solution:
#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";





}


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

#define ll long long

#define ld long double

#define ull unsigned ll

#define ioi exit(0);

 

#define f first

#define s second

 

#define inf (int)1e9 + 7

 

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

 

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

 

#define lb(x) lower_bound(x)

#define ub(x) upper_bound(x)

 

#define pb push_back

#define ppb pop_back

 

#define bitcoin __builtin_popcount

 

#define endl "\n"

 

#define in(x) insert(x)

 

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

 

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

 

#define pw2(x) (1ll<<x) //2^x

 

#define forit(it,v) for (typeof(v.begin()) it = v.begin(); it != v.end(); ++it)

 

#define sqr(x) ((x) * 1ll * (x))

 

#define UpdateRandom srand (time(NULL));

 

using namespace std;

 

const int N = (int)5e5 + 7, MOD = (int)1e9 + 7;



int n,k,ans;

int a[N];

int dp[N][4];

bool was[N][4];



int calc(int x,int cur){

	if(was[x][cur])return dp[x][cur];

	was[x][cur]=1;

	bool found=0;

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

		if(x+a[i]<=k){

			if(calc(x+a[i],(cur^1))==cur)found=1;	

		}

	}

	if(found)return dp[x][cur]=cur;

	else return dp[x][cur]=(cur^1);

}



int main(){

		

	NFS



	cin >> n >> k;

	

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

		cin >> a[i];

	}

	

	if(calc(0,0)==0){

		cout << "First" << endl;

	}

	else cout << "Second" << endl;

	

	ioi

}
// Slower C++ solution:
#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";





}


// Faster C++ solution for the same problem (measured speedup: 1.8741161103949744x):
//by Top

#include <bits/stdc++.h>

     

#define f first

#define s second

#define int long long

#define ld long double

#define ull unsigned long long

#define pii pair <int, int>

#define pll pair <long, long>

#define mp make_pair

#define pb push_back

#define pf push_front

#define pp pop_back

#define rev reverse

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

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

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

#define boost ios_base::sync_with_stdio(false); cin.tie(0),cout.tie(0);

#define nxtp next_permutation

#define pvtp prev_permutation

#define KZ return 

#define x1 x21212121

#define y1 y21212121

#define sqr(x) x * x 

 

const int inf = (1e9) + 1;

const int mod = 1e9 + 7;

const int maxn = 2e5 + 111;

     

using namespace std;



int n, q, a[maxn], dp[maxn], k, mn = inf;

                           

void solve(){

	cin >> n >> k;



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

    	cin >> a[i];

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

    }



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



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

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

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

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

   					dp[i] = 1;

   			}

   			else

   				break;

   		}

   	}



   	if (dp[k] == 1)

   		cout << "First";

   	else

   		cout << "Second";

}



main(){

    boost;

	    

	q = 1;



	while (q--){

		solve();

	}

}
// Slower C++ solution:
#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";





}


// Faster C++ solution for the same problem (measured speedup: 1.314917642688395x):
#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;

}
// Slower C++ solution:
#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;

}


// Faster C++ solution for the same problem (measured speedup: 1.5936469046410848x):
#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;

}
// Slower C++ solution:
#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";





}


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

#include <vector>

#include <algorithm>



using namespace std;

int x,k,n,poz,dp[100005];

vector <int> v;

int mex(vector <int> &v)

{

    sort(v.begin(), v.end());

    for(int i=0;i<v.size();i++)

    {

        if(v[i]!=i)

            return i;

    }

    return v.size();

}

int calc(int poz)

{

    vector <int> vmex;

    for(int it : v)

    {

        if(poz-it>=0)

            vmex.push_back(dp[poz-it]);

    }

    return mex(vmex);

}

int main()

{

    cin>>n>>k;

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

    {

        cin>>x;

        v.push_back(x);

    }

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

        dp[poz]=calc(poz);



    if(dp[k])

        cout<<"First";

    else

        cout<<"Second";

    return 0;

}
// Slower C++ solution:
#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;

}


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

#include <vector>

#include <algorithm>



using namespace std;

int x,k,n,poz,dp[100005];

vector <int> v;

int mex(vector <int> &v)

{

    sort(v.begin(), v.end());

    for(int i=0;i<v.size();i++)

    {

        if(v[i]!=i)

            return i;

    }

    return v.size();

}

int calc(int poz)

{

    vector <int> vmex;

    for(int it : v)

    {

        if(poz-it>=0)

            vmex.push_back(dp[poz-it]);

    }

    return mex(vmex);

}

int main()

{

    cin>>n>>k;

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

    {

        cin>>x;

        v.push_back(x);

    }

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

        dp[poz]=calc(poz);



    if(dp[k])

        cout<<"First";

    else

        cout<<"Second";

    return 0;

}