stablegradients/pie-gem5-pairs huggingface dataset:
// 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: 2.0148028506199456x):
#pragma region

#include <algorithm>

#include <cstring>

#include <iomanip>

#include <iostream>

#include <map>

#include <queue>

#include <stack>

#include <string>

#include <vector>

typedef long long ll;

#define rep(i, a, n) for (long long i = a; i <= n; ++i)

#define per(i, a, n) for (long long i = n; i >= a; --i)

#define IO ios::sync_with_stdio(false), cin.tie(0), cout.tie(0)

using namespace std;

/*

 *                                                     __----~~~~~~~~~~~------___

 *                                    .  .   ~~//====......          __--~ ~~

 *                    -.            \_|//     |||\\  ~~~~~~::::... /~

 *                 ___-==_       _-~o~  \/    |||  \\            _/~~-

 *         __---~~~.==~||\=_    -_--~/_-~|-   |\\   \\        _/~

 *     _-~~     .=~    |  \\-_    '-~7  /-   /  ||    \      /

 *   .~       .~       |   \\ -_    /  /-   /   ||      \   /

 *  /  ____  /         |     \\ ~-_/  /|- _/   .||       \ /

 *  |~~    ~~|--~~~~--_ \     ~==-/   | \~--===~~        .\

 *           '         ~-|      /|    |-~\~~       __--~~

 *                       |-~~-_/ |    |   ~\_   _-~            /\

 *                            /  \     \__   \/~                \__

 *                        _--~ _/ | .-~~____--~-/                  ~~==.

 *                       ((->/~   '.|||' -_|    ~~-/ ,              . _||

 *                                  -_     ~\      ~~---l__i__i__i--~~_/

 *                                  _-~-__   ~)  \--______________--~~

 *                                //.-~~~-~_--~- |-------~~~~~~~~

 *                                       //.-~~~--\

 *                       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 */

#pragma endregion

const int maxn = 105;

bool dp[int(1e7 + 5)][2];

int n, k, a[maxn];

bool dfs(int x, bool f) {

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

    bool flag = 0;

    rep(i, 1, n) if (x >= a[i]) {

        if (!dfs(x - a[i], 1 - f))

            flag = 1;

    }

    return dp[x][f] = flag;

}

int main() {

    IO;

    cin >> n >> k;

    rep(i, 1, n) cin >> a[i];

    cout << (dfs(k, 0) ? "First\n" : "Second\n");

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

}

// Faster C++ solution for the same problem (measured speedup: 1.2642718062278115x):
#pragma region

#include <algorithm>

#include <cstring>

#include <iomanip>

#include <iostream>

#include <map>

#include <queue>

#include <stack>

#include <string>

#include <vector>

typedef long long ll;

#define rep(i, a, n) for (long long i = a; i <= n; ++i)

#define per(i, a, n) for (long long i = n; i >= a; --i)

#define IO ios::sync_with_stdio(false), cin.tie(0), cout.tie(0)

using namespace std;

/*

 *                                                     __----~~~~~~~~~~~------___

 *                                    .  .   ~~//====......          __--~ ~~

 *                    -.            \_|//     |||\\  ~~~~~~::::... /~

 *                 ___-==_       _-~o~  \/    |||  \\            _/~~-

 *         __---~~~.==~||\=_    -_--~/_-~|-   |\\   \\        _/~

 *     _-~~     .=~    |  \\-_    '-~7  /-   /  ||    \      /

 *   .~       .~       |   \\ -_    /  /-   /   ||      \   /

 *  /  ____  /         |     \\ ~-_/  /|- _/   .||       \ /

 *  |~~    ~~|--~~~~--_ \     ~==-/   | \~--===~~        .\

 *           '         ~-|      /|    |-~\~~       __--~~

 *                       |-~~-_/ |    |   ~\_   _-~            /\

 *                            /  \     \__   \/~                \__

 *                        _--~ _/ | .-~~____--~-/                  ~~==.

 *                       ((->/~   '.|||' -_|    ~~-/ ,              . _||

 *                                  -_     ~\      ~~---l__i__i__i--~~_/

 *                                  _-~-__   ~)  \--______________--~~

 *                                //.-~~~-~_--~- |-------~~~~~~~~

 *                                       //.-~~~--\

 *                       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 */

#pragma endregion

const int maxn = 105;

bool dp[int(1e7 + 5)][2];

int n, k, a[maxn];

bool dfs(int x, bool f) {

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

    bool flag = 0;

    rep(i, 1, n) if (x >= a[i]) {

        if (!dfs(x - a[i], 1 - f))

            flag = 1;

    }

    return dp[x][f] = flag;

}

int main() {

    IO;

    cin >> n >> k;

    rep(i, 1, n) cin >> a[i];

    cout << (dfs(k, 0) ? "First\n" : "Second\n");

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

using namespace std;

#define endl '\n'

int n,k,arr[101],mi=10000000;

int dp[100010];

int dfs(int u){

	if(u<mi)return 0;

	int &res=dp[u];

	if(~res)return res;

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

		if(u>=arr[i] && !dfs(u-arr[i]))return res=1;

	}

	return res=0;

}



int main()

{

	ios_base::sync_with_stdio(false);

	cin.tie(0);

	cout.tie(0);

	memset(dp,-1,sizeof dp);

	cin>>n>>k;

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

		cin>>arr[i];

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

	}



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





	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.2839625545569429x):
#pragma region

#include <algorithm>

#include <cstring>

#include <iomanip>

#include <iostream>

#include <map>

#include <queue>

#include <stack>

#include <string>

#include <vector>

typedef long long ll;

#define rep(i, a, n) for (long long i = a; i <= n; ++i)

#define per(i, a, n) for (long long i = n; i >= a; --i)

#define IO ios::sync_with_stdio(false), cin.tie(0), cout.tie(0)

using namespace std;

/*

 *                                                     __----~~~~~~~~~~~------___

 *                                    .  .   ~~//====......          __--~ ~~

 *                    -.            \_|//     |||\\  ~~~~~~::::... /~

 *                 ___-==_       _-~o~  \/    |||  \\            _/~~-

 *         __---~~~.==~||\=_    -_--~/_-~|-   |\\   \\        _/~

 *     _-~~     .=~    |  \\-_    '-~7  /-   /  ||    \      /

 *   .~       .~       |   \\ -_    /  /-   /   ||      \   /

 *  /  ____  /         |     \\ ~-_/  /|- _/   .||       \ /

 *  |~~    ~~|--~~~~--_ \     ~==-/   | \~--===~~        .\

 *           '         ~-|      /|    |-~\~~       __--~~

 *                       |-~~-_/ |    |   ~\_   _-~            /\

 *                            /  \     \__   \/~                \__

 *                        _--~ _/ | .-~~____--~-/                  ~~==.

 *                       ((->/~   '.|||' -_|    ~~-/ ,              . _||

 *                                  -_     ~\      ~~---l__i__i__i--~~_/

 *                                  _-~-__   ~)  \--______________--~~

 *                                //.-~~~-~_--~- |-------~~~~~~~~

 *                                       //.-~~~--\

 *                       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 */

#pragma endregion

const int maxn = 105;

bool dp[int(1e7 + 5)][2];

int n, k, a[maxn];

bool dfs(int x, bool f) {

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

    bool flag = 0;

    rep(i, 1, n) if (x >= a[i]) {

        if (!dfs(x - a[i], 1 - f))

            flag = 1;

    }

    return dp[x][f] = flag;

}

int main() {

    IO;

    cin >> n >> k;

    rep(i, 1, n) cin >> a[i];

    cout << (dfs(k, 0) ? "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.7246252562211177x):
#include<bits/stdc++.h>

#define REP(x,y,z) for(int x=y;x<=z;x++)

#define MSET(x,y) memset(x,y,sizeof(x))

#define M 100005

using namespace std;

int n,k,a[105],dp[M];

bool vis[M];

int dfs(int cur) {

    if (vis[cur]) return dp[cur];

    if (cur == 0) return 0;

    vis[cur] = true;

    int &res = dp[cur];



    res = 0;

    REP(i,1,n) if(cur >= a[i] && !dfs(cur-a[i])) {

        res = 1;

    }

    return res;

}

int main()

{

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

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

    printf("%s\n", dfs(k) ? "First" : "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: 2.0902021632498085x):
#include<bits/stdc++.h>

#define REP(x,y,z) for(int x=y;x<=z;x++)

#define MSET(x,y) memset(x,y,sizeof(x))

#define M 100005

using namespace std;

int n,k,a[105],dp[M];

bool vis[M];

int dfs(int cur) {

    if (vis[cur]) return dp[cur];

    if (cur == 0) return 0;

    vis[cur] = true;

    int &res = dp[cur];



    res = 0;

    REP(i,1,n) if(cur >= a[i] && !dfs(cur-a[i])) {

        res = 1;

    }

    return res;

}

int main()

{

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

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

    printf("%s\n", dfs(k) ? "First" : "Second");

    return 0;

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

}

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

#define REP(x,y,z) for(int x=y;x<=z;x++)

#define MSET(x,y) memset(x,y,sizeof(x))

#define M 100005

using namespace std;

int n,k,a[105],dp[M];

bool vis[M];

int dfs(int cur) {

    if (vis[cur]) return dp[cur];

    if (cur == 0) return 0;

    vis[cur] = true;

    int &res = dp[cur];



    res = 0;

    REP(i,1,n) if(cur >= a[i] && !dfs(cur-a[i])) {

        res = 1;

    }

    return res;

}

int main()

{

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

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

    printf("%s\n", dfs(k) ? "First" : "Second");

    return 0;

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

using namespace std;

#define endl '\n'

int n,k,arr[101],mi=10000000;

int dp[100010];

int dfs(int u){

	if(u<mi)return 0;

	int &res=dp[u];

	if(~res)return res;

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

		if(u>=arr[i] && !dfs(u-arr[i]))return res=1;

	}

	return res=0;

}



int main()

{

	ios_base::sync_with_stdio(false);

	cin.tie(0);

	cout.tie(0);

	memset(dp,-1,sizeof dp);

	cin>>n>>k;

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

		cin>>arr[i];

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

	}



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





	return 0;

}

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

#define REP(x,y,z) for(int x=y;x<=z;x++)

#define MSET(x,y) memset(x,y,sizeof(x))

#define M 100005

using namespace std;

int n,k,a[105],dp[M];

bool vis[M];

int dfs(int cur) {

    if (vis[cur]) return dp[cur];

    if (cur == 0) return 0;

    vis[cur] = true;

    int &res = dp[cur];



    res = 0;

    REP(i,1,n) if(cur >= a[i] && !dfs(cur-a[i])) {

        res = 1;

    }

    return res;

}

int main()

{

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

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

    printf("%s\n", dfs(k) ? "First" : "Second");

    return 0;

}
// Slower C++ solution:
#define _CRT_SECURE_NO_WARNINGS

#include<bits/stdc++.h>

#include<iostream>

#include<algorithm>

#include<iomanip>

#include<string>

#include<cmath>

#include<vector>

#include<set>

#include<queue>

#include<stack>

#include<fstream>

#include<map>

#include<bitset>

#include<unordered_map>

#include<cstring>

#include<cctype>

using namespace std;

#define  ll long long

#define  ull unsigned long long

#define  ul unsigned long

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

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

#define pb(s) push_back(s);

#define format(n) fixed<<setprecision(n)

#define finl "\n"

#define Mohammed_Atef_Hassan fast();

#define mod 1000000007

#define INF LLONG_MAX

#define PI acos(-1)

#define clr(dp,n) memset(dp,n,sizeof dp)

#define ex(n) return cout<<n<<finl,0;

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

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

ll fix_mod(ll x, ll y)

{

	return (y + x % y) % y;

}

void fast() {

	std::ios_base::sync_with_stdio(false);

	cin.tie(nullptr); cout.tie(nullptr);



#ifdef ONLINE_JUDGE

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



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

#endif

#ifndef ONLINE_JUDGE

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

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

#endif

}

vector<int>v;

int mem[(int)1e5 + 10][3];

int solve(int k, int c)

{

	int& ret = mem[k][c];

	if (~ret)return ret;

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

	{

		if (k >= v[i])

		{

			if (solve(k - v[i], c % 2 + 1) == c)return ret=c;

		}

	}

	return ret= c % 2 + 1;

}

int main()

{

	Mohammed_Atef_Hassan

		clr(mem, -1);

		int n, k;

	cin >> n >> k;

	v = vector<int>(n);

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

	cout << (solve(k, 1) == 1 ? "First" : "Second") << finl;

}

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

#define REP(x,y,z) for(int x=y;x<=z;x++)

#define MSET(x,y) memset(x,y,sizeof(x))

#define M 100005

using namespace std;

int n,k,a[105],dp[M];

bool vis[M];

int dfs(int cur) {

    if (vis[cur]) return dp[cur];

    if (cur == 0) return 0;

    vis[cur] = true;

    int &res = dp[cur];



    res = 0;

    REP(i,1,n) if(cur >= a[i] && !dfs(cur-a[i])) {

        res = 1;

    }

    return res;

}

int main()

{

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

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

    printf("%s\n", dfs(k) ? "First" : "Second");

    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.9406432896716221x):
#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;

}
// 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: 2.352010552748033x):
#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;

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

}

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

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

using namespace std;

#define endl '\n'

int n,k,arr[101],mi=10000000;

int dp[100010];

int dfs(int u){

	if(u<mi)return 0;

	int &res=dp[u];

	if(~res)return res;

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

		if(u>=arr[i] && !dfs(u-arr[i]))return res=1;

	}

	return res=0;

}



int main()

{

	ios_base::sync_with_stdio(false);

	cin.tie(0);

	cout.tie(0);

	memset(dp,-1,sizeof dp);

	cin>>n>>k;

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

		cin>>arr[i];

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

	}



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





	return 0;

}

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

}
// Slower C++ solution:
#define _CRT_SECURE_NO_WARNINGS

#include<bits/stdc++.h>

#include<iostream>

#include<algorithm>

#include<iomanip>

#include<string>

#include<cmath>

#include<vector>

#include<set>

#include<queue>

#include<stack>

#include<fstream>

#include<map>

#include<bitset>

#include<unordered_map>

#include<cstring>

#include<cctype>

using namespace std;

#define  ll long long

#define  ull unsigned long long

#define  ul unsigned long

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

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

#define pb(s) push_back(s);

#define format(n) fixed<<setprecision(n)

#define finl "\n"

#define Mohammed_Atef_Hassan fast();

#define mod 1000000007

#define INF LLONG_MAX

#define PI acos(-1)

#define clr(dp,n) memset(dp,n,sizeof dp)

#define ex(n) return cout<<n<<finl,0;

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

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

ll fix_mod(ll x, ll y)

{

	return (y + x % y) % y;

}

void fast() {

	std::ios_base::sync_with_stdio(false);

	cin.tie(nullptr); cout.tie(nullptr);



#ifdef ONLINE_JUDGE

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



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

#endif

#ifndef ONLINE_JUDGE

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

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

#endif

}

vector<int>v;

int mem[(int)1e5 + 10][3];

int solve(int k, int c)

{

	int& ret = mem[k][c];

	if (~ret)return ret;

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

	{

		if (k >= v[i])

		{

			if (solve(k - v[i], c % 2 + 1) == c)return ret=c;

		}

	}

	return ret= c % 2 + 1;

}

int main()

{

	Mohammed_Atef_Hassan

		clr(mem, -1);

		int n, k;

	cin >> n >> k;

	v = vector<int>(n);

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

	cout << (solve(k, 1) == 1 ? "First" : "Second") << finl;

}

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

}