// Original C++ solution (slower):
/*

    -ensure correct output format

    -ensure printing required output

    -reread the problem statement

  */



#include<bits/stdc++.h>

using namespace std;

typedef int ll;

typedef unsigned long long ull;

typedef pair<ll,ll>pll;

typedef pair<ll,pair<ll,ll>>plll;

#define fastread() (ios_base:: sync_with_stdio(false),cin.tie(NULL));

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

#define all(x) x.rbegin(),x.rend()

#define min3(a, b, c)   min(a, min(b, c))

#define max3(a, b, c)   max(a, max(b, c))

#define F first

#define S second

#define in  freopen("input.txt", "r", stdin)

#define out  freopen("output.txt", "w", stdout)

#define minheap int,vector<int>,greater<int>

#define pb push_back

#define eb emplace_back

#define ischar(x)  (('a' <= x && x <= 'z') || ('A' <= x && x <= 'Z'))

#define isvowel(ch) ((ch=='a'||ch=='e'||ch=='i'||ch=='o'||ch=='u')||(ch=='A'|| ch=='E' || ch=='I'|| ch=='O'|| ch=='U'))

#define bug cout<<"BUG"<<endl;

const int Max = 1e5 + 10;

const int Mod = 1e9 + 7;

const double PI  =3.141592653589793238463;

bool compare(const pair<ll,ll> &a, const pair<ll,ll> &b)

{

       return (a.first > b.first);

}

ll lcm(ll a,ll b)

{

    if(a==0 || b==0)return 0;



    return a/__gcd(a,b)*b;

}



void input(ll ara[],ll n)

{

    for(ll i=0; i<n; i++)cin>>ara[i];

}



ll dp[Max+2];



ll ara[Max],n;



ll call(ll val)

{

    //cout<<i<<" "<<val<<endl;



     ll &ret=dp[val];





       if(ret!=-1)

        return ret;



       if(val==0)return dp[val]=0;



       ret=0;



          for(ll i=0; i<n && !ret; i++)

          {

              if(ara[i]<=val)

                ret=!call(val-ara[i]);

          }



          return ret;





}





int main()

{



   fastread();



   ll i,j,m,p,a,sum=0,k,t,b,c,d,cnt=0,q,l,r;





    memset(dp,-1,sizeof(dp));



      cin>>n>>m;



      input(ara,n);







        if(call(m))

            cout<<"First"<<endl;



        else cout<<"Second"<<endl;











}








// Optimized solution to the same problem (faster):
#include<bits/stdc++.h>

#include <ext/pb_ds/assoc_container.hpp>

#include <ext/pb_ds/tree_policy.hpp>

using namespace __gnu_pbds;

using namespace std;

using ll=long long;

using db=double;



///***************************************************** CONSTANTS ******************************************************///



int const N=1e6+3;

ll MOD=1e9+7,fact[N];

const long long inf=(long long)1e18;

const long double PI=3.14159265358979;



///************************************************ CONTAINER DEFINITIONS ***********************************************///



typedef vector<int> vi;

typedef vector<ll> vl;

typedef pair<int,int> pii;

typedef pair<ll, ll> pll;

typedef vector<pii> vii;

typedef vector<pll> vll;

typedef set<int> si;

typedef set<ll> sl;

typedef map<int,int> mii;

typedef map<ll,ll> mll;



///************************************************ SHORT FORM KEYWORDS *************************************************///



#define PB push_back

#define F first

#define S second

#define MP make_pair

#define I insert

#define lb lower_bound

#define ub upper_bound

#define endl '\n'



///************************************************ SHORT FORM FUNCTIONS ************************************************///



#define loop(i,a,b) for(ll i=a;i<b;i++)

#define loopr(i,a,b) for(ll i=a-1;i>=b;i--)

#define afor(x, y) for (auto x : y)

#define mem(a,b) memset(a, b, sizeof(a) )

#define gcd(a,b) __gcd(a,b)

#define lcm(a,b) (a*(b/gcd(a,b)))

#define sa(v) sort(v.begin(),v.end())

#define sd(v) sort(v.begin(),v.end(),greater<>())

#define rev(s) reverse(s.begin(),s.end())

#define stll(x) stoll(x, nullptr, 10);

#define yes cout<<"YES"<<endl;

#define no cout<<"NO"<<endl;

#define mx(a) *max_element(all(a))

#define mn(a) *min_element(all(a))

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

#define mxa(a,N) *max_element(a,a+N)

#define mna(a,N) *min_element(a,a+N)

#define print(a) {for(auto x:a)cout<<x<<" ";cout<<endl;}



///******************************************** FAST IO $ FILE INPUT ****************************************************///



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

#define fraction() cout.unsetf(ios::floatfield); cout.precision(10); cout.setf(ios::fixed,ios::floatfield);

#define fio() freopen("input_file_name","r",stdin);freopen("output_file_name","w",stdout);



///********************************************* REQUIRED FUNCTIONS *****************************************************///



ll powmod(ll a,ll b){ll p=MOD;a%=p;if(!a) return 0;ll pr=1;while(b>0){if(b&1){pr*=a;pr%=p;--b;}a*=a;a%=p;b/=2;}return pr;}

ll inv(ll a,ll p){return powmod(a,p-2);}

ll nCr(ll n,ll k,ll p){fact[0]=1;loop(i,1,n+1) fact[i]=fact[i-1]*i;return ((fact[n]*inv(fact[k],p)%p)*inv(fact[n-k],p))%p;}

bool isPrime(ll n){ if(n<=1)return false;if(n<=3)return true;if(n%2==0 or n%3==0)return false;for(ll i=5;i*i<=n;i+=6){if(n%i==0|n%(i+2)==0)return false;}return true;}



///######################################################################################################################///



typedef tree<pair<ll,ll>, null_type, less<pair<ll,ll>>, rb_tree_tag, tree_order_statistics_node_update> ordered_set;



///************************************************ SOLUTION STARTS HERE ************************************************///

///======================================================================================================================///





void solve()

{

    ll  n,k;

    cin>>n>>k;

    vl a(n);

    loop(i,0,n) cin>>a[i];

    vector<bool> dp(k+1,false);

    loop(i,0,k+1)

    {

        for(auto x: a)

        {

            if(i>=x&&!dp[i-x]) dp[i]=true;

        }

    }

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

    else cout<<"Second\n";

}



int main()

{

    io();

    int $=1;//cin>>$;

    while($--) solve();

    return 0;

}






















// Fastest known solution for this problem: