#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1e9;
const int EPS = 1e-8;
const int MOD = 1000000007;
const long double PI = 3.14159265359;
const int dx4[4] = {0, 1, 0, -1};
const int dy4[4] = {-1, 0, 1, 0};
const int dx8[8] = {-1, -1, -1, 0, 1, 1, 1, 0};
const int dy8[8] = {-1, 0, 1, 1, 1, 0, -1, -1};
inline bool grid_inside(int x, int y, int n, int m) {
  return x >= 1 && x <= n && y >= 1 && y <= m;
}
template <typename T>
T lcm(T a, T b) {
  return (a * b) / __gcd(a, b);
}
template <typename ForwardIterator, typename T>
T first_val(ForwardIterator first, ForwardIterator last, T value) {
  auto it = std::lower_bound(first, last, value);
  return (it != last) ? (it - first) : -1;
}
template <typename ForwardIterator, typename T>
T last_val(ForwardIterator first, ForwardIterator last, T value) {
  auto it = std::upper_bound(first, last, value);
  return ((it != last) ? ((it - first) - 1) : -1);
}
template <typename T>
T Dis(T x1, T y1, T x2, T y2) {
  return sqrt(((x1 - x2) * (x1 - x2)) + ((y1 - y2) * (y1 - y2)));
}
template <typename T>
T Angle(T x1, T y1, T x2, T y2) {
  return atan((double)(y1 - y2) / (double)(x1 - x2));
}
int Set(int N, int pos) { return N = N | (1 << pos); }
int Reset(int N, int pos) { return N = N & ~(1 << pos); }
bool Check(int N, int pos) { return (bool)(N & (1 << pos)); }
template <class T, class X>
inline T togglebit(T a, X i) {
  T t = 1;
  return (a ^ (t << i));
}
bool compare(const pair<int, int>& i, const pair<int, int>& j) {
  return i.first < j.first;
}
int doubleCompare(double x, double y) {
  if (fabs(x - y) <= EPS) return 0;
  if (x < y) return -1;
  return 1;
}
int LSOne(long long int n) { return log2(n & -n) + 1; }
int rangeClear(int n, int i, int j) {
  int ones = ~0;
  int a = ones << (j + 1);
  int b = (i << 2) - 1;
  int mask = a | b;
  int ans = n & mask;
  return ans;
}
int countSetBits(int n) {
  int count = 0;
  while (n > 0) {
    count += (n & 1);
    n = n >> 1;
  }
  return count;
}
long long int fast_power(long long int a, long long int x) {
  if (x == 0)
    return 1;
  else if (x == 1)
    return a;
  else {
    long long int R = fast_power(a, x >> 1);
    if (!(x & 1))
      return R * R;
    else
      return R * a * R;
  }
}
long long int fast_power_unlocked(long long int a, long long int n,
                                  long long int mod) {
  long long int res = 1;
  while (n > 0) {
    if (n & 1) {
      res = (res * a) % mod;
    }
    a = (a * a) % mod;
    n = n >> 1;
  }
  return res;
}
long long int modInverse(long long int A, long long int M) {
  return fast_power_unlocked(A, M - 2, M);
}
bool checkPrime(long long int n) {
  int cnt = 0;
  for (long long int i = 2; i * i <= n; i++) {
    if (n % i == 0) {
      if (n / i == i)
        cnt++;
      else
        cnt += 2;
    }
  }
  if (cnt == 2)
    return true;
  else
    return false;
}
const int MAX_N = 1001;
void solve() {
  string str;
  cin >> str;
  int h[26] = {0};
  int n = str.size();
  for (int i = 0; i < n; i++) {
    h[str[i] - 'a']++;
  }
  int od = 0;
  for (int i = 0; i < 26; i++) {
    if (h[i] & 1) {
      od++;
    }
  }
  if (n & 1 || od == 0) {
    cout << "First";
  } else {
    cout << "Second";
  }
}
int main() {
  ios::sync_with_stdio(false);
  ;
  for (auto blockTime = make_pair(chrono::high_resolution_clock::now(), true);
       blockTime.second;
       fprintf(stderr, "%s: %ld ms\n", "Time Taken",
               chrono::duration_cast<chrono::milliseconds>(
                   chrono::high_resolution_clock::now() - blockTime.first)
                   .count()),
            fflush(stderr), blockTime.second = false) {
    solve();
  }
}

### Prompt

Please create a solution in cpp to the following problem:

The Little Girl loves problems on games very much. Here's one of them.

Two players have got a string s, consisting of lowercase English letters. They play a game that is described by the following rules:

  * The players move in turns; In one move the player can remove an arbitrary letter from string s. 
  * If the player before his turn can reorder the letters in string s so as to get a palindrome, this player wins. A palindrome is a string that reads the same both ways (from left to right, and vice versa). For example, string "abba" is a palindrome and string "abc" isn't. 



Determine which player will win, provided that both sides play optimally well — the one who moves first or the one who moves second.

Input

The input contains a single line, containing string s (1 ≤ |s| ≤ 103). String s consists of lowercase English letters.

Output

In a single line print word "First" if the first player wins (provided that both players play optimally well). Otherwise, print word "Second". Print the words without the quotes.

Examples

Input

aba


Output

First


Input

abca


Output

Second

### Response

```cpp
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1e9;
const int EPS = 1e-8;
const int MOD = 1000000007;
const long double PI = 3.14159265359;
const int dx4[4] = {0, 1, 0, -1};
const int dy4[4] = {-1, 0, 1, 0};
const int dx8[8] = {-1, -1, -1, 0, 1, 1, 1, 0};
const int dy8[8] = {-1, 0, 1, 1, 1, 0, -1, -1};
inline bool grid_inside(int x, int y, int n, int m) {
  return x >= 1 && x <= n && y >= 1 && y <= m;
}
template <typename T>
T lcm(T a, T b) {
  return (a * b) / __gcd(a, b);
}
template <typename ForwardIterator, typename T>
T first_val(ForwardIterator first, ForwardIterator last, T value) {
  auto it = std::lower_bound(first, last, value);
  return (it != last) ? (it - first) : -1;
}
template <typename ForwardIterator, typename T>
T last_val(ForwardIterator first, ForwardIterator last, T value) {
  auto it = std::upper_bound(first, last, value);
  return ((it != last) ? ((it - first) - 1) : -1);
}
template <typename T>
T Dis(T x1, T y1, T x2, T y2) {
  return sqrt(((x1 - x2) * (x1 - x2)) + ((y1 - y2) * (y1 - y2)));
}
template <typename T>
T Angle(T x1, T y1, T x2, T y2) {
  return atan((double)(y1 - y2) / (double)(x1 - x2));
}
int Set(int N, int pos) { return N = N | (1 << pos); }
int Reset(int N, int pos) { return N = N & ~(1 << pos); }
bool Check(int N, int pos) { return (bool)(N & (1 << pos)); }
template <class T, class X>
inline T togglebit(T a, X i) {
  T t = 1;
  return (a ^ (t << i));
}
bool compare(const pair<int, int>& i, const pair<int, int>& j) {
  return i.first < j.first;
}
int doubleCompare(double x, double y) {
  if (fabs(x - y) <= EPS) return 0;
  if (x < y) return -1;
  return 1;
}
int LSOne(long long int n) { return log2(n & -n) + 1; }
int rangeClear(int n, int i, int j) {
  int ones = ~0;
  int a = ones << (j + 1);
  int b = (i << 2) - 1;
  int mask = a | b;
  int ans = n & mask;
  return ans;
}
int countSetBits(int n) {
  int count = 0;
  while (n > 0) {
    count += (n & 1);
    n = n >> 1;
  }
  return count;
}
long long int fast_power(long long int a, long long int x) {
  if (x == 0)
    return 1;
  else if (x == 1)
    return a;
  else {
    long long int R = fast_power(a, x >> 1);
    if (!(x & 1))
      return R * R;
    else
      return R * a * R;
  }
}
long long int fast_power_unlocked(long long int a, long long int n,
                                  long long int mod) {
  long long int res = 1;
  while (n > 0) {
    if (n & 1) {
      res = (res * a) % mod;
    }
    a = (a * a) % mod;
    n = n >> 1;
  }
  return res;
}
long long int modInverse(long long int A, long long int M) {
  return fast_power_unlocked(A, M - 2, M);
}
bool checkPrime(long long int n) {
  int cnt = 0;
  for (long long int i = 2; i * i <= n; i++) {
    if (n % i == 0) {
      if (n / i == i)
        cnt++;
      else
        cnt += 2;
    }
  }
  if (cnt == 2)
    return true;
  else
    return false;
}
const int MAX_N = 1001;
void solve() {
  string str;
  cin >> str;
  int h[26] = {0};
  int n = str.size();
  for (int i = 0; i < n; i++) {
    h[str[i] - 'a']++;
  }
  int od = 0;
  for (int i = 0; i < 26; i++) {
    if (h[i] & 1) {
      od++;
    }
  }
  if (n & 1 || od == 0) {
    cout << "First";
  } else {
    cout << "Second";
  }
}
int main() {
  ios::sync_with_stdio(false);
  ;
  for (auto blockTime = make_pair(chrono::high_resolution_clock::now(), true);
       blockTime.second;
       fprintf(stderr, "%s: %ld ms\n", "Time Taken",
               chrono::duration_cast<chrono::milliseconds>(
                   chrono::high_resolution_clock::now() - blockTime.first)
                   .count()),
            fflush(stderr), blockTime.second = false) {
    solve();
  }
}

```