stablegradients/pie-gem5-pairs huggingface dataset:
// 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.2641596869990734x):
#include <iostream>

#include <set>

#include <string>

#include <algorithm>

#define ll long long

#define mod 998244353



using namespace std;



int n, k, arr[110], dp[100005];



string solve()

{

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

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

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

				dp[i] = 1;

	if (dp[k] == 1)return "First";

	return "Second";

}



int main()

{

	cin >> n >> k;

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

		cin >> arr[i];

	cout << solve() << '\n';

	return 0;

}
// 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.4695821918114529x):
#include <bits/stdc++.h>

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

#define ll long long

#define INF 0x3f3f3f3f3f3f3f3f

using namespace std;





int main()

{

    HS

    int n,k;

    cin>>n>>k;

    int arr[n+5];

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

        cin>>arr[i];

    int dp[k+1]={0};

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

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

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

            dp[i]=1;



if(dp[k]==1)

    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.223393515854344x):
#include <bits/stdc++.h>

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

#define ll long long

#define INF 0x3f3f3f3f3f3f3f3f

using namespace std;





int main()

{

    HS

    int n,k;

    cin>>n>>k;

    int arr[n+5];

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

        cin>>arr[i];

    int dp[k+1]={0};

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

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

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

            dp[i]=1;



if(dp[k]==1)

    cout << "First";

else

    cout << "Second";





    return 0;

}
// 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.3954192661193352x):
#include <iostream>

#include <unordered_map>

#include <map>

#include <vector>

#include <stack>

#include <algorithm>

#include <list>

#include <set>

#include <climits>

#include <cmath>

#define lli long long int

#define M 1000000007

using namespace std ;



int eval(vector<int> &a, int k, int player, vector<vector<int> > &dp)

{

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



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

	{

		int temp ;

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

		{

			temp = eval(a,k-a[i],1-player,dp) ;

			if(temp == player) return dp[player][k] = player ;

		}

	} 



	return dp[player][k] = 1 - player ;

}



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

{

	int n,k ;

	cin>>n>>k ;



	vector<int> a(n) ;

	vector<vector<int> > dp(2, vector<int> (k+1,-1)) ;

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



	int ans = eval(a,k,0,dp) ;

	

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

	else cout<<"First"<<endl ;



	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: 1.985504643084689x):
#include <iostream>

#include <unordered_map>

#include <map>

#include <vector>

#include <stack>

#include <algorithm>

#include <list>

#include <set>

#include <climits>

#include <cmath>

#define lli long long int

#define M 1000000007

using namespace std ;



int eval(vector<int> &a, int k, int player, vector<vector<int> > &dp)

{

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



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

	{

		int temp ;

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

		{

			temp = eval(a,k-a[i],1-player,dp) ;

			if(temp == player) return dp[player][k] = player ;

		}

	} 



	return dp[player][k] = 1 - player ;

}



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

{

	int n,k ;

	cin>>n>>k ;



	vector<int> a(n) ;

	vector<vector<int> > dp(2, vector<int> (k+1,-1)) ;

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



	int ans = eval(a,k,0,dp) ;

	

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

	else cout<<"First"<<endl ;



	return 0 ;

}
// 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.4647292577314577x):
#include <bits/stdc++.h>

using namespace std;

using ll = long long;

using PII = pair<int, int>;

using VI = vector<int>;



int main() {

#ifdef LOCAL_EXEC

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

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

#else

  ios_base::sync_with_stdio(false); cin.tie(NULL);

#endif



  int n; cin >> n;

  int k; cin >> k;

  vector<int> a(n);

  for (int& x: a) cin >> x;



  vector<bool> win(k + 1);

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

    for (int x: a) {

      if (x <= y && !win[y - x]) {

        win[y] = true;

        break;

      }

    }

  }

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



  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.228150281501927x):
#include <bits/stdc++.h>

using namespace std;

using ll = long long;

using PII = pair<int, int>;

using VI = vector<int>;



int main() {

#ifdef LOCAL_EXEC

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

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

#else

  ios_base::sync_with_stdio(false); cin.tie(NULL);

#endif



  int n; cin >> n;

  int k; cin >> k;

  vector<int> a(n);

  for (int& x: a) cin >> x;



  vector<bool> win(k + 1);

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

    for (int x: a) {

      if (x <= y && !win[y - x]) {

        win[y] = true;

        break;

      }

    }

  }

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



  return 0;

}
// 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.4069517002564638x):
#include<bits/stdc++.h>

using namespace std;

typedef long long int ll;



map<int,bool>mp;



int main()

{



    int n,k;

    cin>>n>>k;

    int a[n+5];

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

        cin>>a[i];



    for(int rem=0 ; rem<=k; rem++)

    {

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

        {

            if(a[i]>rem)

                continue;

            if(mp[rem-a[i]]==false)

                mp[rem]=true;

        }

    }



    if(mp[k]==true)

        cout<<"First"<<endl;

    else

        cout<<"Second"<<endl;

    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.1955858604524012x):
#include<bits/stdc++.h>

using namespace std;

typedef long long int ll;



map<int,bool>mp;



int main()

{



    int n,k;

    cin>>n>>k;

    int a[n+5];

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

        cin>>a[i];



    for(int rem=0 ; rem<=k; rem++)

    {

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

        {

            if(a[i]>rem)

                continue;

            if(mp[rem-a[i]]==false)

                mp[rem]=true;

        }

    }



    if(mp[k]==true)

        cout<<"First"<<endl;

    else

        cout<<"Second"<<endl;

    return 0;

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

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

}