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

}

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

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

}


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

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

}

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

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

}






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

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

}


// Faster C++ solution for the same problem (measured speedup: 1.500503000892427x):
// Author : Mohamed Sameh

#include <bits/stdc++.h>

typedef long long ll ;

#define pb push_back

#define f first

#define s second

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

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

#define SZ(a) (int)a.size()

#define Flush fflush(stdout);

using namespace std ;

const int N = 1e2+1, M = 1e5+1;

int n, k, a[N], can[M];

int main()

{

  cin >> n >> k ;

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

    cin >> a[i];

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

    for (int j = 0; j < n && !can[i] && a[j] <= i; j++)

      if (!can[i - a[j]])

        can[i] = 1;

  cout << (can[k] ? "First\n" : "Second\n");

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

}

// Faster C++ solution for the same problem (measured speedup: 1.883976678900557x):
// Author : Mohamed Sameh

#include <bits/stdc++.h>

typedef long long ll ;

#define pb push_back

#define f first

#define s second

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

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

#define SZ(a) (int)a.size()

#define Flush fflush(stdout);

using namespace std ;

const int N = 1e2+1, M = 1e5+1;

int n, k, a[N], can[M];

int main()

{

  cin >> n >> k ;

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

    cin >> a[i];

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

    for (int j = 0; j < n && !can[i] && a[j] <= i; j++)

      if (!can[i - a[j]])

        can[i] = 1;

  cout << (can[k] ? "First\n" : "Second\n");

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

}


// Faster C++ solution for the same problem (measured speedup: 1.869058610794958x):
// Author : Mohamed Sameh

#include <bits/stdc++.h>

typedef long long ll ;

#define pb push_back

#define f first

#define s second

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

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

#define SZ(a) (int)a.size()

#define Flush fflush(stdout);

using namespace std ;

const int N = 1e2+1, M = 1e5+1;

int n, k, a[N], can[M];

int main()

{

  cin >> n >> k ;

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

    cin >> a[i];

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

    for (int j = 0; j < n && !can[i] && a[j] <= i; j++)

      if (!can[i - a[j]])

        can[i] = 1;

  cout << (can[k] ? "First\n" : "Second\n");

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

}

// Faster C++ solution for the same problem (measured speedup: 1.3879151820955926x):
// Author : Mohamed Sameh

#include <bits/stdc++.h>

typedef long long ll ;

#define pb push_back

#define f first

#define s second

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

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

#define SZ(a) (int)a.size()

#define Flush fflush(stdout);

using namespace std ;

const int N = 1e2+1, M = 1e5+1;

int n, k, a[N], can[M];

int main()

{

  cin >> n >> k ;

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

    cin >> a[i];

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

    for (int j = 0; j < n && !can[i] && a[j] <= i; j++)

      if (!can[i - a[j]])

        can[i] = 1;

  cout << (can[k] ? "First\n" : "Second\n");

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

}






// Faster C++ solution for the same problem (measured speedup: 1.889253582429877x):
// Author : Mohamed Sameh

#include <bits/stdc++.h>

typedef long long ll ;

#define pb push_back

#define f first

#define s second

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

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

#define SZ(a) (int)a.size()

#define Flush fflush(stdout);

using namespace std ;

const int N = 1e2+1, M = 1e5+1;

int n, k, a[N], can[M];

int main()

{

  cin >> n >> k ;

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

    cin >> a[i];

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

    for (int j = 0; j < n && !can[i] && a[j] <= i; j++)

      if (!can[i - a[j]])

        can[i] = 1;

  cout << (can[k] ? "First\n" : "Second\n");

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

}


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

#define eps 1e-3

#define pi acos(-1.0)

#define inf 0x3f

#define INF 0x3f3f3f3f

#define pb push_back

#define debug1 cout<<"&&";

#define debug2 cout<<"**";

#define ms(a, x) memset(a, x, sizeof(a))

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

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

using namespace std;

typedef double db;

typedef long long ll;

typedef unsigned long long ull;

typedef pair<int, int> pii;

typedef pair<long long, int> pli;

typedef pair<long long, long long> pll;

const int mod = 1e9 + 7;

const int N = 1e5+10;

const int M = 1e6+10;

/*=================================================================================*/



int n, k, a[200], dp[N][2], p;



bool dfs(int num, int person) {

   if(dp[num][person]) return dp[num][person];

   int ans=0;

   for1(i, n) {

      if(a[i] <= num) ans |= !dfs(num - a[i], person^1);

   }

   dp[num][person] = ans;

   return ans;

}





int main() {

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

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

   bool ans = dfs(k, 1);

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

   return 0;

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

}

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

#define eps 1e-3

#define pi acos(-1.0)

#define inf 0x3f

#define INF 0x3f3f3f3f

#define pb push_back

#define debug1 cout<<"&&";

#define debug2 cout<<"**";

#define ms(a, x) memset(a, x, sizeof(a))

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

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

using namespace std;

typedef double db;

typedef long long ll;

typedef unsigned long long ull;

typedef pair<int, int> pii;

typedef pair<long long, int> pli;

typedef pair<long long, long long> pll;

const int mod = 1e9 + 7;

const int N = 1e5+10;

const int M = 1e6+10;

/*=================================================================================*/



int n, k, a[200], dp[N][2], p;



bool dfs(int num, int person) {

   if(dp[num][person]) return dp[num][person];

   int ans=0;

   for1(i, n) {

      if(a[i] <= num) ans |= !dfs(num - a[i], person^1);

   }

   dp[num][person] = ans;

   return ans;

}





int main() {

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

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

   bool ans = dfs(k, 1);

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

   return 0;

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

}


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

#define eps 1e-3

#define pi acos(-1.0)

#define inf 0x3f

#define INF 0x3f3f3f3f

#define pb push_back

#define debug1 cout<<"&&";

#define debug2 cout<<"**";

#define ms(a, x) memset(a, x, sizeof(a))

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

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

using namespace std;

typedef double db;

typedef long long ll;

typedef unsigned long long ull;

typedef pair<int, int> pii;

typedef pair<long long, int> pli;

typedef pair<long long, long long> pll;

const int mod = 1e9 + 7;

const int N = 1e5+10;

const int M = 1e6+10;

/*=================================================================================*/



int n, k, a[200], dp[N][2], p;



bool dfs(int num, int person) {

   if(dp[num][person]) return dp[num][person];

   int ans=0;

   for1(i, n) {

      if(a[i] <= num) ans |= !dfs(num - a[i], person^1);

   }

   dp[num][person] = ans;

   return ans;

}





int main() {

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

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

   bool ans = dfs(k, 1);

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

   return 0;

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

}

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

#define eps 1e-3

#define pi acos(-1.0)

#define inf 0x3f

#define INF 0x3f3f3f3f

#define pb push_back

#define debug1 cout<<"&&";

#define debug2 cout<<"**";

#define ms(a, x) memset(a, x, sizeof(a))

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

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

using namespace std;

typedef double db;

typedef long long ll;

typedef unsigned long long ull;

typedef pair<int, int> pii;

typedef pair<long long, int> pli;

typedef pair<long long, long long> pll;

const int mod = 1e9 + 7;

const int N = 1e5+10;

const int M = 1e6+10;

/*=================================================================================*/



int n, k, a[200], dp[N][2], p;



bool dfs(int num, int person) {

   if(dp[num][person]) return dp[num][person];

   int ans=0;

   for1(i, n) {

      if(a[i] <= num) ans |= !dfs(num - a[i], person^1);

   }

   dp[num][person] = ans;

   return ans;

}





int main() {

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

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

   bool ans = dfs(k, 1);

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

   return 0;

}