stablegradients/pie-gem5-pairs huggingface dataset:
// 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.4863601078317208x):
#include <bits/stdc++.h>

#define ll long long

#define ull unsigned ll

#define ld long double

#define pll pair<ll, ll>

#define pii pair<int, int>

#define f first

#define se second

#define pb push_back

#define ft fflush(stdout)

 

 

using namespace std;

 

 

const int N = 2e5 + 123;

const int PLS = 3e5 + 123;

const int mod = 1e9 + 7;

const ll inf = 1e16;





ll n, a[N], k;

bool dp[N];





int main() {

    ios_base::sync_with_stdio(NULL);

    cin.tie(NULL); cout.tie(NULL);

    cin >> n >> k;

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

        cin >> a[i];

    dp[0] = 0;

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

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

            if (i >= a[j])

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

    if (dp[k])

        cout << "First";

    else

        cout << "Second";

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

#define ll long long

#define ull unsigned ll

#define ld long double

#define pll pair<ll, ll>

#define pii pair<int, int>

#define f first

#define se second

#define pb push_back

#define ft fflush(stdout)

 

 

using namespace std;

 

 

const int N = 2e5 + 123;

const int PLS = 3e5 + 123;

const int mod = 1e9 + 7;

const ll inf = 1e16;





ll n, a[N], k;

bool dp[N];





int main() {

    ios_base::sync_with_stdio(NULL);

    cin.tie(NULL); cout.tie(NULL);

    cin >> n >> k;

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

        cin >> a[i];

    dp[0] = 0;

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

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

            if (i >= a[j])

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

    if (dp[k])

        cout << "First";

    else

        cout << "Second";

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

 

#define int long long

//#pragma GCC optimize("Ofast")

//#pragma comment(linker, "/stack:200000000")

//#pragma GCC target("sse,sse2,sse3,ssse3,sse4")

 

 

#define file(s) freopen(s".in","r",stdin); freopen(s".out","w",stdout);

#define forev(i, b, a) for(int i = (b); i >= (a); --i)

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

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

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

#define pb push_back

#define ppb pop_back

#define mp make_pair

#define s second

#define f first

 

 

using namespace std;

 

 

typedef pair < long long, long long > pll;    

typedef pair < int, int > pii;

typedef unsigned long long ull;         

typedef vector < pii > vpii;

typedef vector < int > vi;

typedef long double ldb; 

typedef long long ll;  

typedef double db;                         

 

 

const int dx[] = {1, -1, 0, 0}, dy[] = {0, 0, 1, -1}, block = 555;

const pii base = mp(1171, 3307), Mod = mp(1e9 + 7, 1e9 + 9);

const int inf = 1e9, N = 1e5 + 48, mod = 1e9 + 7, maxn = 102;

const db eps = 1e-12, pi = 3.14159265359;

const ll INF = 1e18;





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







main () {

	cin >> n >> k;		

	forn (i, 1, n)

		cin >> a[i];



	forn (x, 1, k)

		forn (i, 1, n) {

			if (a[i] > x)        

				break;



			if (!dp[x - a[i]]) {

				dp[x] = 1;		 

				break;

			}

		}



	puts(dp[k] ? "First" : "Second");

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

 

#define int long long

//#pragma GCC optimize("Ofast")

//#pragma comment(linker, "/stack:200000000")

//#pragma GCC target("sse,sse2,sse3,ssse3,sse4")

 

 

#define file(s) freopen(s".in","r",stdin); freopen(s".out","w",stdout);

#define forev(i, b, a) for(int i = (b); i >= (a); --i)

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

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

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

#define pb push_back

#define ppb pop_back

#define mp make_pair

#define s second

#define f first

 

 

using namespace std;

 

 

typedef pair < long long, long long > pll;    

typedef pair < int, int > pii;

typedef unsigned long long ull;         

typedef vector < pii > vpii;

typedef vector < int > vi;

typedef long double ldb; 

typedef long long ll;  

typedef double db;                         

 

 

const int dx[] = {1, -1, 0, 0}, dy[] = {0, 0, 1, -1}, block = 555;

const pii base = mp(1171, 3307), Mod = mp(1e9 + 7, 1e9 + 9);

const int inf = 1e9, N = 1e5 + 48, mod = 1e9 + 7, maxn = 102;

const db eps = 1e-12, pi = 3.14159265359;

const ll INF = 1e18;





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







main () {

	cin >> n >> k;		

	forn (i, 1, n)

		cin >> a[i];



	forn (x, 1, k)

		forn (i, 1, n) {

			if (a[i] > x)        

				break;



			if (!dp[x - a[i]]) {

				dp[x] = 1;		 

				break;

			}

		}



	puts(dp[k] ? "First" : "Second");

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



#define Solved int main()

#define pb push_back

#define mp make_pair

#define F first

#define S second

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

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

#define rep(i, x, y) for(int i = x; i <= y; i++)

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

#define pii pair<int, int>

#define ll long long

#define ull unsigned long long

#define ld long double

#define mii map<int, int>

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

#define lb lower_bound

#define ub upper_bound

using namespace std;



inline ll bip(ll x,ll n,ll mod){ll res=1;while(n){if(n&1){res=(res*x)%mod;}x=(x*x)%mod;n>>=1;}return res;}



const int maxn = 1e9;

const ll inf = 1e18;

//const int mod = 998244353;

const int mod = 1e9 + 7;

const int N = 2e5 + 10;



int n, a[101], k;

bool dp[N];



void solve() {

    cin >> n >> k;



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

        cin >> a[i], dp[a[i]] = 1;

    }



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

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

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

        }

    }

    if (dp[k]) cout << "First";

    else cout << "Second";

}



Solved {

    SpeedForce;

	int tt = 1;

    //cin >> tt;

	while (tt--) {

		solve();

		cout << '\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.8696607601809478x):
#include <bits/stdc++.h>



#define Solved int main()

#define pb push_back

#define mp make_pair

#define F first

#define S second

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

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

#define rep(i, x, y) for(int i = x; i <= y; i++)

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

#define pii pair<int, int>

#define ll long long

#define ull unsigned long long

#define ld long double

#define mii map<int, int>

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

#define lb lower_bound

#define ub upper_bound

using namespace std;



inline ll bip(ll x,ll n,ll mod){ll res=1;while(n){if(n&1){res=(res*x)%mod;}x=(x*x)%mod;n>>=1;}return res;}



const int maxn = 1e9;

const ll inf = 1e18;

//const int mod = 998244353;

const int mod = 1e9 + 7;

const int N = 2e5 + 10;



int n, a[101], k;

bool dp[N];



void solve() {

    cin >> n >> k;



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

        cin >> a[i], dp[a[i]] = 1;

    }



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

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

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

        }

    }

    if (dp[k]) cout << "First";

    else cout << "Second";

}



Solved {

    SpeedForce;

	int tt = 1;

    //cin >> tt;

	while (tt--) {

		solve();

		cout << '\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.484136341871324x):
#include <bits/stdc++.h>

#define mn(a, b) (a < b ? a : b)

#define mx(a, b) (a > b ? a : b)

#define f first

#define s second

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

#define base 331



using namespace std;



typedef long long ll;

typedef unsigned long long ull;



int const MAXn = 1e5 + 2;



bool dp[MAXn];

int arr[MAXn];



int main(){



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

    ios_base::sync_with_stdio(0);

    cin.tie(0);

    cout.tie(0);

    int n, k;

    cin>>n>>k;

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

        cin>>arr[i];

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

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

        int aux = 1;

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

            if(arr[j] > i) continue;

            aux &= dp[i - arr[j]];

        }

        dp[i] = !aux;

    }

    if(dp[k])

    cout<<"First";

    else

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

#define mn(a, b) (a < b ? a : b)

#define mx(a, b) (a > b ? a : b)

#define f first

#define s second

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

#define base 331



using namespace std;



typedef long long ll;

typedef unsigned long long ull;



int const MAXn = 1e5 + 2;



bool dp[MAXn];

int arr[MAXn];



int main(){



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

    ios_base::sync_with_stdio(0);

    cin.tie(0);

    cout.tie(0);

    int n, k;

    cin>>n>>k;

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

        cin>>arr[i];

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

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

        int aux = 1;

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

            if(arr[j] > i) continue;

            aux &= dp[i - arr[j]];

        }

        dp[i] = !aux;

    }

    if(dp[k])

    cout<<"First";

    else

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

using namespace std;

const int N=105,K=100005;

int a[N],dp[K];

vector<int>q;

int main()

{

	int n,k;

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

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

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

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

	for(int i=0;i<a[1];i++)

		dp[i]=0;

	for(int i=a[1];i<=k;i++)

	{

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

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

				dp[i]=1;

		

	}

	puts(dp[k]?"First":"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.9041910809898999x):
#include<bits/stdc++.h>

using namespace std;

const int N=105,K=100005;

int a[N],dp[K];

vector<int>q;

int main()

{

	int n,k;

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

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

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

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

	for(int i=0;i<a[1];i++)

		dp[i]=0;

	for(int i=a[1];i<=k;i++)

	{

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

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

				dp[i]=1;

		

	}

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

using namespace std;

const int N=105,K=100005;

int a[N],dp[K];

vector<int>q;

int main()

{

	int n,k;

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

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

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

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

	for(int i=0;i<a[1];i++)

		dp[i]=0;

	for(int i=a[1];i<=k;i++)

	{

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

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

				dp[i]=1;

		

	}

	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.4409910489161057x):
// Author : Syed Mujtaba

// Seek knowledge from the Cradle to the Grave !!

// https://www.linkedin.com/in/syed-mujtaba-064a5016a 



#include <bits/stdc++.h>

using namespace std;

#define int     long long

#define fast_io ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);

#define mod ((int)(1e9 + 7))

signed main()

{

	fast_io

	int n, k;

	cin >> n >> k;	

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

	int a[n + 1];

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

		cin >> a[i];

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

	{

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

		{

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

			{

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

				{

					dp[i] = 1;

					break;

				}

			}

			else

				break;

		}

	}	

	if(dp[k] == 1)

		cout << "First\n";

	else

		cout << "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.8092556489708895x):
// Author : Syed Mujtaba

// Seek knowledge from the Cradle to the Grave !!

// https://www.linkedin.com/in/syed-mujtaba-064a5016a 



#include <bits/stdc++.h>

using namespace std;

#define int     long long

#define fast_io ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);

#define mod ((int)(1e9 + 7))

signed main()

{

	fast_io

	int n, k;

	cin >> n >> k;	

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

	int a[n + 1];

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

		cin >> a[i];

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

	{

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

		{

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

			{

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

				{

					dp[i] = 1;

					break;

				}

			}

			else

				break;

		}

	}	

	if(dp[k] == 1)

		cout << "First\n";

	else

		cout << "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.8023542789610592x):
// Author : Syed Mujtaba

// Seek knowledge from the Cradle to the Grave !!

// https://www.linkedin.com/in/syed-mujtaba-064a5016a 



#include <bits/stdc++.h>

using namespace std;

#define int     long long

#define fast_io ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);

#define mod ((int)(1e9 + 7))

signed main()

{

	fast_io

	int n, k;

	cin >> n >> k;	

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

	int a[n + 1];

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

		cin >> a[i];

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

	{

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

		{

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

			{

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

				{

					dp[i] = 1;

					break;

				}

			}

			else

				break;

		}

	}	

	if(dp[k] == 1)

		cout << "First\n";

	else

		cout << "Second\n";

}