#include <bits/stdc++.h>
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using pi = std::pair<int, int>;
using pill = std::pair<int, ll>;
using plli = std::pair<ll, int>;
using pll = std::pair<ll, ll>;
using pld = std::pair<ld, ld>;
using vi = std::vector<int>;
using vpill = std::vector<pill>;
using vplii = std::vector<plli>;
using vll = std::vector<ll>;
using vpi = std::vector<pi>;
using vpll = std::vector<pll>;
using vvi = std::vector<vi>;
using vvll = std::vector<vll>;
using vvvi = std::vector<vvi>;
using vvpi = std::vector<vpi>;
using vb = std::vector<bool>;
using vvb = std::vector<vb>;
using si = std::set<int>;
using sll = std::set<ll>;
using sull = std::set<ull>;
using spi = std::set<pi>;
const int MAX_INT = std::numeric_limits<int>::max();
const int MXI = 1e9;
const ll MAX_LL = std::numeric_limits<long long>::max();
const ull MAX_ULL = std::numeric_limits<unsigned long long>::max();
const ll MXLL = 1e18;
template <typename T1, typename T2, typename T3>
class triple {
 public:
  T1 first;
  T2 second;
  T3 third;
  constexpr triple() {}
  constexpr triple(const T1& first, const T2& second, const T3& third)
      : first(first), second(second), third(third) {}
  triple(const triple& t) = default;
  triple(triple&& t) = default;
  triple& operator=(const triple& t) {
    first = t.first;
    second = t.second;
    third = t.third;
    return *this;
  }
  bool operator==(const triple& t) const {
    return first == t.first && second == t.second && third == t.third;
  }
  bool operator!=(const triple& t) const { return !(*this == t); }
  bool operator<(const triple& t) const {
    if (first == t.first) {
      if (second == t.second) return third < t.third;
      return second < t.second;
    }
    return first < t.first;
  }
  bool operator>(const triple& t) const {
    if (first == t.first) {
      if (second == t.second) return third > t.third;
      return second > t.second;
    }
    return first > t.first;
  }
  bool operator<=(const triple& t) const { return !(*this > t); }
  bool operator>=(const triple& t) const { return !(*this < t); }
  friend std::ostream& operator<<(std::ostream& os, const triple& t) {
    return os << t.first << ' ' << t.second << ' ' << t.third;
  }
};
template <typename T1, typename T2>
std::ostream& operator<<(std::ostream& os, const std::pair<T1, T2>& p) {
  return os << p.first << ' ' << p.second;
}
template <typename... T, template <typename...> class Container,
          typename std::enable_if<!std::is_same<
              Container<T...>, std::string>::value>::type* = nullptr>
std::ostream& operator<<(std::ostream& os, const Container<T...>& c) {
  for (auto&& x : c) os << x << ' ';
  return os;
}
template <typename T,
          typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
inline void getcx(T& var) {
  var = 0;
  register char c = getchar();
  register T sgn = 1;
  while (c < '0' || c > '9') {
    if (c == '-') sgn *= -1;
    c = getchar();
  }
  while (c >= '0' && c <= '9') {
    var = (var << 3) + (var << 1) + c - '0';
    c = getchar();
  }
  var *= sgn;
}
template <typename T,
          typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
inline void putcx(T var) {
  if (var == 0) {
    putchar('0');
    putchar(' ');
    return;
  }
  register T rev = 0;
  register int zeros = 0;
  while (var % 10 == 0) {
    zeros++;
    var /= 10;
  }
  while (var) {
    rev = (rev << 3) + (rev << 1) + (var % 10);
    var /= 10;
  }
  while (rev) {
    putchar(rev % 10 + '0');
    rev /= 10;
  }
  while (zeros--) putchar('0');
}
int n, k;
vi a;
vb dp;
int main() {
  std::ios_base::sync_with_stdio(false);
  std::cin.tie(0);
  std::cout.tie(0);
  std::cin >> n >> k;
  for (size_t i = 0; i < n; i++) {
    int ai;
    std::cin >> ai;
    a.push_back(ai);
  }
  dp = vb(k + 1);
  for (size_t i = a.front(); i <= k; i++)
    for (auto&& ai : a)
      if (!dp[i - ai]) {
        dp[i] = true;
        break;
      }
  std::cout << (dp[k] ? "First" : "Second");
  return 0;
}
