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|  ≤  10^3). 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

Source: codeforces | Difficulty: EASY
Tags: Game theory

Greedy algorithms


Solutions:
import sys
import math

def check(d):
	w = 0
	for i in d:
		if d[i] % 2 != 0:
			w = w + 1
	return w

def fn(n):
	b = []
	for i in n:
		b.append(n.count(i))
	d = dict(zip(n, b))
	w = check(d)
	if len(n) % 2 == 0 and w == 0:
		print('First')
	if len(n) % 2 == 0 and w != 0:
		print('Second')
	if len(n) % 2 != 0 and w % 2 != 0:
		print('First')
	if len(n) % 2 != 0 and w % 2 == 0:
		print('Second')
input = sys.stdin.read()
data = list(map(str, input.split()))
n = data[0]
fn(n)


w = list(input())
ls = list(dict.fromkeys(w))
d = dict()
od = 0
for i in w:
	d[i] = d.get(i, 0) + 1
k = list(d.values())
for i in k:
	if i % 2 == 1:
		od += 1
if od <= 1 or od % 2 == 1:
	print('First')
else:
	print('Second')


inp = input()
set_inp = set(inp)
t = 0
k = 0
for i in set_inp:
	t = inp.count(i)
	if t % 2 == 1:
		k += 1
if k <= 1 or k % 2 == 1:
	print('First')
else:
	print('Second')


listA = list(input())
done = []
store = [[], []]
even = 0
odd = 0
ans = ['First', 'Second']
idex = 0
for c in listA:
	if c not in done:
		done.append(c)
		v = listA.count(c)
		if v & 1:
			store[1].append(v)
			odd += 1
		else:
			store[0].append(v)
			even += 1
while 1:
	if odd == 0 or odd == 1:
		break
	else:
		if even > 0:
			next = store[0].pop(0)
			next -= 1
			if next > 0:
				store[1].append(next)
				odd += 1
			even -= 1
		else:
			next = store[1].pop(0)
			next -= 1
			if next > 0:
				store[0].append(next)
				even += 1
			odd -= 1
		idex ^= 1
print(ans[idex])


s = input()
letters = {}
for c in s:
	if c not in letters:
		letters[c] = 0
	letters[c] += 1
odds = 0
for key in letters:
	if letters[key] % 2 == 1:
		odds += 1
if odds == 0 or odds % 2 == 1:
	print('First')
else:
	print('Second')


from sys import stdin, stdout
import collections
s = list(input())
d = collections.Counter(s)
k = 0
for i in d:
	if d[i] % 2 == 1:
		k += 1
stdout.write('First\n' if k == 0 or k % 2 == 1 else 'Second\n')


s = input()
n = len(s)
a = [0] * 30
for i in range(n):
	a[ord(s[i]) - 97] += 1
odd = 0
for i in range(26):
	if a[i] & 1:
		odd += 1
if odd == 0 or odd & 1:
	print('First')
else:
	print('Second')


l1 = input()
l1 = list(l1)
dict1 = {}
for x in l1:
	if x in dict1:
		dict1[x] = dict1[x] + 1
	else:
		dict1[x] = 1
c = 0
for i in dict1:
	if dict1[i] % 2 != 0:
		c = c + 1
if c <= 1:
	print('First')
elif c % 2 == 0:
	print('Second')
else:
	print('First')


import sys
MIN = -1000000000
MAX = -MIN

def odds_evens(string):
	f = {}
	for letter in string:
		if letter not in f:
			f[letter] = 0
		f[letter] += 1
	(n_odds, n_evens) = (0, 0)
	for (key, val) in list(f.items()):
		if val % 2 != 0:
			n_odds += 1
		else:
			n_evens += 1
	return (n_odds, n_evens)
string = sys.stdin.readline().strip()
(n_odds, n_evens) = odds_evens(string)
if n_odds == 0:
	print('First')
elif n_odds % 2 == 0:
	print('Second')
else:
	print('First')


import collections
s = input()
c = collections.Counter(s)
count = 0
for i in list(set(s)):
	if c[i] % 2 == 1:
		count = count + 1
if count < 2:
	print('First')
elif count % 2 == 0:
	print('Second')
else:
	print('First')


s = str(input())
d = {}
for x in s:
	if x in d:
		d[x] += 1
	else:
		d[x] = 1
o = 0
for x in d:
	if d[x] % 2 == 1:
		o += 1
if o % 2 == 1 or o == 0:
	print('First')
else:
	print('Second')


s = [ord(i) - 97 for i in input()]
a = [0] * 26
for i in s:
	a[i] += 1
odd = 0
for i in a:
	if i & 1:
		odd += 1
if odd & 1 or odd == 0:
	print('First')
else:
	print('Second')


from collections import defaultdict
a = defaultdict(lambda : 0)
s = input()
let = set(s)
for i in s:
	a[i] += 1
ct = 0
for i in let:
	if a[i] & 1:
		ct += 1
if ct & 1 or ct == 0:
	print('First')
else:
	print('Second')


a = sorted(input())
b = 0
while len(a) > 1:
	if a[0] == a[1]:
		a = a[2:]
	else:
		a = a[1:]
		b += 1
if (b + len(a)) % 2 == 0 and b > 0:
	print('Second')
else:
	print('First')


s = str(input())
a = [0] * 26
for i in s:
	a[ord(i) - 97] += 1
ans = 0
for i in a:
	if i % 2 == 1:
		ans += 1
if ans == 0:
	print('First')
elif ans % 2 == 1:
	print('First')
else:
	print('Second')


n = input()
freq = {}
x = 0
for i in 'abcdefghijklmnopqrstuvwxyz':
	freq[i] = 0
for i in n:
	freq[i] += 1
for i in freq.values():
	x += i % 2 == 1
if x % 2 or x == 0:
	print('First')
else:
	print('Second')


s = input()
d_e = {}
n_o = 0
for c in s:
	if c not in d_e:
		d_e[c] = 0
	d_e[c] += 1
	if d_e[c] % 2 == 1:
		n_o += 1
	else:
		n_o -= 1
if n_o == 0:
	print('First')
elif n_o % 2 == 1:
	print('First')
else:
	print('Second')


from collections import Counter
n = input()
c = 0
for (k, v) in Counter(n).items():
	if v % 2 != 0:
		c += 1
if c == 0:
	print('First')
elif c % 2 != 0:
	print('First')
else:
	print('Second')


from collections import Counter
s = input()
freq = dict(Counter(s))
num_of_odds = 0
for i in freq:
	if freq[i] % 2 != 0:
		num_of_odds += 1
if num_of_odds % 2 != 0 or num_of_odds == 0:
	print('First')
else:
	print('Second')


l = input()
r = [0] * 26
for i in l:
	r[ord(i) - 97] += 1
for i in range(26):
	r[i] = r[i] % 2
if sum(r) == 0 or sum(r) == 1:
	print('First')
else:
	r = sum(r) - 1
	if r % 2:
		print('Second')
	else:
		print('First')


s = input()
d = {}
for i in range(len(s)):
	if s[i] in d:
		d[s[i]] += 1
	else:
		d[s[i]] = 1
(o, e) = (0, 0)
for i in d.values():
	if i % 2 == 0:
		e += 1
	else:
		o += 1
if o <= 1:
	print('First')
elif o % 2 == 0:
	print('Second')
else:
	print('First')


s = input()
l = list(s)
z = 0
a = set(l)
for i in a:
	if l.count(i) % 2 == 1:
		z += 1
if z <= 1:
	print('First')
elif z % 2 == 0:
	print('Second')
else:
	print('First')


def check_if_palindrome(s, l):
	if l % 2 == 0:
		d = {}
		for i in s:
			if i in d:
				d[i] += 1
			else:
				d[i] = 1
		for i in d:
			if d[i] % 2 != 0:
				return i
		return 'yes'
	else:
		d = {}
		for i in s:
			if i in d:
				d[i] += 1
			else:
				d[i] = 1
		count = 0
		for i in d:
			if d[i] % 2 != 0:
				count += 1
				if count == 2:
					return i
		return 'yes'
s = list(input())
l = len(s)
count = 0
while l > 0:
	ret = check_if_palindrome(s, l)
	if ret == 'yes':
		if count % 2 == 0:
			print('First')
			break
		print('Second')
		break
	count += 1
	l -= 1
	s.remove(ret)


s = input()
n = sum(map(2 .__rmod__, map(s.count, set(s))))
if n < 2 or len(s) % 2:
	print('First')
else:
	print('Second')


from sys import stdin
s = stdin.readline().strip()
l = len(s)
arr = [0] * 26
for i in s:
	arr[ord(i) - 97] += 1
count = 0
for i in arr:
	if i % 2 == 1:
		count += 1
if count <= 1:
	print('First')
elif count % 2 == 0:
	print('Second')
else:
	print('First')


m = list(input())
d = {}
for c in m:
	if c in d:
		d[c] += 1
	else:
		d[c] = 1
cnt = 0
for c in d:
	if d[c] % 2:
		cnt += 1
if not cnt:
	print('First')
elif cnt % 2:
	print('First')
else:
	print('Second')


from collections import Counter

def ispalindrome(st):
	c = Counter(st)
	count = 0
	for i in c:
		if c[i] % 2 != 0:
			count += 1
	if len(st) % 2 != 0:
		if count == 1:
			return True
		else:
			return False
	elif count == 0:
		return True
	else:
		return False
s = input()
if ispalindrome(s):
	print('First')
elif len(s) % 2 != 0:
	print('First')
else:
	print('Second')


import math
from collections import *
import sys
from functools import reduce
import time
from itertools import groupby

def input():
	return sys.stdin.readline()

def get_ints():
	return map(int, input().strip().split())

def get_list():
	return list(get_ints())

def get_string():
	return list(input().strip().split())

def printxsp(*args):
	return print(*args, end='')

def printsp(*args):
	return print(*args, end=' ')
DIRECTIONS = [(+0, +1), (+0, -1), (+1, +0), (+1, -1)]
NEIGHBOURS = [(-1, -1), (-1, +0), (-1, +1), (+0, -1), (+1, +1), (+1, +0), (+1, -1), (+0, +1)]
CAPS_ALPHABETS = {chr(i + ord('A')): i for i in range(26)}
SMOL_ALPHABETS = {chr(i + ord('a')): i for i in range(26)}
INF = float('inf')
s = input().strip('\n')
c = Counter(s)
odd = 0
for (k, v) in c.items():
	if v & 1:
		odd += 1
if odd < 2:
	print('First')
elif odd & 1:
	print('First')
else:
	print('Second')


s = input()
x = sum((s.count(i) % 2 for i in s))
if x % 2 + (x < 1) != 0:
	print('First')
else:
	print('Second')


from math import ceil, sqrt, log, gcd

def ii():
	return int(input())

def si():
	return input()

def mi():
	return map(int, input().split())

def li():
	return list(mi())
abc = 'abcdefghijklmnopqrstuvwxyz'
abd = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}
mod = 1000000007
inf = float('inf')
vow = ['a', 'e', 'i', 'o', 'u']
(dx, dy) = ([-1, 1, 0, 0], [0, 0, 1, -1])

def bo(i):
	return ord(i) - ord('a')

def solve():
	s = input()
	f = [0] * 26
	f1 = 0
	for i in s:
		f[bo(i)] += 1
	for j in range(len(s)):
		c = 0
		(o, e) = (-1, -1)
		for i in range(26):
			if f[i] == 0:
				continue
			if f[i] & 1:
				c += 1
				o = i
			else:
				e = i
		if c <= 1:
			break
		f1 ^= 1
		if e != -1:
			f[e] -= 1
		else:
			f[o] -= 1
	if f1 == 0:
		print('First')
	else:
		print('Second')
solve()


from collections import Counter
t = input()
l = Counter(t)
count = 0
for i in l:
	if l[i] % 2 != 0:
		count = count + 1
if count <= 1:
	print('First')
elif count % 2 == 0:
	print('Second')
else:
	print('First')


import collections
s = input()
Dict = collections.Counter(s)
cntEven = 0
cntOdd = 0
for v in Dict.values():
	if v % 2 == 0:
		cntEven += 1
	else:
		cntOdd += 1
if cntOdd <= 1:
	print('First')
elif cntOdd % 2 == 0:
	print('Second')
else:
	print('First')


import sys, os, io
from sys import stdin
import math
from collections import defaultdict
from heapq import heappush, heappop, heapify
from bisect import bisect_left, bisect_right
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
alphabets = list('abcdefghijklmnopqrstuvwxyz')
from types import GeneratorType

def bootstrap(f, stack=[]):

	def wrappedfunc(*args, **kwargs):
		if stack:
			return f(*args, **kwargs)
		else:
			to = f(*args, **kwargs)
			while True:
				if type(to) is GeneratorType:
					stack.append(to)
					to = next(to)
				else:
					stack.pop()
					if not stack:
						break
					to = stack[-1].send(to)
			return to
	return wrappedfunc

def ncr(n, r, p):
	num = den = 1
	for i in range(r):
		num = num * (n - i) % p
		den = den * (i + 1) % p
	return num * pow(den, p - 2, p) % p

def primeFactors(n):
	l = []
	while n % 2 == 0:
		l.append(2)
		n = n / 2
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			l.append(int(i))
			n = n / i
	if n > 2:
		l.append(n)
	return list(set(l))

def power(x, y, p):
	res = 1
	x = x % p
	if x == 0:
		return 0
	while y > 0:
		if y & 1 == 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

def sieveForSmallestPrimeFactor():
	MAXN = 100001
	spf = [0 for i in range(MAXN)]
	spf[1] = 1
	for i in range(2, MAXN):
		spf[i] = i
	for i in range(4, MAXN, 2):
		spf[i] = 2
	for i in range(3, math.ceil(math.sqrt(MAXN))):
		if spf[i] == i:
			for j in range(i * i, MAXN, i):
				if spf[j] == j:
					spf[j] = i
	return spf

def getPrimeFactorizationLOGN(x):
	spf = sieveForSmallestPrimeFactor()
	ret = list()
	while x != 1:
		ret.append(spf[x])
		x = x // spf[x]
	return ret

def SieveOfEratosthenes(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	return prime

def si():
	return input()

def divideCeil(n, x):
	if n % x == 0:
		return n // x
	return n // x + 1

def ii():
	return int(input())

def li():
	return list(map(int, input().split()))
if os.path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
	input = lambda : sys.stdin.readline().rstrip('\r\n')

def isPal(s):
	n = len(s)
	d = defaultdict(lambda : 0)
	for i in s:
		d[i] += 1
	o = 0
	e = 0
	for i in d.values():
		if i % 2 == 0:
			e += 1
		else:
			o += 1
	if n % 2 == 0:
		if o == 0:
			return True
		return False
	if o == 1:
		return True
	return False

def solve():
	s = si()
	if isPal(s):
		print('First')
		return
	if len(s) % 2 == 0:
		print('Second')
	else:
		print('First')
t = 1
for _ in range(t):
	solve()


s = input()
n = len(s)
(o, e) = (0, 0)
dic = {}
for i in range(n):
	dic[s[i]] = dic.get(s[i], 0) + 1
for i in dic.keys():
	if dic[i] % 2:
		o += 1
	else:
		e += 1
if o <= 1:
	print('First')
else:
	print('Second' if o % 2 == 0 else 'First')


import math, sys
from collections import defaultdict, Counter, deque
INF = float('inf')
MOD = 1000000007

def gcd(a, b):
	while b:
		(a, b) = (b, a % b)
	return a

def isPrime(n):
	if n <= 1:
		return False
	i = 2
	while i ** 2 <= n:
		if n % i == 0:
			return False
		i += 1
	return True

def primeFactors(n):
	factors = []
	i = 2
	while i ** 2 <= n:
		while n % i == 0:
			factors.append(i)
			n //= i
		i += 1
	if n > 1:
		factors.append(n)
	return factors

def vars():
	return map(int, input().split())

def array():
	return list(map(int, input().split()))

def main():
	s = input()
	m = Counter(s)
	cnt = 0
	for k in m:
		cnt += m[k] % 2
	if cnt <= 1:
		print('First')
	elif cnt % 2 == 1:
		print('First')
	else:
		print('Second')
t = 1
for _ in range(t):
	main()


s = input()
sett = list(set(s))
odd_cnt = 0
for i in range(len(sett)):
	if s.count(sett[i]) % 2 != 0:
		odd_cnt += 1
if odd_cnt % 2 == 0 and odd_cnt != 0:
	print('Second')
else:
	print('First')


def answer(s):
	ss = set(s)
	num_odds = 0
	for char in ss:
		ccnt = s.count(char)
		if ccnt % 2 == 1:
			num_odds += 1
	if num_odds == 0 or num_odds == 1:
		return 'First'
	if num_odds % 2 == 0:
		return 'Second'
	return 'First'

def main():
	s = input()
	print(answer(s))
	return
main()


s = input()
from collections import defaultdict
d = defaultdict(int)
for k in s:
	d[k] += 1
odd_count = 0
for (key, c) in d.items():
	odd_count += c % 2
if odd_count % 2 or odd_count <= 1:
	print('First')
else:
	print('Second')


s = input()
all_freq = {}
for i in s:
	if i in all_freq:
		all_freq[i] += 1
	else:
		all_freq[i] = 1
k = 0
for i in all_freq:
	if all_freq[i] % 2 != 0:
		k += 1
if k == 0 or k % 2 != 0:
	print('First')
else:
	print('Second')


s = list(input())
odd = 0
cnt = dict()
for i in s:
	cnt[i] = 0
for i in s:
	cnt[i] += 1
for i in cnt:
	if int(cnt[i]) % 2 == 1:
		odd += 1
if odd == 0 or odd % 2 == 1:
	print('First')
else:
	print('Second')


s = input()
dict = {}
un = 0
for letter in s:
	if letter not in dict.keys():
		dict[letter] = 0
	dict[letter] += 1
for k in dict:
	if dict[k] % 2 == 1:
		un += 1
print('First' if un % 2 == 1 or un < 2 else 'Second')


s = input()
dic = dict()
for i in s:
	if i not in dic:
		dic[i] = 0
	dic[i] += 1
odds = 0
for (i, v) in dic.items():
	if v % 2 != 0:
		odds += 1
if odds == 1:
	print('First')
elif odds == 0:
	print('First')
elif odds % 2 != 0:
	print('First')
elif odds % 2 == 0:
	print('Second')


while True:
	try:

		def soln(s):
			n = 1
			num = 0
			(ss, ele) = ([0] * (len(s) + 1), {})
			for i in range(len(s)):
				if s[i] in ele:
					ss[ele[s[i]]] += 1
				else:
					ele[s[i]] = n
					ss[n] += 1
					n += 1
			for i in range(1, n, 1):
				num = num + ss[i] % 2
			if num % 2 == 1 or num == 0:
				print('First')
			else:
				print('Second')

		def read():
			s = input()
			soln(s)
		if __name__ == '__main__':
			read()
	except EOFError:
		break


from collections import Counter
seq = list(str(input()))
parity = []
count_dict = Counter(seq)
for v in count_dict.values():
	parity.append(v % 2)
parity_count = Counter(parity)
if parity_count[1] % 2 == 1 or parity_count[1] == 0:
	print('First')
else:
	print('Second')


from collections import Counter
s = input()
c = Counter(s)
total_odds = 0
for (ch, count) in c.items():
	if count % 2 != 0:
		total_odds += count
print('First') if total_odds % 2 != 0 or total_odds == 0 else print('Second')


from collections import Counter
s = input()
count = Counter(s)
lis = list(count.values())
c = 0
for i in lis:
	if i % 2 != 0:
		c += 1
if c <= 1:
	print('First')
elif len(s) % 2 == 0:
	print('Second')
else:
	print('First')


k = input()
hash = {}
a = set(k)
for i in a:
	hash[i] = k.count(i)
flag = 0
if len(k) % 2 == 0:
	for i in hash.keys():
		if hash[i] % 2 != 0:
			flag = 1
			break
else:
	count = 0
	for i in hash.keys():
		if hash[i] % 2 != 0:
			count += 1
	if count > 1:
		falg = 1
if flag == 1:
	print('Second')
else:
	print('First')


n = input()
a = list(n)
se = set(a)
count = 0
for l in se:
	if a.count(l) % 2 != 0:
		count += 1
if count == 0 or count == 1:
	print('First')
elif count % 2 == 0:
	print('Second')
else:
	print('First')


import sys
input = sys.stdin.readline

def ceil(x):
	if x != int(x):
		x = int(x) + 1
	return x

def factorial(x, m):
	val = 1
	while x > 0:
		val = val * x % m
		x -= 1
	return val

def swaparr(arr, a, b):
	temp = arr[a]
	arr[a] = arr[b]
	arr[b] = temp

def gcd(a, b):
	if b == 0:
		return a
	return gcd(b, a % b)

def nCr(n, k):
	if k > n - k:
		k = n - k
	res = 1
	for i in range(k):
		res = res * (n - i)
		res = res / (i + 1)
	return int(res)

def upper_bound(a, x, lo=0, hi=None):
	if hi == None:
		hi = len(a)
	while lo < hi:
		mid = (lo + hi) // 2
		if a[mid] < x:
			lo = mid + 1
		else:
			hi = mid
	return lo

def primefs(n):
	primes = {}
	while n % 2 == 0 and n > 0:
		primes[2] = primes.get(2, 0) + 1
		n = n // 2
	for i in range(3, int(n ** 0.5) + 2, 2):
		while n % i == 0 and n > 0:
			primes[i] = primes.get(i, 0) + 1
			n = n // i
	if n > 2:
		primes[n] = primes.get(n, 0) + 1
	return primes

def power(x, y, p):
	res = 1
	x = x % p
	if x == 0:
		return 0
	while y > 0:
		if y & 1 == 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

def swap(a, b):
	temp = a
	a = b
	b = temp
	return (a, b)

def find(x, link):
	p = x
	while p != link[p]:
		p = link[p]
	while x != p:
		nex = link[x]
		link[x] = p
		x = nex
	return p

def union(x, y, link, size):
	x = find(x, link)
	y = find(y, link)
	if size[x] < size[y]:
		(x, y) = swap(x, y)
	if x != y:
		size[x] += size[y]
		link[y] = x

def sieve(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	return prime
MAXN = int(100000.0 + 5)

def spf_sieve():
	spf[1] = 1
	for i in range(2, MAXN):
		spf[i] = i
	for i in range(4, MAXN, 2):
		spf[i] = 2
	for i in range(3, ceil(MAXN ** 0.5), 2):
		if spf[i] == i:
			for j in range(i * i, MAXN, i):
				if spf[j] == j:
					spf[j] = i

def factoriazation(x):
	ret = {}
	while x != 1:
		ret[spf[x]] = ret.get(spf[x], 0) + 1
		x = x // spf[x]
	return ret

def int_array():
	return list(map(int, input().strip().split()))

def float_array():
	return list(map(float, input().strip().split()))

def str_array():
	return input().strip().split()
MOD = int(1000000000.0) + 7
CMOD = 998244353
INF = float('inf')
NINF = -float('inf')

def solve():
	s = input()
	s = list(sorted(s))
	s.remove('\n')
	d = {}
	for x in s:
		if d.get(x) == None:
			d[x] = 1
		else:
			d[x] += 1
	odd = 0
	for x in d.values():
		if x % 2 == 1:
			odd += 1
	if odd <= 1:
		print('First')
	else:
		print(['First', 'Second'][(len(s) - 1) % 2])
for _ in range(1):
	solve()


from collections import Counter
s = input()
c = Counter()
for sym in s:
	c[sym] += 1
syms = set(s)
even_even = True
odd_cnt = 0
for sym in syms:
	if c[sym] % 2 == 0:
		even_even = not even_even
	else:
		odd_cnt += 1
ans = 'First'
if len(syms) % 2 == 0:
	ans = 'Second'
if not even_even:
	if ans == 'First':
		ans = 'Second'
	else:
		ans = 'First'
if odd_cnt == 0:
	ans = 'First'
print(ans)


from sys import stdin
s = stdin.readline().strip()
dic = dict()
for c in s:
	if c in dic:
		dic[c] += 1
	else:
		dic[c] = 1
cnt = 0
for (k, v) in dic.items():
	if v % 2:
		cnt += 1
if cnt == 0 or cnt % 2:
	print('First')
else:
	print('Second')


s = input()
string = list(s)
l = list(set(string))
ans = []
a = 0
for i in range(len(l)):
	ans.append(string.count(l[i]))
for i in range(len(ans)):
	if ans[i] % 2 == 1:
		a += 1
if a >= 1:
	a -= 1
print('First' if a % 2 == 0 or a == 0 else 'Second')


word = input()
count_odd = 0
for letter in set(word):
	if word.count(letter) % 2 == 0:
		pass
	else:
		count_odd += 1
if count_odd == 0:
	print('First')
elif count_odd % 2 == 1:
	print('First')
else:
	print('Second')


s = input()
x = sum((s.count(i) % 2 for i in s))
print('SFeicrosntd'[x % 2 + (x < 1)::2])


s = input()
str_dict = {}
for i in s:
	if i in str_dict:
		str_dict[i] += 1
	else:
		str_dict[i] = 1
odd_count = 0
for item in str_dict:
	if str_dict[item] % 2 == 1:
		odd_count += 1
if odd_count == 0:
	print('First')
elif (odd_count - 1) % 2 == 1:
	print('Second')
else:
	print('First')


s = input()
s = sum((s.count(chr(i)) % 2 for i in range(97, 123)))
print(['Second', 'First'][s < 2 or s % 2])


s = input()
a = list(set(s))
akol = []
l = len(a)
for i in range(l):
	akol.append(s.count(a[i]))
win = ''
zikl = 1
while win == '':
	nech = 0
	kl = 0
	for i in range(l):
		if akol[i] % 2 != 0:
			nech += 1
	if nech < 2:
		if zikl % 2 != 0:
			win = 'First'
		else:
			win = 'Second'
	else:
		for i in range(l):
			if akol[i] % 2 == 0 and akol[i] != 0:
				akol[i] -= 1
				kl = 1
				break
		if kl == 0:
			for i in range(l):
				if akol[i] % 2 != 0 and akol[i] != 0:
					akol[i] -= 1
					break
	zikl += 1
print(win)


c = [0] * 26
s = input()
for i in range(len(s)):
	c[int(ord(s[i])) - 97] += 1
f = 0
for i in range(26):
	if c[i] % 2 != 0:
		f += 1
if f > 0:
	f -= 1
if f % 2 == 0:
	print('First')
else:
	print('Second')


s = input()
d = {}
for el in s:
	d[el] = d.get(el, 0) + 1
ans = 0
for el in list(d.values()):
	ans += el % 2
if ans % 2 == 1 or ans == 0:
	print('First')
else:
	print('Second')


import sys

def main():
	cnt = [0] * 26
	a_ord = ord('a')
	for c in sys.stdin.readline().strip():
		cnt[ord(c) - a_ord] += 1
	odds = sum((v % 2 for v in cnt))
	print('First' if odds == 0 or odds % 2 != 0 else 'Second')
main()


from collections import defaultdict
s = input()
count = defaultdict(lambda : 0)
for i in s:
	count[i] += 1
odd = 0
even = 0
for i in count.keys():
	if count[i] % 2 == 0:
		even += 1
	else:
		odd += 1
if odd < 2:
	print('First')
else:
	ans = 0
	ans += even
	ans += even + odd - 1
	if ans % 2 == 0:
		print('First')
	else:
		print('Second')


s = input()
alf = [0] * 26
k = 0
for item in s:
	alf[ord(item) - 97] += 1
for item in alf:
	if item % 2:
		k += 1
if k == 0 or k % 2:
	print('First')
else:
	print('Second')


s = input()
a = [0] * 26
for q in s:
	a[ord(q) - 97] += 1
j = 0
for q in range(26):
	if a[q] % 2:
		j += 1
if j % 2 or j == 0:
	print('First')
else:
	print('Second')


import sys
from collections import Counter
INT_MAX = sys.maxsize
INT_MIN = -sys.maxsize - 1
sys.setrecursionlimit(10 ** 7)
mod = 1000000007

def main():
	s = sys.stdin.readline().replace('\n', '')
	d = Counter(s)
	(even, odd) = (0, 0)
	for (k, v) in d.items():
		if v & 1:
			odd += 1
		else:
			even += 1
	if odd == 0:
		print('First')
	elif odd == 1:
		print('First')
	elif odd - 1 & 1:
		print('Second')
	else:
		print('First')
main()


s = input()
cnt = [0, 0]
for i in set(s):
	cnt[s.count(i) % 2] += 1
if cnt[1] and cnt[1] % 2 or not cnt[1]:
	print('First')
else:
	print('Second')


from collections import Counter
import string
import math
import sys

def array_int():
	return [int(i) for i in sys.stdin.readline().split()]

def vary(number_of_variables):
	if number_of_variables == 1:
		return int(sys.stdin.readline())
	if number_of_variables >= 2:
		return map(int, sys.stdin.readline().split())

def makedict(var):
	return dict(Counter(var))
mod = 100000007
s = input()
tt = makedict(list(s))
count_odd = 0
count_even = 0
for i in tt:
	if tt[i] % 2 != 0:
		count_odd += 1
if count_odd == 0 or count_odd == 1:
	print('First')
	exit()
if count_odd % 2 != 0:
	print('First')
else:
	print('Second')


s = input()
o = e = 0
for i in set(s):
	if s.count(i) % 2:
		o += 1
if o % 2 == 1 or o == 0:
	print('First')
else:
	print('Second')


def main():
	s = input()
	liters = [0 for i in range(26)]
	for i in s:
		liters[ord(i) - ord('a')] ^= 1
	c = liters.count(1)
	if c == 0 or c % 2 == 1:
		print('First')
	else:
		print('Second')
main()


s = input()
ans = [0] * 26
lens = len(s)
for i in range(lens):
	ans[ord('a') - ord(s[i])] += 1
odd = 0
for i in range(26):
	if ans[i] % 2 == 1:
		odd += 1
if odd % 2 == 0 and odd > 0:
	print('Second')
else:
	print('First')


word = input()
wordcount = dict()
for i in word:
	if i in wordcount.keys():
		wordcount[i] += 1
	else:
		wordcount[i] = 1
countodd = 0
counteven = 0
for i in wordcount.keys():
	if wordcount[i] % 2 == 0:
		counteven += 1
	elif wordcount[i] % 2 != 0:
		countodd += 1
found = 0
while found != 1:
	if countodd <= 1:
		found = 1
		print('First')
		break
	elif countodd % 2 == 0:
		print('Second')
		found = 1
		break
	else:
		print('First')
		found = 1
		break


s = list(input())
s.sort()
count = i = 0
while i < len(s):
	x = s.count(s[i])
	if x % 2 != 0:
		count += 1
	i += x
if count % 2 != 0 or count == 0:
	print('First')
else:
	print('Second')


from collections import Counter
cnt = Counter(input())
s = sum([a[1] % 2 for a in list(cnt.items())])
print('First' if s <= 1 or s % 2 else 'Second')


l = list(input())
n = len(l)
l = sorted(l, key=l.count)
k = 0
t = 0
for i in range(n):
	a = list(set(l))
	t = 0
	for i in a:
		if l.count(i) % 2 != 0:
			t += 1
	if t <= 1:
		if k % 2 == 0:
			print('First')
		else:
			print('Second')
		exit()
	else:
		k += 1
		l = l[1:]


s = input()
win = 'First'
s = list(s)
dic = {}
for i in range(len(s)):
	if s[i] in dic:
		dic[s[i]] += 1
	else:
		dic[s[i]] = 1
k = 0
for i in range(len(s)):
	if dic[s[i]] % 2 != 0:
		k += 1
if k == 0 or k == 1:
	print(win)
elif k % 2 == 0:
	print('Second')
else:
	print('First')


a = input()
a = list(a)
s = set(a)
c = 0
j = 0
for i in s:
	if a.count(i) % 2 == 0:
		continue
	elif j == 0:
		j += 1
	else:
		c += 1
if c % 2 == 0:
	print('First')
else:
	print('Second')


(d, c) = ({}, 0)
for v in input():
	if v not in d:
		d[v] = 0
	d[v] += 1
for k in d:
	if d[k] & 1:
		c += 1
print('First' if c == 0 or c & 1 else 'Second')


s = input()
k = 0
l = set(s)
for i in l:
	if s.count(i) % 2 != 0:
		k += 1
if k == 0 or k % 2 != 0:
	print('First')
else:
	print('Second')


s = input()
s1 = {}
for i in s:
	s1[i] = s1.get(i, 0) + 1
ans = 0
for i in s:
	ans += s1[i] % 2
if ans % 2 == 0:
	if ans == 0:
		print('First')
	else:
		print('Second')
elif ans == 1:
	print('First')
else:
	print('First')


from collections import Counter
s = input()
d = Counter(s)
count = 0
for (key, val) in d.items():
	if val % 2 != 0:
		count += val
if count == 0 or count == 1:
	print('First')
else:
	count -= 1
	if count % 2 == 0:
		print('First')
	else:
		print('Second')


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, copy, functools
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return list(map(int, sys.stdin.readline().split()))

def LLI():
	return [tuple(map(int, l.split())) for l in sys.stdin]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().split()]

def LS():
	return sys.stdin.readline().split()

def I():
	return int(sys.stdin.readline())

def F():
	return float(sys.stdin.readline())

def S():
	return input()

def pf(s):
	return print(s, flush=True)

def main():
	c = collections.Counter(S())
	k = 0
	for v in c.values():
		if v % 2 == 1:
			k += 1
	if k < 2 or k % 2 == 1:
		return 'First'
	return 'Second'
print(main())


def main():
	l = [0] * 26
	for c in input():
		l[ord(c) - 97] ^= 1
	x = l.count(1)
	print(('Second', 'First')[not x or x & 1])
main()


from collections import Counter
a = input()
b = Counter(a)
c = 0
d = len(a)
h = 0
for i in b.values():
	if i % 2 != 0:
		c += 1
if c == 1 and d % 2 != 0:
	print('First')
elif c == 0 and d % 2 == 0:
	print('First')
else:
	for i in range(1000000):
		d -= 1
		c -= 1
		h += 1
		if d % 2 == 0 and c == 0:
			break
		elif d % 2 != 0 and c == 1:
			break
	if h % 2 != 0:
		print('Second')
	else:
		print('First')


import os
import sys
from math import *
from collections import *
from bisect import *
from io import BytesIO, IOBase

def vsInput():
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def value():
	return map(int, input().split())

def array():
	return [int(i) for i in input().split()]
s = input()
d = Counter(s)
odd = 0
for i in d.keys():
	if d[i] & 1:
		odd += 1
ans = 0
if odd != 0:
	ans = odd - 1
	if odd % 2 == 0:
		print('Second')
	else:
		print('First')
else:
	print('First')


from collections import defaultdict as dc

def mlt():
	return map(int, input().split())

def arp():
	return [*mlt()]
s = input()
mp = dc(lambda : 0)
for n in s:
	mp[ord(n) - 97] += 1
cntr = 0
for n in s:
	if mp[ord(n) - 97] % 2:
		cntr += 1
if cntr <= 1:
	print('First')
else:
	s1 = ['Second', 'First']
	print(s1[len(s) % 2])


s = input().strip()
alphs = [0 for i in range(26)]
for c in s:
	alphs[ord(c) - ord('a')] += 1
firsWins = False
odds = 0
evens = 0
for i in alphs:
	if i > 0:
		if i % 2:
			odds += 1
		else:
			evens += 1
if odds == 0 or odds % 2 == 1:
	firsWins = True
print('First' if firsWins else 'Second')


a = input()
c = sum((a.count(i) % 2 for i in set(a)))
print('Second' if c % 2 == 0 and c != 0 else 'First')


s = input()
n = len(s)
freq = [0 for i in range(26)]
for i in s:
	freq[ord(i) - ord('a')] += 1
counto = 0
for i in range(26):
	if freq[i] % 2 == 1:
		counto += 1
if counto == 0:
	print('First')
elif counto % 2 == 0:
	print('Second')
else:
	print('First')


from sys import stdin, stdout
from math import gcd
ii1 = lambda : int(stdin.readline().strip())
is1 = lambda : stdin.readline().strip()
iia = lambda : list(map(int, stdin.readline().strip().split()))
isa = lambda : stdin.readline().strip().split()
mod = 1000000007
n = is1()
d = {}
for i in n:
	d.setdefault(i, [0])[0] += 1
odd = 0
for i in d:
	if d[i][0] % 2 != 0:
		odd += 1
if odd % 2 != 0 or odd == 0:
	print('First')
else:
	print('Second')


import bisect
import os
import gc
import sys
from io import BytesIO, IOBase
from collections import Counter
from collections import deque
import heapq
import math
import statistics

def sin():
	return input()

def ain():
	return list(map(int, sin().split()))

def sain():
	return input().split()

def iin():
	return int(sin())
MAX = float('inf')
MIN = float('-inf')
MOD = 1000000007

def sieve(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	s = set()
	for p in range(2, n + 1):
		if prime[p]:
			s.add(p)
	return s

def readTree(n, m):
	adj = [deque([]) for _ in range(n + 1)]
	for _ in range(m):
		(u, v) = ain()
		adj[u].append(v)
		adj[v].append(u)
	return adj
USE_IO = 2

def main():
	s = sin()
	if s == s[::-1]:
		print('First')
	else:
		c = Counter(s)
		flag = 1
		x = 0
		temp = 0
		while flag:
			temp = 0
			odd = 0
			even = 0
			one = 0
			for val in c.values():
				if val == 0:
					continue
				if val % 2 == 1:
					odd += 1
				else:
					even += 1
			if odd in [0, 1]:
				flag = 1
				break
			if even == 0:
				for key in c.keys():
					if c[key] != 0:
						c[key] -= 1
						break
				x = 1 - x
			else:
				for key in c.keys():
					if c[key] != 0 and c[key] % 2 == 0:
						c[key] -= 1
						break
				x = 1 - x
		if x == 0:
			print('First')
		else:
			print('Second')
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
if USE_IO == 1:
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
	input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


s = input()
b = {}
for i in s:
	if i not in b:
		b[i] = 1
	else:
		b[i] += 1
even = odd = 0
for i in b:
	if b[i] % 2 == 0:
		even += 1
	else:
		odd += 1
n = len(s)
if n % 2 != 0:
	print('First')
elif odd == 0:
	print('First')
elif odd % 2 == 0:
	print('Second')
else:
	print('First')


s = input()
freq = {}
list1 = []
list1[:0] = s
for item in list1:
	if item in freq:
		freq[item] += 1
	else:
		freq[item] = 1
p = []
for i in freq.values():
	if i % 2 != 0:
		p.append(i)
if len(p) == 0:
	print('First')
elif len(p) % 2 == 0:
	print('Second')
else:
	print('First')


s = input()
d = {}
for ele in s:
	d[ele] = s.count(ele)
co = 0
for ele in d:
	if d[ele] % 2 != 0:
		co += 1
if co == 0 or (co - 1) % 2 == 0:
	print('First')
else:
	print('Second')


a = input()
b = set(a)
c = 0
for i in b:
	if a.count(i) % 2 == 1:
		c += 1
if c == 0 or c == 1:
	print('First')
elif c % 2 == 0:
	print('Second')
else:
	print('First')


import sys
from collections import Counter

def input():
	return sys.stdin.readline().strip()

def iinput():
	return int(input())

def rinput():
	return map(int, sys.stdin.readline().strip().split())

def get_list():
	return list(map(int, sys.stdin.readline().strip().split()))
t = input()
l = Counter(t)
count = 0
for i in l:
	if l[i] % 2 != 0:
		count += 1
if count <= 1:
	print('First')
elif count % 2 == 0:
	print('Second')
else:
	print('First')


from itertools import permutations
from collections import defaultdict
from math import *
import os
import sys
from io import BytesIO, IOBase
from heapq import nlargest
from bisect import *
import copy
import itertools
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))

def input():
	return sys.stdin.readline().rstrip('\r\n')

def isPalindrome(s):
	val = len(s) // 2
	n = len(s)
	for i in range(n):
		if s[i] != s[n - 1 - i]:
			return False
	return True
s = input()
d = defaultdict(int)
for i in range(len(s)):
	d[s[i]] += 1
odd = 0
x = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
for i in range(26):
	if d[x[i]] % 2 == 1:
		odd += 1
if odd <= 1 or odd % 2 == 1:
	print('First')
else:
	print('Second')


from itertools import groupby
occs = [len(list(g)) for (c, g) in groupby(sorted(input()))]
print('First' if sum(occs) % 2 or all((x % 2 == 0 for x in occs)) else 'Second')


test = input()
hashtable = [0] * 26
for i in range(len(test)):
	hashtable[ord(test[i]) - ord('a')] += 1
odd = 0
for i in range(26):
	if hashtable[i] % 2 == 1:
		odd += 1
if odd == 0 or odd % 2 == 1:
	print('First')
else:
	print('Second')


s = input()
l = [0] * 26
for i in s:
	l[ord(i) - 97] += 1
count = 0
for i in l:
	if i % 2 != 0:
		count += 1
if len(s) % 2 == 0:
	if count == 0:
		print('First')
	else:
		print('Second')
else:
	print('First')


x = input()
ar = []
for i in x:
	ar.append(i)
s = 0
for j in range(0, len(ar)):
	b = ar.count(ar[j])
	if b % 2 != 0:
		s = s + 1
if s == 1 or s == 0:
	print('First')
elif s % 2 == 0:
	print('Second')
else:
	print('First')


s = input()
n = len(s)
if n % 2 == 1:
	print('First')
else:
	l = [0] * 26
	for i in s:
		if i == 'a':
			l[0] += 1
		elif i == 'b':
			l[1] += 1
		elif i == 'c':
			l[2] += 1
		elif i == 'd':
			l[3] += 1
		elif i == 'e':
			l[4] += 1
		elif i == 'f':
			l[5] += 1
		elif i == 'g':
			l[6] += 1
		elif i == 'h':
			l[7] += 1
		elif i == 'i':
			l[8] += 1
		elif i == 'j':
			l[9] += 1
		elif i == 'k':
			l[10] += 1
		elif i == 'l':
			l[11] += 1
		elif i == 'm':
			l[12] += 1
		elif i == 'n':
			l[13] += 1
		elif i == 'o':
			l[14] += 1
		elif i == 'p':
			l[15] += 1
		elif i == 'q':
			l[16] += 1
		elif i == 'r':
			l[17] += 1
		elif i == 's':
			l[18] += 1
		elif i == 't':
			l[19] += 1
		elif i == 'u':
			l[20] += 1
		elif i == 'v':
			l[21] += 1
		elif i == 'w':
			l[22] += 1
		elif i == 'x':
			l[23] += 1
		elif i == 'y':
			l[24] += 1
		else:
			l[25] += 1
	c = 0
	for i in l:
		if i % 2 == 1:
			c += 1
	if c == 0:
		print('First')
	else:
		print('Second')


from collections import Counter
c = Counter(input())
t = 0
for x in c.values():
	if x % 2 == 1:
		t += 1
print(['Second', 'First'][t % 2] if t > 0 else 'First')


def main(string):
	dp = [0 for _ in range(26)]
	for x in string:
		dp[ord(x) - ord('a')] += 1
	cnt = 0
	for i in range(26):
		if dp[i] % 2 != 0:
			cnt += 1
	if cnt <= 1:
		print('First')
	elif cnt % 2 == 0:
		print('Second')
	else:
		print('First')

def text():
	with open('input.txt', 'r') as f:
		t = int(f.readline().rstrip())
		while t:
			string = str(f.readline().rstrip())
			string = list(string)
			main(string)
			t -= 1

def normal():
	string = str(input())
	string = list(string)
	main(string)
normal()


s = list(input())
dict = {}
for i in range(len(s)):
	if s[i] in dict:
		dict[s[i]] += 1
	else:
		dict[s[i]] = 1
for i in range(len(s), 0, -1):
	odd = 0
	for (key, value) in dict.items():
		if value % 2 != 0:
			char = key
			odd += 1
	if i % 2 == 0 and odd == 0 or (i % 2 != 0 and odd == 1):
		print('First' if (len(s) - i) % 2 == 0 else 'Second')
		break
	dict[char] -= 1


def __starting_point():
	s = input()
	c = [s.count(x) for x in set(s)]
	total = 0
	for x in c:
		if x % 2 != 0:
			total += 1
	if total % 2 == 0 and total != 0:
		print('Second')
	else:
		print('First')
__starting_point()


str = list(input())
list = []
for x in range(27):
	list.append(0)
for x in range(len(str)):
	list[ord(str[x]) - ord('a')] += 1
k = 0
for x in range(27):
	if list[x] % 2 != 0:
		k += 1
if k == 0:
	print('First')
if k == 1:
	print('First')
if k > 1 and k % 2 == 0:
	print('Second')
if k > 1 and k % 2 != 0:
	print('First')


st = input().strip().lower()
L = [False for _ in range(26)]
for i in st:
	idx = ord(i) - 97
	L[idx] = False if L[idx] else True
if L.count(True) % 2 != 0 or L.count(True) == 0:
	print('First')
else:
	print('Second')


def main():
	s = input()
	cnt = [0] * 26
	for c in s:
		cnt[ord(c) - ord('a')] += 1
	done = False
	turn = 0
	while not done:
		odds = 0
		diff = 0
		for i in range(26):
			odds += cnt[i] % 2
			if cnt[i] > 0:
				diff += 1
		if odds == 0 or odds == 1:
			done = True
			break
		if odds == diff:
			for i in range(26):
				if cnt[i] > 0:
					cnt[i] -= 1
					break
		else:
			for i in range(26):
				if cnt[i] > 0 and cnt[i] % 2 == 0:
					cnt[i] -= 1
					break
		turn = 1 - turn
	if turn == 1:
		print('Second')
	else:
		print('First')
main()


s = input()
d = dict()
for x in s:
	if x not in d:
		d[x] = 0
	d[x] += 1
odds = []
for x in d:
	if d[x] % 2:
		odds.append(d[x])
odds.sort()
sm = sum(odds[:-1])
if sm % 2:
	print('Second')
else:
	print('First')


from collections import Counter
a = Counter(input())
cn = sum([1 for k in a if a[k] & 1])
if cn == 0 or cn == 1:
	print('First')
elif cn > 1:
	if cn & 1:
		print('First')
	else:
		print('Second')


s = input()
count = [0] * 26
for c in s:
	count[ord(c) - ord('a')] += 1
odd_count = 0
for e in count:
	if e % 2 == 1:
		odd_count += 1
if odd_count == 0 or odd_count == 1 or odd_count % 2 == 1:
	print('First')
else:
	print('Second')


from collections import Counter

def f(oddc, evenc):
	turn = 1
	while True:
		if len(oddc) <= 1:
			if turn % 2 != 0:
				return 'First'
			else:
				return 'Second'
		else:
			if len(evenc) > 0:
				for char in evenc:
					oddc[char] = evenc[char] - 1
					del evenc[char]
					break
			else:
				for char in oddc:
					if oddc[char] > 1:
						evenc[char] = oddc[char] - 1
					del oddc[char]
					break
			turn += 1
s = input()
c = Counter(s)
(oddc, evenc) = (Counter(), Counter())
for char in c:
	if c[char] % 2 == 0:
		evenc[char] = c[char]
	else:
		oddc[char] = c[char]
print(f(oddc, evenc))


s = input()
a = [0] * 26
for c in s:
	a[ord(c) - ord('a')] += 1
cnt = 0
for i in range(26):
	if a[i] % 2 == 1:
		cnt += 1
if cnt == 0:
	print('First')
elif cnt % 2 == 0:
	print('Second')
else:
	print('First')


s = input()
d = {}
for i in range(len(s)):
	if s[i] in d:
		d[s[i]] += 1
	else:
		d[s[i]] = 1
count = 0
for i in d:
	if d[i] % 2 != 0:
		count += 1
if count == 0 or count == 1 or count % 2 == 1:
	print('First')
else:
	print('Second')


string = input()
mydict = dict()
for i in string:
	mydict[i] = mydict.get(i, 0) + 1
count_odd = 0
count_even = 0
for i in mydict:
	if mydict[i] & 1:
		count_odd = count_odd + 1
	else:
		count_even = count_even + 1
if count_odd & 1 or count_odd == 0:
	print('First')
else:
	print('Second')


def mi():
	return map(int, input().split(' '))
n = input()
s = set(n)
odd = 0
for i in s:
	if n.count(i) % 2:
		odd += 1
if odd % 2 == 1 or odd == 0:
	print('First')
else:
	print('Second')


s = input()
di = dict()
c = 0
for i in s:
	di[i] = di.get(i, 0) + 1
while True:
	odd = 0
	for i in di:
		if di[i] % 2 == 1:
			odd += 1
	if len(s) % 2 == 0:
		for i in di:
			if di[i] % 2 == 1:
				di[i] -= 1
				c += 1
				break
		if odd == 0:
			if c % 2 == 0:
				print('First')
				exit(0)
			else:
				print('Second')
				exit(0)
	else:
		if odd > 1:
			for i in di:
				if di[i] % 2 == 1:
					di[i] -= 1
					c += 1
					break
		if odd == 1:
			if c % 2 == 0:
				print('First')
				exit(0)
			else:
				print('Second')
				exit(0)
	s = ''
	for i in di:
		s = s + di[i] * i


s = input()
counts = {}
for i in s:
	if i not in counts:
		counts[i] = 0
	counts[i] += 1
dist = 0
for i in counts:
	dist += int(counts[i] % 2 == 1)
if dist == 0 or dist % 2 == 1:
	print('First')
else:
	print('Second')


z = list(input())
count = 0
for i in set(z):
	count += z.count(i) % 2
print(['Second', 'First'][count % 2 != 0 or count == 0])


def fun(s):
	l = [str(i) for i in s]
	(e, o) = (0, 0)
	for i in l:
		if s.count(i) % 2 == 0:
			e = e + 1
		else:
			o = o + 1
	return (e, o)

def pallin(e, o, l):
	if l % 2 == 0 and o == 0 or (l % 2 == 1 and o == 1):
		return True
	else:
		return False
s = input()
i = 0
l = len(s)
(e, o) = fun(s)
while 1:
	if pallin(e, o, l) and i % 2 == 0:
		print('First')
		exit()
	elif pallin(e, o, l) and i % 2 == 1:
		print('Second')
		exit()
	else:
		if e != 0:
			e = e - 1
		else:
			o = o - 1
		l = l - 1
	i = i + 1


import collections

def palindromic(f, l):
	if l % 2 == 0:
		return len(odds(f)) == 0
	else:
		return len(odds(f)) == 1

def odds(f):
	return [k for (k, v) in list(f.items()) if v % 2 == 1]

def evens(f):
	return [k for (k, v) in list(f.items()) if v % 2 == 0 and v > 0]
s = input()
f = collections.defaultdict(int)
l = len(s)
for c in s:
	f[c] += 1
while not palindromic(f, l):
	o = odds(f)
	if len(o) >= 1:
		f[o[0]] -= 1
	else:
		f[evens(f)[0]] -= 1
	l -= 1
print('First' if (len(s) - l) % 2 == 0 else 'Second')


import collections
word = list(input())
flag = True
player = 0
while flag:
	player += 1
	count = collections.Counter(word)
	odd = 0
	for c in count:
		if count[c] % 2 == 1:
			odd += 1
	if odd == 1 or odd == 0:
		flag = False
		if player % 2 == 1:
			print('First')
		else:
			print('Second')
	else:
		for i in range(len(word) - 1, -1, -1):
			if count[word[i]] % 2 == 1:
				word.pop(i)
				break


def GirlAndTheGame(str):
	game = list(str)
	odd = [item for item in game if game.count(item) % 2 != 0]
	oddOneOut = len(set(odd))
	if oddOneOut == 0 or oddOneOut % 2 == 1:
		print('First')
	else:
		print('Second')
GirlAndTheGame(input())


s = input()
d = {}
for i in s:
	if i not in d:
		d[i] = 0
	d[i] += 1
o = 0
e = 0
for q in d:
	if d[q] % 2 == 1:
		o = o + 1
	else:
		e = e + 1
if len(s) % 2 == 0 and o == 0:
	print('First')
	exit()
if len(s) % 2 == 1 and o == 1:
	print('First')
	exit()
if len(s) % 2 == 0:
	print('Second')
else:
	print('First')


s = sorted(list(input()))
tmp = [len([1 for i in s if c == i]) % 2 for c in set(s)]
if sum(tmp) == 0 or sum(tmp) % 2 == 1:
	print('First')
else:
	print('Second')


import math
s = input()
d = dict()
for i in s:
	if i in d:
		d[i] += 1
	else:
		d[i] = 1
x = [d[i] % 2 for i in d]
n = x.count(1)
if n == 0:
	n = 1
ans = ['Second', 'First']
print(ans[n % 2])


def GreedyGirl(str):
	odd = list(str)
	temp = [item for item in odd if odd.count(item) % 2 != 0]
	OddOneOut = len(set(temp))
	if OddOneOut == 0 or OddOneOut % 2 == 1:
		print('First ')
	else:
		print('Second')
GreedyGirl(input())


def palodd(s):
	d = {}
	for ele in s:
		if ele in d:
			d[ele] += 1
		else:
			d[ele] = 1
	flag = False
	for ele in d:
		if d[ele] & 1 == 1:
			if flag == False:
				flag = True
			else:
				return False
	return True

def paleve(s):
	d = {}
	for ele in s:
		if ele in d:
			d[ele] += 1
		else:
			d[ele] = 1
	for ele in d:
		if d[ele] & 1 == 1:
			return False
	return True
s = input()
l = len(s)
if l & 1 == 0:
	if paleve(s):
		print('First')
	else:
		print('Second')
else:
	print('First')


from collections import Counter
cnt = Counter(input())
s = sum(map(lambda a: a[1] % 2, cnt.items()))
print('First' if s <= 1 or s % 2 else 'Second')


given = input()
diffs = sum([given.count(i) % 2 for i in set(given)])
print(['Second', 'First'][diffs % 2 == 1 or diffs == 0])


from collections import Counter
C = Counter(input())

def is_win(C):
	count_odd = 0
	for (_, v) in C.items():
		count_odd += v % 2
	return count_odd <= 1
player = 0
while C:
	if is_win(C):
		break
	else:
		(target_k, target_v) = next(iter(C.items()))
		for (k, v) in C.items():
			if v % 2 == 0 and v != 0:
				target_k = k
				target_v = v
				break
		C[target_k] -= 1
		if C[target_k] == 0:
			del C[target_k]
		player = (player + 1) % 2
print('First' if player == 0 else 'Second')


a = input()
d = {}
for i in a:
	d[i] = d.get(i, 0) + 1
s = 0
for i in d:
	if d[i] & 1:
		s += 1
if s == 0 or s & 1:
	print('First')
else:
	print('Second')


s = input()
a = [0] * 26
count = 0
for i in range(len(s)):
	a[ord(s[i]) - ord('a')] += 1
	if a[ord(s[i]) - ord('a')] % 2 != 0:
		count += 1
	elif count != 0:
		count -= 1
if count == 0 or count == 1:
	print('First')
elif count % 2 == 0:
	print('Second')
elif count % 2 != 0:
	print('First')


s = input().strip()
m = {i: 0 for i in 'abcdefghijklmnopqrstuvwxyz'}
t = 0
for i in s:
	m[i] += 1
	t += 1
if any((m[i] & 1 for i in m)):
	t -= 1
print('Second' if t & 1 else 'First')


s = input()
flag = 0
for i in set(s):
	if s.count(i) % 2 == 1:
		flag += 1
if flag == 0 or flag % 2 == 1:
	print('First')
else:
	print('Second')


import math

def fact(a, b):
	ans = 1
	for i in range(a, b + 1):
		ans *= i
	return str(ans) - 1

def comb(n, c):
	return fact(n) // (fact(n - c) * c)
s = str(input())
dic = {}
(eve, odd) = (0, 0)
for i in range(len(s)):
	if s[i] in dic:
		dic[s[i]] += 1
	else:
		dic[s[i]] = 1
for i in dic:
	if dic[i] % 2 == 0:
		eve += 1
	else:
		odd += 1
if odd == 0 and eve:
	print('First')
elif eve >= 0 and odd > 0:
	if (odd - 1) % 2 == 0:
		print('First')
	else:
		print('Second')


a = input()
n = len(a)
u = {}
for j in a:
	if j not in u:
		u[j] = 1
	else:
		u[j] += 1
(p, y) = (0, 0)
for j in u.values():
	if j % 2 == 0:
		p += 1
	else:
		y += 1
if a == a[::-1]:
	print('First')
elif y <= 1:
	print('First')
elif n % 2:
	print('First')
else:
	print('Second')


st = input()
l = len(st)
l1 = []
for k in range(26):
	l1.append(0)
for i in range(l):
	ch = st[i]
	x = ord(ch)
	x = x - 97
	l1[x] = l1[x] + 1
c = 0
for j in range(26):
	if l1[j] % 2 == 1:
		c = c + 1
if c > 0:
	c = c - 1
if c % 2 == 0:
	print('First')
else:
	print('Second')


s = input()
l = len(s)
d = {}
for i in s:
	try:
		d[i] += 1
	except:
		d[i] = 1
odd = 0
for i in d:
	if d[i] % 2:
		odd += 1
if odd == 0 or (l % 2 and odd == 1):
	print('First')
	exit()
if l % 2:
	print('First')
else:
	print('Second')


import collections
s = input()
d = collections.Counter(s)
count0fodd = 0
for i in d:
	if d[i] % 2 != 0:
		count0fodd += 1
if count0fodd == 0 or count0fodd % 2 != 0:
	print('First')
else:
	print('Second')


def main():
	from sys import stdin, stdout
	import collections
	s = stdin.readline().strip()
	count = collections.Counter(s)
	l = list(filter(lambda x: count[x] & 1, list((x for x in count))))
	removed = sum(list((count[x] for x in l))) - max(list((count[x] for x in l)) + [0])
	if removed & 1:
		stdout.write('Second')
	else:
		stdout.write('First')
main()


s = input()
f = [0] * 26
for i in s:
	f[ord(i) - ord('a')] += 1
k = 0
for i in range(26):
	if f[i] % 2 != 0:
		k += 1
if k <= 1:
	print('First')
elif k % 2 == 0:
	print('Second')
else:
	print('First')


s = input().strip()
d = {}
for i in s:
	if i in d:
		d[i] += 1
	else:
		d[i] = 1
res = 0
for i in d:
	if d[i] % 2:
		res += 1
if res == 1 or res == 0:
	print('First')
	exit(0)
if res % 2 == 0:
	print('Second')
else:
	print('First')


from collections import Counter
from functools import reduce
s = input()

def gcd(a, b):
	if not b:
		return a
	return gcd(b, a % b)

def canMakeIt():
	res = Counter(s)
	if reduce(gcd, list(res.values())) == 2:
		return 'First'
	return 'Second'
if len(s) & 1:
	print('First')
else:
	print(canMakeIt())


import sys
import math
import collections

def get_ints():
	return map(int, sys.stdin.readline().strip().split())

def get_list():
	return list(map(int, sys.stdin.readline().strip().split()))

def get_string():
	return sys.stdin.readline().strip()
for t in range(1):
	n = list(input())
	count = dict()
	for i in n:
		if i in count:
			count[i] += 1
		else:
			count[i] = 1
	odd = 0
	for i in count:
		val = count[i]
		if val % 2 == 1:
			odd += 1
	if odd <= 1:
		print('First')
	elif odd % 2 == 0:
		print('Second')
	else:
		print('First')


s = input()
s = sum((s.count(ch) % 2 for ch in set(s)))
print('First' if s == 0 or s % 2 else 'Second')


n = input()
n.split()
n = list(n)
a = []
a.extend(n)
n = set(n)
n = list(n)
c = []
c2 = 0
c3 = 0
for i in range(len(n)):
	c1 = 0
	for j in range(len(a)):
		if n[i] == a[j]:
			c1 += 1
	c.append(c1)
for k in range(len(c)):
	if c[k] % 2 == 0:
		c2 += 1
	else:
		c3 += 1
if c3 == 0 and c2 > 0:
	print('First')
elif c3 == 1 and c2 > 0:
	print('First')
elif c3 % 2 == 0:
	print('Second')
else:
	print('First')


s = input()
count = [0 for _ in range(26)]
for v in s:
	count[ord(v) - ord('a')] += 1
n_odd = 0
for v in count:
	if v % 2 != 0:
		n_odd += 1
if n_odd == 0:
	print('First')
else:
	print('First') if n_odd % 2 != 0 else print('Second')


def game(string):
	d = {}
	for i in string:
		d[i] = d.get(i, 0) + 1
	if len(string) % 2 == 0:
		for i in string:
			if d[i] % 2 != 0:
				return 'Second'
		else:
			return 'First'
	else:
		return 'First'
print(game(input()))


palavra = input()
k = sum((palavra.count(x) % 2 for x in set(palavra)))
if k == 0 or k == 1 or k % 2 == 1:
	print('First')
else:
	print('Second')


a = input()
alpha = {'a': 0, 'b': 0, 'c': 0, 'd': 0, 'e': 0, 'f': 0, 'g': 0, 'h': 0, 'i': 0, 'j': 0, 'k': 0, 'l': 0, 'm': 0, 'n': 0, 'o': 0, 'p': 0, 'q': 0, 'r': 0, 's': 0, 't': 0, 'u': 0, 'v': 0, 'w': 0, 'x': 0, 'y': 0, 'z': 0}
for i in a:
	alpha[i] += 1
odds = 0
for i in alpha.keys():
	if alpha[i] % 2 == 1:
		odds += 1
if odds in [0, 1]:
	print('First')
elif odds % 2 == 0:
	print('Second')
else:
	print('First')


x = input()
ch = nch = 0
for i in 'abcdefghijklmnopqrstuvwxyz':
	if x.count(i) > 0:
		if x.count(i) % 2 == 0:
			ch += 1
		else:
			nch += 1
t = 0
while nch > 1:
	if ch > 0:
		ch -= 1
		nch += 1
	else:
		nch -= 1
	t = (t + 1) % 2
print('First' if t == 0 else 'Second')


inp = input()
l1 = []
for i in range(0, len(inp)):
	l1.append(inp[i])
l2 = set(l1)
l3 = []
for i in l2:
	l3.append(0)
l4 = list(l2)
for i in range(0, len(l4)):
	for j in l1:
		if l4[i] == j:
			l3[i] += 1
step = 0
for i in l3:
	step += i % 2
if step != 0:
	step -= 1
if step % 2 == 0:
	print('First')
else:
	print('Second')


def odd(x):
	if x[1] % 2:
		return x[0]

def even(x):
	if x[1] % 2 == 0:
		return x[0]
from collections import *
(s, first, second) = (input(), 1, 0)
c = Counter(s)
while True:
	(odd1, even1) = (list(filter(odd, c.items())), list(filter(even, c.items())))
	if len(odd1) < 2:
		exit(print('First' if first else 'Second'))
	elif len(even1) > 0:
		c[even1[0][0]] -= 1
	else:
		c[odd1[0][0]] -= 1
	(first, second) = (second, first)
	c += Counter()


s = input()
y = []
n = len(s)
for i in range(0, n):
	if s[i] not in y:
		y.append(s[i])
p = [0] * len(y)
for i in range(0, len(y)):
	p[i] = s.count(y[i]) % 2
if p.count(1) <= 1:
	print('First')
elif p.count(1) % 2 == 0:
	print('Second')
else:
	print('First')


s = input()
d = {}
for i in s:
	if i not in d:
		d[i] = 0
	d[i] += 1
odd = 0
for i in d.values():
	if i % 2 == 1:
		odd += 1
if odd <= 1:
	print('First')
elif odd % 2 == 0:
	print('Second')
else:
	print('First')


def main():
	s = str(input())
	odd = 0
	even = 0
	for e in set(s):
		if s.count(e) % 2 == 0:
			even += 1
		else:
			odd += 1
	if odd >= 1:
		odd -= 1
	print('First' if odd % 2 == 0 else 'Second')
main()


s = input()
c = 0
a = []
i = 0
b = 0
while c < len(s):
	if s[i] not in a:
		x = s.count(s[i])
		if x % 2 == 1:
			b += 1
		c += x
		a.append(s[i])
	i += 1
if b == 0 or b % 2 == 1:
	print('First')
else:
	print('Second')


s = input()
rem = sum([s.count(x) % 2 for x in set(s)])
if rem == 0 or rem % 2:
	print('First')
else:
	print('Second')


from collections import defaultdict
s = input()
f = defaultdict(int)
for c in s:
	f[c] += 1
odd = 0
for val in f.values():
	if val % 2 == 1:
		odd += 1
print('First' if odd < 2 or odd % 2 == 1 else 'Second')


s = list(input())
c = 0
for i in s:
	if s.count(i) % 2 != 0:
		c += 1
if c < 2 or c % 2 != 0:
	print('First')
else:
	print('Second')


s = input()
dic = {}
for i in range(len(s)):
	if s[i] not in dic:
		dic[s[i]] = 1
	else:
		dic[s[i]] += 1
c = 0
for i in dic:
	if dic[i] % 2 == 1:
		c += 1
if c <= 1:
	print('First')
elif c % 2 == 0:
	print('Second')
else:
	print('First')


def main():
	s = input()
	G = Counter(s)
	cnt = 0
	for v in G.values():
		if v % 2:
			cnt += 1
	if cnt % 2 or cnt < 2:
		print('First')
	else:
		print('Second')
from collections import *
MOD = 998244353
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def read_int():
	return int(input())

def read_ints():
	return list(map(int, input().split()))

def print_nums(nums):
	print(' '.join(map(str, nums)))

def YES():
	print('YES')

def Yes():
	print('Yes')

def NO():
	print('NO')

def No():
	print('No')

def fib(n):
	(a, b) = (0, 1)
	for _ in range(n):
		(a, b) = (b, a + b)
	return a

def fib_ns(n):
	assert n >= 1
	f = [0 for _ in range(n + 1)]
	f[0] = 0
	f[1] = 1
	for i in range(2, n + 1):
		f[i] = f[i - 1] + f[i - 2]
	return f

def gcd(a, b):
	if a == 0:
		return b
	return gcd(b, a % b)

def xgcd(a, b):
	(x0, x1, y0, y1) = (0, 1, 1, 0)
	while a != 0:
		((q, a), b) = (divmod(b, a), a)
		(y0, y1) = (y1, y0 - q * y1)
		(x0, x1) = (x1, x0 - q * x1)
	return (b, x0, y0)

def modinv(a, m):
	(g, x, _) = xgcd(a, m)
	if g != 1:
		raise Exception('gcd(a, m) != 1')
	return x % m

def mod_add(x, y):
	x += y
	while x >= MOD:
		x -= MOD
	while x < 0:
		x += MOD
	return x

def mod_mul(x, y):
	return x * y % MOD

def mod_pow(x, y):
	if y == 0:
		return 1
	if y % 2:
		return mod_mul(x, mod_pow(x, y - 1))
	p = mod_pow(x, y // 2)
	return mod_mul(p, p)

def mod_inv(y):
	return mod_pow(y, MOD - 2)

def mod_div(x, y):
	return mod_mul(x, mod_inv(y))
main()


ss = input()
d = {}
for i in ss:
	if i not in d.keys():
		d[i] = 0
	d[i] += 1
k = 0
for i in d.keys():
	if d[i] % 2:
		k += 1
if k < 2:
	print('First')
elif k % 2:
	print('First')
else:
	print('Second')


import operator as op
import re
import sys
from bisect import bisect, bisect_left, insort, insort_left
from collections import Counter, defaultdict, deque
from copy import deepcopy
from decimal import Decimal
from functools import reduce
from itertools import accumulate, combinations, combinations_with_replacement, groupby, permutations, product
from math import acos, asin, atan, ceil, cos, degrees, factorial, gcd, hypot, log2, pi, radians, sin, sqrt, tan
from operator import itemgetter, mul
from string import ascii_lowercase, ascii_uppercase, digits

def inp():
	return int(input())

def inlist():
	return list(map(int, input().split()))

def instr():
	s = input()
	return list(s[:len(s)])

def invr():
	return map(int, input().split())

def def_value():
	return 0
s = input()
count = defaultdict(def_value)
n = len(s)
for c in s:
	count[c] += 1
odd = even = 0
if n % 2 != 0:
	for k in count:
		if count[k] % 2 == 0:
			even += 1
		else:
			odd += 1
	if odd % 2 != 0:
		print('First')
	else:
		print('Second')
else:
	for k in count:
		if count[k] % 2 == 0:
			even += 1
		else:
			odd += 1
	if odd == 0:
		print('First')
	else:
		print('Second')


str = input()
from collections import Counter
counts = Counter(str)
even = 0
odd = 0
for i in str:
	if counts[i] > 0:
		if counts[i] % 2 == 0:
			even += 1
		else:
			odd += 1
		counts[i] = -1
if odd == 0 or odd == 1:
	print('First')
else:
	val = odd - 1
	if val % 2 == 0:
		print('First')
	else:
		print('Second')


from collections import Counter
odds = sum((1 for (k, v) in Counter(input()).items() if v % 2 != 0))
print('First' if odds == 0 or odds % 2 != 0 else 'Second')


s = input()
dict = {}
l = list(s)
total = -1
for i in l:
	if i in dict:
		continue
	else:
		c = l.count(i)
		dict[i] = c
		if c % 2:
			total += 1
if total == -1:
	print('First')
elif total % 2:
	print('Second')
else:
	print('First')


s = input()
oddCounter = 0
d = {}
for x in range(len(s)):
	if s[x] in d:
		d[s[x]] += 1
	else:
		d[s[x]] = 1
for k in d.keys():
	oddCounter += d[k] % 2
if oddCounter == 0 or oddCounter % 2:
	print('First')
else:
	print('Second')


from collections import Counter
c = Counter(input())
first = True
while True:
	count = 0
	for ch in c:
		if c[ch] % 2 == 1:
			count += 1
	if count <= 1:
		break
	flag = None
	for ch in c:
		if c[ch] % 2 == 0 and c[ch] > 0:
			flag = ch
	if flag is not None:
		c[flag] -= 1
	else:
		for ch in c:
			if c[ch] > 0:
				c[ch] -= 1
				break
	first = not first
if first:
	print('First')
else:
	print('Second')


from collections import Counter
s = input()
c = Counter(s)
l = []
for i in range(len(s)):
	l.append(s[i])
x = []
for i in l:
	if c[i] % 2 != 0:
		x.append(c[i])
if len(x) == 0:
	print('First')
elif len(x) % 2 == 0:
	print('Second')
else:
	print('First')


n = input()
g = set(n)
l = list(g)
b = 0
for i in range(len(l)):
	a = n.count(l[i])
	if a % 2 != 0:
		b = b + 1
if b <= 1:
	print('First')
elif b % 2 == 0:
	print('Second')
else:
	print('First')


s = input()
c = 0
if s[::-1] == s:
	print('First')
else:
	x = []
	a = []
	for i in range(len(s)):
		if s[i] not in x:
			x.append(s[i])
	for j in range(len(x)):
		a.append(s.count(x[j]))
	for k in range(len(x)):
		if a[k] % 2 != 0:
			c += 1
	if c == 0:
		print('First')
	elif c % 2 == 0:
		print('Second')
	else:
		print('First')


str = input()
hash = {}
for ch in str:
	if ch not in hash:
		hash[ch] = 1
	else:
		hash[ch] += 1
x = 0
for key in hash:
	if hash[key] % 2 == 1:
		x += 1
if x == 0:
	print('First')
elif x % 2 == 0:
	print('Second')
else:
	print('First')


from collections import Counter
s = input()
x = list(dict(Counter(s)).values())
c = 0
for i in x:
	if i % 2 != 0:
		c += 1
if c == 0 or c % 2 != 0:
	print('First')
else:
	print('Second')


from sys import stdin, stdout
from collections import Counter

def solve(s):
	count = Counter(s)
	odds = 0
	for x in count.values():
		if x % 2 != 0:
			odds += 1
	if odds == 0 or odds & 1:
		return 'First'
	return 'Second'
s = str(stdin.readline().rstrip())
stdout.write(str(solve(s)))


from sys import stdin, stdout
from sys import maxsize
input = stdin.readline

def solve():
	pass
test = 1
for t in range(0, test):
	s = list(input().strip())
	d = {}
	for el in s:
		d[el] = d.get(el, 0) + 1
	cnt = 0
	for el in d:
		if d[el] % 2 == 1:
			cnt += 1
	if cnt == 0:
		print('First')
	elif cnt % 2 == 1:
		print('First')
	else:
		print('Second')
	ans = solve()


s = list(input())
print('First' if len([i for i in set(s) if s.count(i) % 2 != 0]) <= 1 or len([i for i in set(s) if s.count(i) % 2 != 0]) % 2 != 0 else 'Second')


s = input()
n = len(s)

def if_palindrome(s):
	x = list(s)
	y = list(s)
	y.reverse()
	if x == y:
		return True
	return False
done = False
x = list(s)
x = list(set(x))
nn = len(x)
r = 0
for i in range(nn):
	if s.count(x[i]) % 2 == 1:
		r += 1
	if r > 1:
		break
if r <= 1:
	print('First')
	done = True
if not done:
	n = len(s)
	if n % 2 == 1:
		print('First')
	else:
		print('Second')


import sys
import math

def get_line():
	return list(map(int, sys.stdin.readline().strip().split()))

def in1():
	return int(input())
s = str(input())
n = len(s)
s1 = list(s)
d = {}
for i in s1:
	if i not in d.keys():
		d[i] = 1
	else:
		d[i] += 1
e = 0
o = 0
for i in d.keys():
	if d[i] % 2 == 0:
		e += 1
	else:
		o += 1
t1 = 1
while n > 0:
	if n % 2 == 0 and o == 0:
		break
	elif n % 2 != 0 and o == 1:
		break
	else:
		if n % 2 != 0 and o == 0:
			o += 1
		else:
			o -= 1
			n -= 1
		if t1 == 1:
			t1 = 2
		else:
			t1 = 1
if t1 == 1:
	print('First')
else:
	print('Second')


from sys import stdin, stdout, setrecursionlimit
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush, nlargest
from math import *
from collections import defaultdict as dd, deque, Counter as C
from itertools import combinations as comb, permutations as perm, accumulate
from bisect import bisect_left as bl, bisect_right as br, bisect
from time import perf_counter
from fractions import Fraction
import copy
import time
setrecursionlimit(10 ** 9)
starttime = time.time()
mod = int(pow(10, 9) + 7)
mod2 = 998244353

def data():
	return input()

def num():
	return int(input())

def L():
	return list(sp())

def LF():
	return list(spf())

def sl():
	return list(ssp())

def sp():
	return map(int, data().split())

def spf():
	return map(int, input.readline().split())

def ssp():
	return map(str, data().split())

def l1d(n, val=0):
	return [val for i in range(n)]

def l2d(n, m, val=0):
	return [l1d(n, val) for j in range(m)]

def pmat(A):
	for ele in A:
		print(*ele, end='\n')

def pmat2(A):
	for ele in A:
		for j in ele:
			print(j, end='')
		print()

def iseven(n):
	return n % 2 == 0

def seive(r):
	prime = [1 for i in range(r + 1)]
	prime[0] = 0
	prime[1] = 0
	for i in range(r + 1):
		if prime[i]:
			for j in range(2 * i, r + 1, i):
				prime[j] = 0
	return prime
a = input()
HM = {}
for i in a:
	HM[i] = HM.get(i, 0) + 1
odd_count = 0
for (i, v) in HM.items():
	if v % 2 == 1:
		odd_count += 1
if odd_count < 2:
	print('First')
elif odd_count % 2 == 0:
	print('Second')
else:
	print('First')
endtime = time.time()


import sys
mem = {}

def palindrome_set_counts(string):
	if string == '':
		return True
	counts = {}
	for letter in string:
		if letter not in counts:
			counts[letter] = 0
		counts[letter] += 1
		counts[letter] %= 2
	letter_sums = 0
	for (key, value) in counts.items():
		letter_sums += value
	return letter_sums

def who_wins():
	results = [1, 1, -1, 1]
	for i in range(4, 2000000):
		results.append(results[i - 1] * -1)
	return results
counts = palindrome_set_counts(sys.stdin.readline().strip())
print('First' if who_wins()[counts] == 1 else 'Second')


from collections import Counter
s = input()
c = Counter(s)
odd = 0
for el in c:
	if c[el] % 2 == 1:
		odd += 1
if odd % 2 == 0 and odd != 0:
	print('Second')
else:
	print('First')


L = [0 for i in range(26)]
s = input()
for c in s:
	L[ord(c) - ord('a')] += 1
odd = 0
even = 0
for i in range(26):
	if L[i] % 2 == 0:
		even += 1
	else:
		odd += 1
if odd == 0:
	print('First')
elif odd % 2 == 0:
	print('Second')
else:
	print('First')


a = input()
freq = {}
odd_cnt = 0
even_cnt = 0
for i in a:
	try:
		freq[i] += 1
	except:
		freq[i] = 1
for i in freq:
	if freq[i] % 2:
		odd_cnt += 1
	else:
		even_cnt += 1
player = ['First', 'Second']
if len(a) % 2 and odd_cnt == 1:
	print(player[0])
elif not len(a) % 2 and (not odd_cnt):
	print(player[0])
else:
	print(player[(len(a) + 1) % 2])


s = input()
d = {}
for i in s:
	if i in d:
		d[i] += 1
	else:
		d[i] = 1
odd = 0
for i in d:
	if d[i] % 2 == 1:
		odd += 1
if odd <= 1 or odd % 2 == 1:
	print('First')
else:
	print('Second')


def canFormPalindrome(s):
	count = [0] * 256
	for i in range(0, len(s)):
		count[ord(s[i])] += 1
	odd = 0
	for i in range(0, 256):
		if count[i] & 1:
			odd += 1
		if odd > 1:
			return False
	return True
s = input()
i = 1
while True:
	rev_s = s[::-1]
	if s == rev_s or canFormPalindrome(s):
		if i % 2 == 0:
			print('Second')
		else:
			print('First')
		break
	I = 0
	while I < len(s):
		if s[I] != rev_s[I]:
			break
		I += 1
	s = s[:I] + s[I + 1:]
	i += 1


s = input()
res = 0
for c in 'abcdefghijklmnopqrstuvwxyz':
	res += s.count(c) % 2
print('First' if res <= 1 or len(s) % 2 == 1 else 'Second')


from collections import Counter

def iswin(c):
	if c == c[::-1]:
		return (True, None)
	else:
		co = Counter(c)
		ae = 0
		k1 = c[0]
		for (k, v) in co.items():
			if v % 2 == 0:
				ae += 1
				k1 = k
		if ae == len(co) or (len(co) % 2 == 1 and ae == len(co) - 1):
			return (True, None)
		else:
			return (False, k1)
s = input()
p = True
res = ''
while s:
	(r, k) = iswin(s)
	if not r:
		i = s.index(k)
		s = s[:i] + s[min(i + 1, len(s) - 1):]
	else:
		if p:
			res = 'First'
		else:
			res = 'Second'
		break
	p = not p
print(res)


d = input()
c = dict.fromkeys(d)
for i in set(d):
	c[i] = d.count(i)
f = list(filter(lambda x: c[x] % 2 == 1, c))
if len(f) % 2 == 1 or f == []:
	print('First')
else:
	print('Second')


from collections import defaultdict
s = list(input())
f = defaultdict(int)
for i in s:
	f[i] += 1
c = 0
for i in f:
	if f[i] % 2 != 0:
		c += 1
c = max(0, c - 1)
print('First') if c % 2 == 0 else print('Second')


s = input()
d1 = {}
for i in s:
	try:
		d1[i] += 1
	except:
		d1[i] = 1
count = 0
for i in d1:
	if d1[i] % 2 != 0:
		count += 1
if count == 0 or count == 1:
	print('First')
elif count % 2 == 0:
	print('Second')
else:
	print('First')


s = input().strip()
d = {}
for i in s:
	if i in d:
		d[i] += 1
	else:
		d[i] = 1
odd = 0
for (key, value) in d.items():
	if value & 1:
		odd += 1
if odd == 0 or odd % 2 == 1:
	print('First')
else:
	print('Second')


s = list(input())
for n in s:
	if n == ' ':
		s.remove(n)

def normalisation(s):
	c = []
	b = set()
	for letter in s:
		if letter in b:
			continue
		if s.count(letter) % 2 == 1:
			c.append(letter)
			b.add(letter)
	return c
s = normalisation(s)

def check(s, odds, b):
	c = len(s)
	if c == 1 or c == 0:
		return True
	elif c > 1 and odds == c and (b == c):
		return False
	letter = s[b]
	count = s.count(letter)
	if count % 2 == 0:
		while count != 0:
			s.remove(letter)
			count -= 1
		return check(s, odds, b)
	else:
		while count != 1:
			s.remove(letter)
			count -= 1
		odds += 1
		b += 1
		return check(s, odds, b)
count = 2
while True:
	if count % 2 == 0:
		player = 'First'
	else:
		player = 'Second'
	if check(s, 0, 0):
		print(player)
		break
	s.pop(0)
	count += 1


from collections import Counter as cc
s = input()
y = dict(cc(s))
count = 0
for i in y.values():
	if i % 2 == 1:
		count += 1
if count == 0 or count == 1:
	print('First')
elif count > 1:
	print(['First', 'Second'][1 - count % 2])


import string
stroka = string.ascii_lowercase
s = input()
sum = 0
count_n = 0
for i in range(26):
	for j in range(len(s)):
		if s[j] == stroka[i]:
			sum += 1
	if sum % 2 == 0:
		sum = 0
	else:
		sum = 0
		count_n += 1
if count_n == 0 or count_n == 1:
	print('First')
elif count_n > 1 and count_n % 2 == 0:
	print('Second')
else:
	print('First')


word = input()
d = {}
odd = 0
for i in range(len(word)):
	if word[i] in d:
		d[word[i]] += 1
	else:
		d[word[i]] = 1
for i in d.values():
	if i % 2 != 0:
		odd += 1
if odd <= 1:
	print('First')
elif odd % 2 == 0:
	print('Second')
else:
	print('First')


a = input()
b = dict()
for i in set(a):
	if a.count(i) % 2 != 0:
		b[i] = a.count(i)
if len(b) > 1:
	if (len(b) - 1) % 2:
		print('Second')
	else:
		print('First')
else:
	print('First')


from collections import Counter
st = Counter(input())
a = 0
for ele in st:
	if st[ele] % 2 == 1:
		a += 1
if a == 0 or a % 2 == 1:
	print('First')
else:
	print('Second')


def input_ints():
	return list(map(int, input().split()))

def solve():
	s = input()
	x = 0
	for c in 'abcdefghijklmnopqrstuvwxyz':
		x += s.count(c) % 2
	print(['Second', 'First'][int(x <= 1 or len(s) % 2)])
solve()


s = input()
temp = s.split()
dictionary = dict()
for i in range(len(s)):
	if s[i] not in dictionary:
		dictionary[s[i]] = 1
	else:
		dictionary[s[i]] += 1
oddLetter = 0
for (i, j) in dictionary.items():
	if j % 2 != 0:
		oddLetter += 1
if oddLetter <= 1:
	print('First')
elif oddLetter % 2 == 0:
	print('Second')
else:
	print('First')


s = input()
n = len(s)
i = 0
d = {}
while i < n:
	a = s[i]
	t = 0
	while s[i] == a:
		i += 1
		t += 1
		if i == n:
			break
	if a in d:
		d[a] += t
	else:
		d[a] = t
t = 0
for i in d:
	if d[i] % 2 != 0:
		t += 1
if t == 0:
	print('First')
elif t % 2 == 0:
	print('Second')
else:
	print('First')


n = list(input())
l = len(n)
d = {}
for i in n:
	if i not in d:
		d[i] = 1
	else:
		d[i] += 1
count = 0
for i in d.values():
	if i % 2 == 1:
		count += 1
if count == 0:
	print('First')
elif count == 1:
	print('First')
elif count % 2 == 0:
	print('Second')
else:
	print('First')


def palindrome(s):
	a = []
	for x in s:
		a.append(x)
	a = set(a)
	oddcount = 0
	for y in a:
		if s.count(y) % 2 == 1:
			oddcount += 1
	if oddcount % 2 == 1 or oddcount == 0:
		print('First')
		return
	else:
		print('Second')
t = input()
palindrome(t)


dict = {}
str = input()
for u in str:
	dict[u] = 0
for u in str:
	dict[u] += 1
co = 0
ce = 0
for keys in dict:
	if dict[keys] % 2 == 0:
		ce += 1
	else:
		co += 1
count = 0
if co == 0 or (co - 1) % 2 == 0:
	print('First')
	exit(0)
else:
	print('Second')
	exit(0)


from collections import Counter

def solve():
	s = input()
	d = Counter(s)
	count = 0
	for i in d:
		if d[i] % 2 != 0:
			count += 1
	if count == 0 or count % 2 == 1:
		print('First')
	else:
		print('Second')
solve()


from collections import Counter
inpS = str(input())
ansCount = 0
myMap = Counter(inpS)
for val in myMap.values():
	ansCount += val % 2
if ansCount == 0 or ansCount % 2 == 1:
	print('First')
else:
	print('Second')


from collections import deque, Counter, OrderedDict
from heapq import nsmallest, nlargest
from math import ceil, floor, log, log2, sqrt, gcd, factorial, pow, pi
from bisect import bisect_left, bisect_right

def binNumber(n, size=4):
	return bin(n)[2:].zfill(size)

def iar():
	return list(map(int, input().split()))

def ini():
	return int(input())

def isp():
	return map(int, input().split())

def sti():
	return str(input())

def par(a):
	print(' '.join(list(map(str, a))))

def tdl(outerListSize, innerListSize, defaultValue=0):
	return [[defaultValue] * innerListSize for i in range(outerListSize)]

def sts(s):
	s = list(s)
	s.sort()
	return ''.join(s)

class pair:

	def __init__(self, f, s):
		self.fi = f
		self.se = s

	def __lt__(self, other):
		return (self.fi, self.se) < (other.fi, other.se)

def canMakePalindrom(s):
	return sum((v % 2 == 1 for v in Counter(s).values())) <= 1
s = sti()
cnt = 0
while True:
	if canMakePalindrom(s):
		if cnt == 0:
			print('First')
		else:
			print('Second')
		quit()
	else:
		c = Counter(s)
		mi = 1000000
		mii = -1
		for i in range(len(s)):
			if mi > c[s[i]]:
				mi = c[s[i]]
				mii = i
		s = s[:i] + s[i + 1:]
	cnt = (cnt + 1) % 2


from collections import defaultdict as dd
d = dd(lambda : 0)
for i in input():
	d[i] += 1
t = sum(map(lambda i: i % 2, d.values()))
if t == 0:
	t += 1
print(['Second', 'First'][t % 2])


a = input()
my_dict = {}
for k in a:
	if my_dict.get(k, 0):
		my_dict[k] += 1
	else:
		my_dict[k] = 1
n = 0
for k in my_dict.keys():
	if my_dict[k] % 2 == 1:
		n += 1
if n < 2 or n % 2 == 1:
	print('First')
else:
	print('Second')


letters = {'a': 0, 'b': 0, 'c': 0, 'd': 0, 'e': 0, 'f': 0, 'g': 0, 'h': 0, 'i': 0, 'j': 0, 'k': 0, 'l': 0, 'm': 0, 'n': 0, 'o': 0, 'p': 0, 'q': 0, 'r': 0, 's': 0, 't': 0, 'u': 0, 'v': 0, 'w': 0, 'x': 0, 'y': 0, 'z': 0}
s = input()
for letter in s:
	letters[letter] = (letters[letter] + 1) % 2
sum_ = sum(letters.values())
if sum_ != 0 and sum_ % 2 == 0:
	print('Second')
else:
	print('First')


from collections import Counter
s = input()
c = Counter(s)
odd = sum((c[char] % 2 != 0 for char in s))
if odd <= 1:
	print('First')
elif odd % 2 == 0:
	print('Second')
else:
	print('First')


s = input()
from collections import Counter
z = Counter(s)
k = 0
for val in z.values():
	if val & 1 == 1:
		k += 1
if k == 0 or k == 1 or k & 1 == 1:
	print('First')
elif k & 1 == 0:
	print('Second')


from collections import Counter
word = input()
count = Counter(word)
odd = []
even = []
for val in count:
	if count[val] % 2 == 0:
		even.append(val)
	else:
		odd.append(val)
moves = 0
while len(odd) > 1:
	if len(odd) % 2 != 0:
		val = odd.pop()
		count[val] -= 1
		if count[val] > 0:
			even.append(val)
	elif len(even) > 0:
		val = even.pop()
		count[val] -= 1
		if count[val] > 0:
			odd.append(val)
	else:
		val = odd.pop()
		count[val] -= 1
		if count[val] > 0:
			even.append(val)
	moves += 1
if moves % 2 == 0:
	print('First')
else:
	print('Second')


s = input()
n = len(s)
odd = 0
even = 0
a = [0] * 26
for i in range(n):
	a[ord(s[i]) - 97] += 1
for i in range(26):
	if a[i] % 2 == 0:
		even += 1
	else:
		odd += 1
if odd <= 1:
	print('First')
elif odd % 2 == 0:
	print('Second')
else:
	print('First')


from collections import defaultdict
s = input()
c = defaultdict(int)
for i in s:
	c[i] += 1
k1 = 0
k2 = 0
for i in c:
	if c[i] % 2 == 0:
		k2 += 1
	else:
		k1 += 1
if len(s) % 2 == 0 and k1 == 0 or (len(s) % 2 != 0 and k1 == 1) or k1 % 2 != 0:
	print('First')
else:
	print('Second')


s = list(input())
b = [0] * 26
count = 0
for i in s:
	b[ord(i) - ord('a')] += 1
for i in b:
	if i % 2 == 1:
		count += 1
if s == s[::-1] or count <= 1:
	print('First')
elif len(s) % 2 == 0:
	print('Second')
else:
	print('First')


a = list(input())
od = 0
for i in set(a):
	if a.count(i) % 2 != 0:
		od += 1
if od > 0:
	print(['Second', 'First'][od % 2])
else:
	print('First')


a = input()
keys = {}
for i in a:
	if i in keys:
		keys[i] += 1
	else:
		keys[i] = 1
n = 0
for i in keys.keys():
	if keys[i] % 2 == 1:
		n += 1
if n < 2 or n % 2 == 1:
	print('First')
else:
	print('Second')


import sys
input = sys.stdin.readline
from math import log2, log, ceil

def swaparr(arr, a, b):
	temp = arr[a]
	arr[a] = arr[b]
	arr[b] = temp

def gcd(a, b):
	if a == 0:
		return b
	return gcd(b % a, a)

def nCr(n, k):
	if k > n - k:
		k = n - k
	res = 1
	for i in range(k):
		res = res * (n - i)
		res = res / (i + 1)
	return res

def upper_bound(a, x, lo=0):
	hi = len(a)
	while lo < hi:
		mid = (lo + hi) // 2
		if a[mid] < x:
			lo = mid + 1
		else:
			hi = mid
	return lo

def primefs(n):
	primes = {}
	while n % 2 == 0:
		primes[2] = primes.get(2, 0) + 1
		n = n // 2
	for i in range(3, int(n ** 0.5) + 2, 2):
		while n % i == 0:
			primes[i] = primes.get(i, 0) + 1
			n = n // i
	if n > 2:
		primes[n] = primes.get(n, 0) + 1
	return primes

def power(x, y, p):
	res = 1
	x = x % p
	if x == 0:
		return 0
	while y > 0:
		if y & 1 == 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

def swap(a, b):
	temp = a
	a = b
	b = temp
	return (a, b)

def find(x, link):
	while x != link[x]:
		x = link[x]
	return x

def union(x, y, link, size):
	x = find(x, link)
	y = find(y, link)
	if size[x] < size[y]:
		(x, y) = swap(x, y)
	if x != y:
		size[x] += size[y]
		link[y] = x

def sieve(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	return prime
MAXN = int(1000000.0 + 5)
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def find_parent(parent, i, cnt):
	cnt += 1
	if parent[i - 1] == i:
		return cnt
	if parent[i - 1] != i:
		find_parent(parent, parent[i - 1], cnt)
from collections import Counter
from collections import Counter
s = input()
c = Counter(s)
cnt = 0
for i in s:
	if c[i] % 2 != 0:
		cnt += 1
if cnt <= 1:
	print('First')
elif cnt % 2 == 0:
	print('Second')
else:
	print('First')


from collections import Counter
n = input()
even = odd = 0
count = Counter(n)
for i in count:
	if count[i] % 2 == 0:
		even += 1
	else:
		odd += 1
if odd == 0:
	print('First')
	quit()
if odd - 1 == 0:
	print('First')
	quit()
odd -= 1
if odd % 2 != 0:
	print('Second')
else:
	print('First')


p = input()
p = p.replace('', ' ')
p = p.split()
l = []
for i in range(26):
	l.append(0)
for i in p:
	l[ord(i) - ord('a')] += 1
c = 0
for i in l:
	if i % 2 == 1:
		c += 1
if c == 0 or c == 1:
	print('First')
else:
	c -= 1
	if c % 2 == 0:
		print('First')
	else:
		print('Second')


s = input()
dic = {}
for x in s:
	dic[x] = 0
for x in s:
	dic[x] += 1
evens = 0
odds = 0
for x in dic.values():
	if x % 2 == 0:
		evens += 1
	else:
		odds += 1
if odds == 0 or odds == 1:
	print('First')
else:
	diff = odds - 1
	if diff % 2 == 0:
		print('First')
	else:
		print('Second')


a = {}
for c in input():
	if c in a:
		a[c] += 1
	else:
		a[c] = 1
ans = len([1 for x in a.values() if x % 2 == 1])
print('First' if ans == 0 else list(['Second', 'First'])[ans % 2])


s = input()
c = sum((s.count(i) % 2 for i in s))
if c == 0 or c % 2:
	print('First')
else:
	print('Second')


a = input()
k = []
if a == a[::-1]:
	print('First')
elif len(a) == 1:
	print('First')
elif a.count(a[0]) == len(a):
	print('First')
else:
	count = 0
	for i in a:
		if i not in k:
			k.append(i)
			if a.count(i) % 2 == 0:
				continue
			else:
				count += 1
	if count % 2 == 1 or count == 0:
		print('First')
	else:
		print('Second')


string = input()
count = {}
for i in string:
	if i in count:
		count[i] += 1
		continue
	count[i] = 1
odds = -1
for i in count:
	if count[i] & 1:
		odds += 1
print('Second' if odds * (odds > 0) & 1 else 'First')


def main():
	s = input()
	n = list(s)
	n.sort()
	k = 0
	f = 0
	i = 0
	while i < len(s):
		if n.count(n[i]) == 1 and f == 0:
			f = 1
		elif n.count(n[i]) % 2 != 0:
			k = k + n.count(n[i])
		i = i + n.count(n[i])
	if k == 0:
		print('First')
		return
	if f == 0:
		if k % 2 != 0:
			print('First')
			return
		else:
			print('Second')
			return
	elif k % 2 == 0:
		print('First')
		return
	else:
		print('Second')
		return
main()


n = input()
d = {}
for i in range(len(n)):
	if n[i] in d:
		d[n[i]] += 1
	else:
		d[n[i]] = 1
(even, odd) = (0, 0)
for i in d:
	if d[i] % 2 != 0:
		odd += 1
if odd == 0:
	print('First')
elif odd % 2 == 0:
	print('Second')
else:
	print('First')


import sys
from collections import defaultdict
input = sys.stdin.readline

def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))

def insr():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	return map(int, input().split())

def main():
	d = defaultdict(lambda : 0)
	s = input().strip()
	for c in s:
		d[c] += 1
	c = 0
	for (k, v) in d.items():
		if v % 2 != 0:
			c += 1
	print('First' if c <= 1 or c % 2 != 0 else 'Second')
main()


from collections import *
s = input()
a = Counter(s)
cnt = 0
for i in a:
	if a[i] & 1 == 1:
		cnt += 1
if cnt & 1 or cnt == 0:
	print('First')
else:
	print('Second')


from collections import *
x = sum((i % 2 for i in list(Counter(input()).values())))
print('SFeicrosntd'[x % 2 + (x < 1)::2])


a = ord('a')
s = input()
n = len(s)
alphabet = [0] * 28
res = 0
if n % 2 == 0:
	for letter in s:
		alphabet[ord(letter) - a] += 1
	for val in alphabet:
		res += val % 2
	print('First' if res == 0 else 'Second')
else:
	print('First')


s = input()
a = {}
for i in range(len(s)):
	if a.get(s[i]):
		a[s[i]] += 1
	else:
		a[s[i]] = 1
count = 0
for i in a.values():
	if i % 2 != 0:
		count += 1
if count == 0:
	print('First')
elif count % 2 == 0:
	print('Second')
else:
	print('First')


s = input()
l = [0] * 26
for i in range(len(s)):
	l[ord(s[i]) - ord('a')] += 1
cpt = 0
for i in range(26):
	if l[i] % 2 == 1:
		cpt += 1
if cpt < 2 or cpt % 2 == 1:
	print('First')
else:
	print('Second')


from collections import Counter
s = input()
k = Counter(s)
a = [*k.values()]
odd_cnt = 0
even_cnt = 0
for i in a:
	if i & 1:
		odd_cnt += 1
	else:
		even_cnt += 1
if odd_cnt <= 1:
	print('First')
elif odd_cnt & 1:
	print('First')
else:
	print('Second')


from collections import Counter
input_string = input().strip()
value_string = dict(Counter(input_string))
number_of_odd_character = 0
for (key, value) in value_string.items():
	if value % 2 != 0:
		number_of_odd_character += 1
if number_of_odd_character % 2 != 0 or number_of_odd_character == 0:
	print('First')
else:
	print('Second')


s = input()
d = {}
for i in s:
	if i in d:
		d[i] = (d[i] + 1) % 2
	else:
		d[i] = 1
if 1 in d.values():
	s = sum(d.values()) - 1
else:
	s = sum(d.values())
if s % 2 == 0:
	print('First')
else:
	print('Second')


a = input()
b = []
k = []
k1 = []
c = 0
for i in a:
	if a.count(i) % 2 == 0:
		k.append(i)
	if i not in b:
		b.append(i)
for i in k:
	if i not in k1:
		k1.append(i)
for i in b:
	if i not in k:
		c += 1
print('First') if c % 2 != 0 or len(k1) == len(b) else print('Second')


from collections import Counter
s = input()
d = Counter(s)
odd = []
for i in d:
	if d[i] % 2 == 1:
		odd.append(i)
if len(odd) == 0 or len(odd) == 1:
	print('First')
elif (len(odd) - 1) % 2 == 0:
	print('First')
else:
	print('Second')


from sys import stdin as sin

def aint():
	return int(input())

def amap():
	return map(int, sin.readline().split())

def alist():
	return list(map(int, sin.readline().split()))

def astr():
	return input()
s = input()
c = [0] * 26
for i in s:
	c[ord(i) - 97] += 1
e = 0
o = 0
for i in c:
	if i != 0:
		if i % 2 == 0:
			e += 1
		else:
			o += 1
if o <= 1:
	print('First')
elif (e + o) % 2 != 0:
	if e % 2 == 0:
		print('First')
	else:
		print('Second')
elif e % 2 == 0:
	print('Second')
else:
	print('First')


from collections import Counter
s = input()
d = Counter(s)
odds = 0
for key in d:
	if d[key] % 2 != 0:
		odds += 1
if odds == 0 or odds % 2 != 0:
	print('First')
else:
	print('Second')


import sys
arr = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']

def check(d):
	w = 0
	for i in d:
		if d[i] % 2 != 0:
			w = w + 1
	return w

def deeznuts(n):
	b = []
	for i in n:
		b.append(n.count(i))
	d = dict(zip(n, b))
	w = check(d)
	if len(n) % 2 == 0 and w == 0:
		print('First')
	if len(n) % 2 == 0 and w != 0:
		print('Second')
	if len(n) % 2 != 0 and w % 2 != 0:
		print('First')
	if len(n) % 2 != 0 and w % 2 == 0:
		print('Second')
input = sys.stdin.read()
data = list(map(str, input.split()))
n = list(data[0])
deeznuts(n)


s = input()
l = sorted(s)
d = {}
for letter in l:
	d[letter] = 0
for letter in l:
	d[letter] += 1
count = 0
for value in d.values():
	if value % 2 == 1:
		count += 1
if count == 0 or count % 2 == 1:
	print('First')
else:
	print('Second')


from collections import Counter
s = str(input())
t = Counter(s)
ans = 0
for k in t:
	if t[k] % 2 != 0:
		ans += 1
if ans == 0:
	print('First')
elif ans % 2 == 0:
	print('Second')
else:
	print('First')


from typing import Counter
s = input()
c = Counter(s)
co = 0
for i in c.values():
	co += i % 2
if (len(s) - co) % 2 == 0:
	co -= 1
if co >= 0:
	if co % 2 == 0:
		print('First')
	else:
		print('Second')
else:
	print('First')


s = str(input())
r = sum((s.count(c) % 2 for c in set(s)))
if r == 0 or r & 1 == 1:
	print('First')
else:
	print('Second')


s = list(input())
h = [0 for k in range(0, 26)]
for i in s:
	h[ord(i) - ord('a')] += 1
res = 0
for k in h:
	if k % 2 != 0:
		res += 1
if res <= 1:
	print('First')
else:
	res -= 1
	if res % 2 != 0:
		print('Second')
	else:
		print('First')


l = input()
abc = 'abcdefghijklmnopqrstuvwxyz'
x = sum((l.count(i) % 2 for i in abc))
if x == 0 or x % 2 == 1:
	print('First')
else:
	print('Second')


import sys, os, io, time, copy
if os.path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
import math

def main():
	st = input()
	n = len(st)
	dic = {}
	for s in st:
		if s not in dic:
			dic[s] = 1
		else:
			dic[s] += 1
	odd = 0
	for d in dic:
		if dic[d] % 2 != 0:
			odd += 1
	if odd <= 1 or n % 2 != 0:
		print('First')
	else:
		print('Second')
main()


s = input()
cnt = sum((s.count(i) % 2 for i in s))
if cnt % 2 == 1 or cnt == 0:
	print('First')
else:
	print('Second')


from collections import Counter
s = dict(Counter(input()))
oddct = 0
for key in s:
	if s[key] % 2 == 1:
		oddct += 1
if oddct % 2 == 1 or oddct == 0:
	print('First')
else:
	print('Second')


mod = 1000000007
ii = lambda : int(input())
si = lambda : input()
dgl = lambda : list(map(int, input()))
f = lambda : map(int, input().split())
il = lambda : list(map(int, input().split()))
ls = lambda : list(input())
s = si()
l = [0] * 26
for i in s:
	l[ord(i) - ord('a')] += 1
c = sum((l[i] & 1 for i in range(26)))
if c == 0 or c == 1:
	print('First')
else:
	print('First' if c & 1 else 'Second')


import os
import sys
from io import BytesIO, IOBase
import heapq as h
import bisect
from types import GeneratorType
BUFSIZE = 8192

class SortedList:

	def __init__(self, iterable=[], _load=200):
		values = sorted(iterable)
		self._len = _len = len(values)
		self._load = _load
		self._lists = _lists = [values[i:i + _load] for i in range(0, _len, _load)]
		self._list_lens = [len(_list) for _list in _lists]
		self._mins = [_list[0] for _list in _lists]
		self._fen_tree = []
		self._rebuild = True

	def _fen_build(self):
		self._fen_tree[:] = self._list_lens
		_fen_tree = self._fen_tree
		for i in range(len(_fen_tree)):
			if i | i + 1 < len(_fen_tree):
				_fen_tree[i | i + 1] += _fen_tree[i]
		self._rebuild = False

	def _fen_update(self, index, value):
		if not self._rebuild:
			_fen_tree = self._fen_tree
			while index < len(_fen_tree):
				_fen_tree[index] += value
				index |= index + 1

	def _fen_query(self, end):
		if self._rebuild:
			self._fen_build()
		_fen_tree = self._fen_tree
		x = 0
		while end:
			x += _fen_tree[end - 1]
			end &= end - 1
		return x

	def _fen_findkth(self, k):
		_list_lens = self._list_lens
		if k < _list_lens[0]:
			return (0, k)
		if k >= self._len - _list_lens[-1]:
			return (len(_list_lens) - 1, k + _list_lens[-1] - self._len)
		if self._rebuild:
			self._fen_build()
		_fen_tree = self._fen_tree
		idx = -1
		for d in reversed(range(len(_fen_tree).bit_length())):
			right_idx = idx + (1 << d)
			if right_idx < len(_fen_tree) and k >= _fen_tree[right_idx]:
				idx = right_idx
				k -= _fen_tree[idx]
		return (idx + 1, k)

	def _delete(self, pos, idx):
		_lists = self._lists
		_mins = self._mins
		_list_lens = self._list_lens
		self._len -= 1
		self._fen_update(pos, -1)
		del _lists[pos][idx]
		_list_lens[pos] -= 1
		if _list_lens[pos]:
			_mins[pos] = _lists[pos][0]
		else:
			del _lists[pos]
			del _list_lens[pos]
			del _mins[pos]
			self._rebuild = True

	def _loc_left(self, value):
		if not self._len:
			return (0, 0)
		_lists = self._lists
		_mins = self._mins
		(lo, pos) = (-1, len(_lists) - 1)
		while lo + 1 < pos:
			mi = lo + pos >> 1
			if value <= _mins[mi]:
				pos = mi
			else:
				lo = mi
		if pos and value <= _lists[pos - 1][-1]:
			pos -= 1
		_list = _lists[pos]
		(lo, idx) = (-1, len(_list))
		while lo + 1 < idx:
			mi = lo + idx >> 1
			if value <= _list[mi]:
				idx = mi
			else:
				lo = mi
		return (pos, idx)

	def _loc_right(self, value):
		if not self._len:
			return (0, 0)
		_lists = self._lists
		_mins = self._mins
		(pos, hi) = (0, len(_lists))
		while pos + 1 < hi:
			mi = pos + hi >> 1
			if value < _mins[mi]:
				hi = mi
			else:
				pos = mi
		_list = _lists[pos]
		(lo, idx) = (-1, len(_list))
		while lo + 1 < idx:
			mi = lo + idx >> 1
			if value < _list[mi]:
				idx = mi
			else:
				lo = mi
		return (pos, idx)

	def add(self, value):
		_load = self._load
		_lists = self._lists
		_mins = self._mins
		_list_lens = self._list_lens
		self._len += 1
		if _lists:
			(pos, idx) = self._loc_right(value)
			self._fen_update(pos, 1)
			_list = _lists[pos]
			_list.insert(idx, value)
			_list_lens[pos] += 1
			_mins[pos] = _list[0]
			if _load + _load < len(_list):
				_lists.insert(pos + 1, _list[_load:])
				_list_lens.insert(pos + 1, len(_list) - _load)
				_mins.insert(pos + 1, _list[_load])
				_list_lens[pos] = _load
				del _list[_load:]
				self._rebuild = True
		else:
			_lists.append([value])
			_mins.append(value)
			_list_lens.append(1)
			self._rebuild = True

	def discard(self, value):
		_lists = self._lists
		if _lists:
			(pos, idx) = self._loc_right(value)
			if idx and _lists[pos][idx - 1] == value:
				self._delete(pos, idx - 1)

	def remove(self, value):
		_len = self._len
		self.discard(value)
		if _len == self._len:
			raise ValueError('{0!r} not in list'.format(value))

	def pop(self, index=-1):
		(pos, idx) = self._fen_findkth(self._len + index if index < 0 else index)
		value = self._lists[pos][idx]
		self._delete(pos, idx)
		return value

	def bisect_left(self, value):
		(pos, idx) = self._loc_left(value)
		return self._fen_query(pos) + idx

	def bisect_right(self, value):
		(pos, idx) = self._loc_right(value)
		return self._fen_query(pos) + idx

	def count(self, value):
		return self.bisect_right(value) - self.bisect_left(value)

	def __len__(self):
		return self._len

	def __getitem__(self, index):
		(pos, idx) = self._fen_findkth(self._len + index if index < 0 else index)
		return self._lists[pos][idx]

	def __delitem__(self, index):
		(pos, idx) = self._fen_findkth(self._len + index if index < 0 else index)
		self._delete(pos, idx)

	def __contains__(self, value):
		_lists = self._lists
		if _lists:
			(pos, idx) = self._loc_left(value)
			return idx < len(_lists[pos]) and _lists[pos][idx] == value
		return False

	def __iter__(self):
		return (value for _list in self._lists for value in _list)

	def __reversed__(self):
		return (value for _list in reversed(self._lists) for value in reversed(_list))

	def __repr__(self):
		return 'SortedList({0})'.format(list(self))

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		import os
		self.os = os
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			self.os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
import collections as col
import math, string

def getInts():
	return [int(s) for s in input().split()]

def getInt():
	return int(input())

def getStrs():
	return [s for s in input().split()]

def getStr():
	return input()

def listStr():
	return list(input())
MOD = 10 ** 9 + 7
mod = 10 ** 9 + 7
t = 1
p = 10 ** 9 + 7

def ncr_util():
	inv[0] = inv[1] = 1
	fact[0] = fact[1] = 1
	for i in range(2, 300001):
		inv[i] = inv[i % p] * (p - p // i) % p
	for i in range(1, 300001):
		inv[i] = inv[i - 1] * inv[i] % p
		fact[i] = fact[i - 1] * i % p

def solve():
	l1 = [0] * 27
	for i in range(len(s)):
		l1[ord(s[i]) - ord('a')] += 1
	(o, e) = (0, 0)
	for i in range(27):
		if l1[i] > 0:
			if l1[i] % 2 == 0:
				e += 1
			else:
				o += 1
	if o <= 1:
		return 'First'
	if o % 2 == 0:
		return 'Second'
	return 'First'
	return 'Second'
for _ in range(t):
	s = input()
	print(solve())


import sys
import bisect
import heapq
from math import *
from collections import defaultdict as dd
from collections import deque
from collections import Counter as c
from itertools import combinations as comb
from bisect import bisect_left as bl, bisect_right as br, bisect
mod = pow(10, 9) + 7
mod2 = 998244353

def data():
	return sys.stdin.readline().strip()

def out(var):
	sys.stdout.write(var)

def l():
	return list(map(int, data().split()))

def sl():
	return list(map(str, data().split()))

def sp():
	return map(int, data().split())

def ssp():
	return map(str, data().split())

def l1d(n, val=0):
	return [val for i in range(n)]

def l2d(n, m, val=0):
	return [[val for i in range(n)] for j in range(m)]
s = data()
count = c(s)
winner = 1
(two, one) = (0, 0)
for i in count.values():
	if i & 1:
		one += 1
	else:
		two += 1
if one <= 1:
	out('First')
	exit()
if one % 2 == 1:
	out('First')
	exit()
out('Second')


s = input()
a = {}
for ch in s:
	if not ch in a:
		a[ch] = 1
	else:
		a[ch] += 1
count = 0
for (ch, n) in a.items():
	if n % 2 == 1:
		count += 1
if count % 2 == 1 or count == 0:
	print('First')
else:
	print('Second')


s = list(str(input()))
k = list(set(s))
chet = 0
nechet = 0
for i in range(len(k)):
	if s.count(k[i]) % 2 == 0:
		chet += 1
	else:
		nechet += 1
if nechet < 2 or nechet % 2 == 1:
	print('First')
else:
	print('Second')


(t, p) = (input(), {})
for i in t:
	p[i] = p.get(i, 0) + 1
s = sum((p[i] % 2 for i in p))
if s < 2:
	print('First')
elif s % 2 == 0:
	print('Second')
else:
	print('First')


def game(s):
	dicti = {}
	for i in s:
		if i in dicti:
			dicti[i] += 1
		else:
			dicti[i] = 1
	odd = 0
	for i in dicti:
		if dicti[i] % 2 == 1:
			odd += 1
	if odd == 0:
		return 'First'
	elif odd == 1:
		return 'First'
	elif odd % 2 == 1:
		return 'First'
	else:
		return 'Second'
s = input()
print(game(s))


def solve(string):
	di = {}
	for char in string:
		if char in di:
			di[char] += 1
		else:
			di.update({char: 1})
	letterToBeRemoved = 0
	for char in di:
		if di[char] % 2 != 0:
			letterToBeRemoved += 1
	if letterToBeRemoved == 0:
		print('First')
		return
	if letterToBeRemoved % 2 == 0:
		print('Second')
	else:
		print('First')
string = input()
solve(string)


s = input()
l1 = [0] * 26
odds = 0
evens = 0
for i in range(0, 26):
	if s.count(chr(i + 97)) % 2 == 0 and s.count(chr(i + 97)) > 0:
		evens += 1
	elif s.count(chr(i + 97)) % 2 == 1:
		odds += 1
if odds % 2 == 1 or odds == 0:
	print('First')
else:
	print('Second')


from collections import defaultdict

def main():
	s = input()
	m = defaultdict(int)
	for c in list(s):
		m[c] += 1
	e = 0
	o = 0
	for k in m:
		if m[k] % 2 == 0:
			e += m[k]
		else:
			o += m[k]
	winner = 0
	while e + o > 0:
		if o == 1:
			break
		if e > 0:
			e -= 1
		else:
			o -= 1
		winner ^= 1
	return 'First' if winner == 0 else 'Second'
print(main())


entrada = input()
letras = [0] * 30
for letra in entrada:
	letras[ord(letra) - ord('a')] += 1
impar = 0
for i in range(len(letras)):
	if letras[i] % 2 != 0:
		impar += 1
if impar % 2 == 1 or impar == 0:
	print('First')
else:
	print('Second')


from collections import Counter as C
s = input()
c = C(s)
ans = 0
for i in c:
	if c[i] & 1:
		ans += 1
ans -= 1
if ans & 1 and ans > 0:
	print('Second')
else:
	print('First')


from string import ascii_lowercase

def is_pallindrome(freq, n):
	even = 0
	odd = 0
	ones = 0
	for i in ascii_lowercase:
		if freq[i] % 2 == 0 and freq[i] != 0:
			even += freq[i]
		elif freq[i] % 2 and freq[i] != 1:
			odd += freq[i]
		elif freq[i] == 1:
			ones += 1
	if n % 2:
		return even == n - 1 and ones == 1
	else:
		return even == n

def delete_char(freq, n):
	even = None
	odd = None
	for i in ascii_lowercase:
		if freq[i] % 2 == 0 and freq[i] != 0:
			if even and freq[i] > freq[even]:
				even = i
			elif even is None:
				even = i
		elif freq[i] % 2:
			if odd and freq[i] > freq[odd]:
				odd = i
			elif odd is None:
				odd = i
	if even:
		freq[even] -= 1
	else:
		freq[odd] -= 1

def main():
	s = input()
	freq = dict.fromkeys(ascii_lowercase, 0)
	n = len(s)
	for i in s:
		freq[i] += 1
	count = 1
	while n > 1:
		if is_pallindrome(freq, n):
			break
		else:
			delete_char(freq, n)
			n -= 1
		count += 1
	if count % 2:
		print('First')
	else:
		print('Second')
main()


st = input()
frequency = [0] * 26
even = 0
odd = 0
for s in st:
	frequency[ord(s) - 97] += 1
for i in frequency:
	if i % 2 == 0:
		even += 1
	else:
		odd += 1
if odd <= 1 or odd % 2 == 1:
	print('First')
elif odd % 2 == 0:
	print('Second')


def best(words):
	for w in words:
		if words[w] % 2 != 0:
			odd = w
			break
	return odd

def palin(words):
	odd = 0
	for w in words:
		if words[w] % 2 != 0:
			odd += 1
	if odd == 0 or odd == 1:
		return True
	else:
		return False
s = input()
words = {}
for x in s:
	words[x] = words.setdefault(x, 0) + 1
player = 'First'
while not palin(words):
	words[best(words)] -= 1
	if player == 'First':
		player = 'Second'
	else:
		player = 'First'
print(player)


str1 = input()
x = len(str1)
li = [0] * 26
for i in str1:
	li[ord(i) - 97] += 1
odd1 = []
even1 = []
for i in range(26):
	if li[i]:
		if li[i] % 2:
			odd1 += [i]
		else:
			even1 += [i]
ans = 0
while True:
	ans ^= 1
	if len(odd1) <= 1:
		break
	if len(even1):
		p = even1.pop()
		if li[p] - 1:
			li[p] -= 1
			odd1 += [p]
	else:
		p = odd1.pop()
		if li[p] - 1:
			li[p] -= 1
			even1 += [p]
print('First ' if ans else 'Second')


def main():
	s = input()
	arr = [0, 0]
	ass = set(s)
	for i in ass:
		arr[s.count(i) % 2] += 1
	if arr[1] and arr[1] % 2 or not arr[1]:
		print('First')
	else:
		print('Second')
main()


s = input()
dic = {}
for i in s:
	if dic.get(i):
		dic[i] += 1
	else:
		dic[i] = 1
c = 0
for i in dic.values():
	if i % 2 == 1:
		c += 1
if c == 0:
	print('First')
elif c % 2 == 0:
	print('Second')
else:
	print('First')


s = input()
ans = sum((s.count(x) % 2 for x in set(s)))
if ans == 0 or ans % 2 == 1:
	print('First')
else:
	print('Second')


x = input()
map_ = {}
for ele in x:
	if ele in map_:
		map_[ele] += 1
	else:
		map_[ele] = 1
c = 0
for ele in map_:
	if map_[ele] % 2 != 0:
		c += 1
if c <= 1:
	print('First')
elif c % 2 == 0:
	print('Second')
else:
	print('First')


from collections import Counter

def main():
	cnt = Counter(input())
	first = True
	while True:
		for (k, v) in cnt.items():
			if v % 2 != 0:
				break
		else:
			print('First' if first else 'Second')
			return
		if len(cnt) == 1:
			print('First' if first else 'Second')
			return
		for (k, v) in cnt.items():
			if v % 2 == 0:
				cnt[k] -= 1
				break
		else:
			for k in cnt:
				cnt[k] -= 1
				break
		first = not first
		cnt += Counter()
main()


s = input()
arr = [0] * 26
ans = 'First'
for i in s:
	arr[ord(i) - 97] += 1
odds = 0
for i in arr:
	if i % 2 != 0:
		odds += 1
if odds > 1 and odds % 2 == 0:
	ans = 'Second'
print(ans)


a = input()
li = []
for i in range(30):
	li.append(0)
for i in a:
	li[ord(i) - ord('a')] += 1
odd = 0
for i in li:
	if i % 2 == 1:
		odd += 1
if odd <= 1:
	print('First')
elif (len(a) - 1) % 2 == 1:
	print('Second')
else:
	print('First')


import sys
from collections import Counter
input = sys.stdin.readline

def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))

def insr():
	s = input()
	return s[:len(s) - 1]

def invr():
	return map(int, input().split())
S = list(insr())
C = Counter(S)
a = 0
for c in C:
	if C[c] % 2 != 0:
		a += 1
if a > 0:
	a -= 1
if a % 2 == 0:
	print('First')
else:
	print('Second')


s = input()
d = {}
for i in s:
	if i not in d:
		d[i] = 1
	else:
		d[i] += 1
e = 0
o = 0
for j in d.values():
	if j % 2 == 0:
		e += 1
	else:
		o += 1
win = -1
while o > 1:
	if e > 0:
		e -= 1
		o += 1
	elif e == 0:
		o -= 1
	win = -win
if win == -1:
	print('First')
else:
	print('Second')


s = list(input())
a = [0] * 26
for i in s:
	a[ord(i) - 97] += 1
odd = 0
for i in a:
	if i % 2 != 0:
		odd += 1
if odd < 2:
	print('First')
elif odd % 2 == 0:
	print('Second')
else:
	print('First')


import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush
from collections import defaultdict as dd, deque, Counter as C
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
from time import perf_counter
from fractions import Fraction
import copy
import time
starttime = time.time()
mod = int(pow(10, 9) + 7)
mod2 = 998244353

def data():
	return sys.stdin.readline().strip()

def out(*var, end='\n'):
	sys.stdout.write(' '.join(map(str, var)) + end)

def L():
	return list(sp())

def sl():
	return list(ssp())

def sp():
	return map(int, data().split())

def ssp():
	return map(str, data().split())

def l1d(n, val=0):
	return [val for i in range(n)]

def l2d(n, m, val=0):
	return [l1d(n, val) for j in range(m)]
try:
	sys.setrecursionlimit(int(pow(10, 6)))
	sys.stdin = open('input.txt', 'r')
except:
	pass
s = input()
d = {}
for c in s:
	d[c] = d.get(c, 0) + 1
odd = 0
for k in d:
	odd += d[k] % 2
if odd <= 1:
	print('First')
elif len(s) % 2 == 0:
	print('Second')
else:
	print('First')
endtime = time.time()


s = input()
l = len(s)
counts = [s.count(c) for c in set(s)]
if sum((c % 2 for c in counts)) <= 1:
	print('First')
else:
	print(('Second', 'First')[l % 2])


word = {}
for char in input():
	try:
		word[char] += 1
	except:
		word[char] = 1
turn = 0
odd = 0
for (char, occ) in word.items():
	if occ % 2 != 0:
		odd += 1
if odd > 0:
	turn = odd - 1
players = ['First', 'Second']
print(players[turn % 2])


import sys, math
from collections import deque, defaultdict
import operator as op
from functools import reduce
I = sys.stdin.readline

def ii():
	return int(I().strip())

def li():
	return list(map(int, I().strip().split()))

def mi():
	return map(int, I().strip().split())

def ncr(n, r, p):
	num = den = 1
	for i in range(r):
		num = num * (n - i) % p
		den = den * (i + 1) % p
	return num * pow(den, p - 2, p) % p

def gcd(x, y):
	while y:
		(x, y) = (y, x % y)
	return x

def valid(row, col, rows, cols, rcross, lcross):
	return rows[row] == 0 and cols[col] == 0 and (rcross[col + row] == 0) and (lcross[col - row] == 0)

def div(n):
	tmp = []
	for i in range(2, int(n ** 0.5) + 1):
		if n % i == 0:
			cnt = 0
			while n % i == 0:
				n = n // i
				cnt += 1
			tmp.append((i, cnt))
	if n > 1:
		tmp.append((n, 1))
	return tmp

def isPrime(n):
	if n <= 1:
		return False
	elif n <= 2:
		return True
	else:
		flag = True
		for i in range(2, int(n ** 0.5) + 1):
			if n % i == 0:
				flag = False
				break
		return flag

def s(b):
	ans = []
	while b > 0:
		tmp = b % 10
		ans.append(tmp)
		b = b // 10
	return ans

def main():
	s = I().strip()
	d = defaultdict(int)
	for i in s:
		d[i] += 1
	odd = 0
	for i in d:
		if d[i] % 2:
			odd += 1
	if odd <= 1:
		print('First')
	elif odd % 2:
		print('First')
	else:
		print('Second')
main()


s = input()
cnt = [0] * 26
for l in s:
	cnt[ord(l) - ord('a')] += 1
odd = 0
for n in cnt:
	if n % 2 == 1:
		odd += 1
if odd == 1 or odd == 0:
	print('First')
elif odd % 2 == 0:
	print('Second')
else:
	print('First')


from collections import *
s = input()
c = Counter(s)
x = 0
for i in c:
	if c[i] % 2 == 1:
		x += 1
if x <= 1:
	print('First')
elif x % 2 == 0:
	print('Second')
else:
	print('First')


s = input()
a = ord('a')
letras = [0] * 26
for l in s:
	letras[ord(l) - a] += 1
qntd_sem_par = 0
for i in letras:
	if i % 2 == 1:
		qntd_sem_par += 1
if qntd_sem_par == 0:
	print('First')
elif qntd_sem_par % 2 == 0:
	print('Second')
else:
	print('First')


s = input()
l = 0
a = [0] * 26
for i in s:
	l += 1
	k = ord(i)
	a[k - 97] += 1
b = [i for i in a if i % 2 == 1]
if len(b) <= 1:
	print('First')
elif l % 2 == 1:
	print('First')
else:
	print('Second')


st = input()
track = dict()
for i in st:
	if not i in track.keys():
		track[i] = 0
	track[i] += 1

def getOdds():
	odds = 0
	for i in track.keys():
		if track[i] % 2 == 1:
			odds += 1
	return odds

def playMove():
	nOdds = getOdds()
	if nOdds < 2:
		return True
	else:
		for i in track.keys():
			if track[i] % 2 == 0:
				track[i] -= 1
				break
		else:
			for i in track.keys():
				track[i] -= 1
				if track[i] == 0:
					del track[i]
				break
		return False
turn = True
while True:
	k = playMove()
	if k:
		if turn:
			print('First')
			break
		else:
			print('Second')
			break
	elif turn:
		turn = False
	else:
		turn = True


import sys
import math

def get_line():
	return list(map(int, sys.stdin.readline().strip().split()))

def in1():
	return int(input())
s = str(input())
n = len(s)
s1 = list(s)
s2 = list(set(s1))
c = 0
for i in s2:
	c += s.count(i) % 2
if c % 2 == 1 or c == 0:
	print('First')
else:
	print('Second')


from collections import Counter
n = list(input())
n1 = [v for v in Counter(n).values()]
count = 0
for x in n1:
	if x % 2 != 0:
		count += 1
if count == 0 or count == 1:
	print('First')
elif count % 2 == 0:
	print('Second')
else:
	print('First')


a = input()
ans = 0
for i in set(a):
	x = a.count(i)
	if x % 2:
		ans += 1
if ans % 2 == 1 or ans == 0:
	print('First')
else:
	print('Second')


s = input()
counts = []
counted = []
for i in s:
	if i not in counted:
		counted.append(i)
		counts.append(s.count(i))
ce = 0
co = 0
for i in counts:
	if i % 2 == 0:
		ce += 1
	else:
		co += 1
if co <= 1:
	print('First')
elif co % 2 == 0:
	print('Second')
else:
	print('First')


s = input().strip()
c = 0
for i in set(s):
	c += s.count(i) % 2
if c % 2 == 1 or c == 0:
	print('First')
else:
	print('Second')


from collections import Counter

def main():
	odds = sum((v % 2 for v in Counter(input()).values()))
	print('First' if odds == 0 or odds % 2 != 0 else 'Second')
main()


import string
s = input()
letters = string.ascii_lowercase
count = dict()
for i in letters:
	count[i] = 0
for i in s:
	count[i] = count[i] + 1
n = len(s)
count_values = list(filter(lambda x: x > 0, count.values()))
n_count = len(count_values)
w = True
while True:
	n_even = len(list(filter(lambda x: x % 2 == 0, count_values)))
	n_odd = n_count - n_even
	changed = False
	if n % 2 == 0 and n_even == n_count:
		break
	if n % 2 == 1 and n_odd == 1:
		break
	if n % 2 == 1 or (n % 2 == 0 and n_odd > 1):
		for i in range(n_count):
			if count_values[i] % 2 == 0 and count_values[i] > 0:
				count_values[i] = count_values[i] - 1
				changed = True
				break
	if not changed:
		for i in range(n_count):
			if count_values[i] > 0:
				count_values[i] = count_values[i] - 1
				changed = True
				break
	n -= 1
	w = not w
ans = 'First' if w else 'Second'
print(ans)


from collections import Counter
p = 0
d = Counter(input())
for c in d:
	if d[c] % 2 != 0:
		p += 1
p = max(1, p)
if p % 2:
	print('First')
else:
	print('Second')


b = input()
if b[:] == b[::-1]:
	print('First')
else:
	m = []
	count = 1
	for i in b:
		if b.count(i) % 2 == 1 and i not in m:
			count += b.count(i)
			m.append(i)
	if count % 2 == 0 or count == 1:
		print('First')
	else:
		print('Second')


s = input()
x = sum((s.count(i) % 2 for i in set(s)))
print('First' if x == 0 or (x and x % 2 != 0) else 'Second')


word = input()
count = 0
for char in set(word):
	if word.count(char) & 1:
		count += 1
if count == 0 or count & 1:
	print('First')
else:
	print('Second')


from collections import Counter
st = input()
n = len(st)
mp = Counter(st)
odd = 0
for (key, val) in mp.items():
	if val % 2 != 0:
		odd += 1
if odd == 0 or odd == 1:
	print('First')
	exit()
if odd % 2 == 0:
	print('Second')
else:
	print('First')


s = list(input())
s.sort()
se = set()
odd = 0
even = 0
count = 0
for i in range(0, len(s)):
	if s[i] not in se:
		se.add(s[i])
		if s.count(s[i]) % 2 == 0:
			even += 1
		else:
			odd += 1
	else:
		pass
if odd == 0 and even > 0:
	print('First')
elif odd == 1 and even >= 0:
	print('First')
else:
	ans = 'first'
	odd += even
	if even % 2 != 0:
		ans = 'Second'
	if odd % 2 == 0 and ans == 'first':
		print('Second')
	elif odd % 2 == 0 and ans == 'Second':
		print('First')
	elif odd % 2 != 0 and ans == 'first':
		print('First')
	else:
		print('Second')


def gint():
	return int(input())

def gint_arr():
	return list(map(int, input().split()))

def gfloat():
	return float(input())

def gfloat_arr():
	return list(map(float, input().split()))

def pair_int():
	return map(int, input().split())
INF = 1 << 31
dx = [-1, 0, 1, 0]
dy = [0, 1, 0, -1]
s = input()
i = 0
cnt = {}
for c in s:
	if c in cnt:
		cnt[c] += 1
	else:
		cnt[c] = 1
odds = 0
for c in cnt.values():
	odds += c & 1
if odds & 1 or not odds:
	print('First')
else:
	print('Second')


import sys
s = sys.stdin.readline()[:-1]
c = sum((s.count(i) % 2 for i in s))
if c == 0 or c % 2:
	print('First')
else:
	print('Second')


def main():
	cnt = [0] * 26
	a_ord = ord('a')
	for c in input():
		cnt[ord(c) - a_ord] += 1
	odds = sum((v % 2 for v in cnt))
	print('First' if odds == 0 or odds % 2 != 0 else 'Second')
main()


s = str(input())
m = {}
for i in s:
	if i in m:
		m[i] += 1
	else:
		m[i] = 1
c = 0
for i in m:
	if m[i] % 2 != 0:
		c += 1
c -= 1
if c % 2 == 0 or c == -1:
	print('First')
else:
	print('Second')


s = input()
d = {}
for i in s:
	if i in d:
		d[i] += 1
	else:
		d[i] = 1
r = sum([x % 2 for x in d.values()])
if len(d) == 1 or r == 0:
	print('First')
elif r % 2 == 1:
	print('First')
else:
	print('Second')


s = str(input())
c = set(s)
d = 0
for i in c:
	if s.count(i) % 2 != 0:
		d = d + 1
e = d - 1
if d == 0 or d == 1:
	print('First')
elif e % 2 == 0:
	print('First')
else:
	print('Second')


a = [0] * 26
for i in input():
	a[ord(i) - ord('a')] += 1
print('First' if sum([i % 2 for i in a]) % 2 == 1 or sum([i % 2 for i in a]) == 0 else 'Second')


from collections import Counter
s = input().strip()
letters = [letter for letter in s]
letter_count = Counter(letters)
quantities = list(letter_count.values())
odd_count = 0
for quantity in quantities:
	if quantity % 2 == 1:
		odd_count += 1
if odd_count <= 1:
	print('First')
elif odd_count % 2 == 0:
	print('Second')
else:
	print('First')


s = input()
d = {}
l = len(s)
for i in range(len(s)):
	if s[i] in d:
		d[s[i]] += 1
		d[s[i]] = d[s[i]] % 2
	else:
		d[s[i]] = 1
a = 0
for r in d:
	a += d[r]
if a > 0:
	a = a - 1
if a % 2 == 0:
	print('First')
else:
	print('Second')


s = str(input())
d = {}
for i in s:
	if i not in d:
		d[i] = 1
	else:
		d[i] += 1
lens = len(s)
odd = even = 0
for i in d:
	if d[i] % 2 == 0:
		even += 1
	else:
		odd += 1
if lens % 2 == 0 and odd == 0:
	print('First')
elif lens % 2 == 1 and odd == 1:
	print('First')
elif lens % 2 == 1:
	print('First')
else:
	print('Second')


s = input()
a = [0] * 26
for i in s:
	a[ord(i) - ord('a')] += 1
w = 0
for i in a:
	if i % 2 == 1:
		w += 1
if w == 0 or w % 2 == 1:
	print('First')
else:
	print('Second')


import os
import sys
from io import BytesIO, IOBase
from collections import Counter

def main():
	ans = sum([1 if x % 2 != 0 else 0 for x in Counter(list(input())).values()])
	print('First' if ans < 1 or ans % 2 != 0 else 'Second')
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


palabra = str(input())
letras = []
veces = []
impar = 0
turno = 'First'
for i in palabra:
	if i in letras:
		pass
	else:
		letras.append(i)
		veces.append(palabra.count(i))
for i in veces:
	if i % 2 != 0:
		impar += 1
	if impar % 2 == 0 and impar > 0:
		turno = 'Second'
	else:
		turno = 'First'
print(turno)


from sys import stdin, stdout
from collections import Counter
from math import ceil
from bisect import bisect_left
from bisect import bisect_right
import math

def ai():
	return list(map(int, stdin.readline().split()))

def ei():
	return map(int, stdin.readline().split())

def ip():
	return int(stdin.readline().strip())

def op(ans):
	return stdout.write(str(ans) + '\n')
s = input()
d = {}
for i in s:
	if i not in d:
		d[i] = 1
	else:
		d[i] += 1
even = odd = 0
ans = d.values()
for i in ans:
	if i % 2 == 0:
		even += 1
	else:
		odd += 1
if odd <= 1:
	print('First')
elif odd % 2 == 0:
	print('Second')
else:
	print('First')


s = input()
dict1 = {}
for i in s:
	if i in dict1:
		dict1[i] += 1
	else:
		dict1[i] = 1
odd = 0
even = 0
for i in dict1:
	if dict1[i] % 2 == 0:
		even += 1
	else:
		odd += 1
if odd <= 1:
	print('First')
elif odd % 2 == 0:
	print('Second')
else:
	print('First')


count = 0
d = {}
str = input()
for i in str:
	if i in d:
		d[i] += 1
	else:
		d[i] = 1
for i in d.keys():
	if d[i] % 2 == 1:
		count += 1
if count <= 1:
	print('First')
elif count % 2 == 1:
	print('First')
else:
	print('Second')


n = input()
a = 0
for i in set(n):
	if n.count(i) % 2 != 0:
		a += 1
if a % 2 == 1 or a == 0:
	print('First')
else:
	print('Second')


from collections import Counter
s = input()
dic = Counter(s)
count = 0
for val in dic.values():
	if val % 2 != 0:
		count += 1
if count == 0:
	print('First')
elif count % 2 == 0:
	print('Second')
else:
	print('First')


from collections import Counter
l = list(map(lambda x: x % 2, list(Counter(input()).values())))
a = sum(l)
b = len(l)
if a == 1 or a == 0:
	print('First')
elif (2 * b - a - 1) % 2 == 0:
	print('First')
else:
	print('Second')


from math import sqrt
s = input()
n = len(s)
d = [0] * 26
for i in s:
	d[ord(i) - 97] += 1
o = 0
e = 0
for i in range(26):
	if d[i] & 1:
		o += 1
	else:
		e += 1
if o == 0 or o & 1:
	print('First')
else:
	print('Second')


def solve():
	s = input()
	j = 0
	st = set(s)
	d = []
	for i in s:
		if s.count(i) % 2 == 1:
			j += 1
			d.append(i)
	if j == 0 or j == 1:
		print('First')
		return
	elif (j - 1) % 2 == 0:
		print('First')
		return
	else:
		print('Second')
		return
try:
	solve()
except:
	pass


s = input()
dic = {}
for i in s:
	if i in dic:
		dic[i] += 1
	else:
		dic[i] = 1
odd_count = 0
for i in dic.keys():
	if dic[i] % 2 != 0:
		odd_count += 1
if odd_count != 0 and odd_count % 2 == 0:
	print('Second')
else:
	print('First')


import sys
import string
import math
from collections import defaultdict
from functools import lru_cache
from collections import Counter
from fractions import Fraction

def mi(s):
	return map(int, s.strip().split())

def lmi(s):
	return list(mi(s))

def tmi(s):
	return tuple(mi(s))

def mf(f, s):
	return map(f, s)

def lmf(f, s):
	return list(mf(f, s))

def js(lst):
	return ' '.join((str(d) for d in lst))

def jsns(lst):
	return ''.join((str(d) for d in lst))

def line():
	return sys.stdin.readline().strip()

def linesp():
	return line().split()

def iline():
	return int(line())

def mat(n):
	matr = []
	for _ in range(n):
		matr.append(linesp())
	return matr

def matns(n):
	mat = []
	for _ in range(n):
		mat.append([c for c in line()])
	return mat

def mati(n):
	mat = []
	for _ in range(n):
		mat.append(lmi(line()))
	return mat

def pmat(mat):
	for row in mat:
		print(js(row))

def main():
	S = line()
	odd = set()
	even = set()
	for c in S:
		if c in odd:
			odd.remove(c)
			even.add(c)
		elif c in even:
			even.remove(c)
			odd.add(c)
		else:
			odd.add(c)
	if len(odd) == 0 or len(odd) % 2 == 1:
		print('First')
	else:
		print('Second')
main()


def check_palindrome(s):
	if len(s) % 2 == 0:
		if s[:len(s) // 2] == s[len(s) // 2:]:
			return True
		else:
			return False
	elif s[:len(s) // 2] == s[1 + len(s) // 2:]:
		return True
	else:
		return False
n = list(input())
s = list(set(n))
ans = 0
for i in range(len(s)):
	if n.count(s[i]) % 2 != 0:
		ans += 1
if ans <= 1:
	print('First')
elif ans % 2 == 0:
	print('Second')
else:
	print('First')


import sys

def main():
	pass

def binary(n):
	return bin(n).replace('0b', '')

def decimal(s):
	return int(s, 2)

def pow2(n):
	p = 0
	while n > 1:
		n //= 2
		p += 1
	return p

def isPrime(n):
	if n == 1:
		return False
	else:
		root = int(n ** 0.5)
		root += 1
		for i in range(2, root):
			if n % i == 0:
				return False
		return True

def lts(l):
	s = ''.join(map(str, l))
	return s

def stl(s):
	l = list(s)
	return l

def sq(a, target, arr=[]):
	s = sum(arr)
	if s == target:
		return arr
	if s >= target:
		return
	for i in range(len(a)):
		n = a[i]
		remaining = a[i + 1:]
		ans = sq(remaining, target, arr + [n])
		if ans:
			return ans
mod = int(1000000000.0) + 7

def sinp():
	return sys.stdin.readline().strip()

def iinp():
	return int(input())

def ninp():
	return map(int, sys.stdin.readline().strip().split())

def llinp():
	return list(map(int, sys.stdin.readline().strip().split()))

def p(xyz):
	print(xyz)

def p2(a, b):
	print(a, b)
import math as m
s = sinp()
freq = [0] * 26
for c in s:
	freq[ord(c) - 97] += 1
x = 0
for i in freq:
	if i % 2 == 1:
		x += 1
if x == 0 or x % 2 == 1:
	print('First')
else:
	print('Second')


s = list(input())
counter = [0 for x in range(26)]
for letter in s:
	counter[ord(letter) - 97] += 1
count_odds = 0
for num in counter:
	if num % 2 != 0:
		count_odds += 1
if count_odds == 0 or count_odds == 1:
	print('First')
else:
	moves = count_odds - 1
	if moves % 2 == 0:
		print('First')
	else:
		print('Second')


import string

def is_even(num):
	return num % 2 == 0
s = input()
d = dict.fromkeys(s, 0)
length = len(s)
for c in s:
	d[c] += 1
odd_count = 0
for key in d:
	if not is_even(d[key]):
		odd_count += 1
if odd_count <= 1:
	print('First')
elif is_even(odd_count):
	print('Second')
else:
	print('First')


s = list(input())
import collections
c = collections.Counter(s)
print('First' if sum((v & 1 for v in c.values())) & 1 or sum((v & 1 for v in c.values())) == 0 else 'Second')


s = input()
d = {}
for char in s:
	d[char] = d.get(char, 0) + 1
count = 0
for item in d:
	if d[item] % 2 == 1:
		count += 1
if count == 0:
	print('First')
elif count % 2 == 0:
	print('Second')
else:
	print('First')


import sys
import string
from heapq import *
from bisect import *
from collections import Counter, defaultdict
from math import fsum, sqrt, gcd, ceil, factorial
from operator import *
from itertools import accumulate
inf = float('inf')
flush = lambda : sys.stdout.flush
comb = lambda x, y: factorial(x) // factorial(y) // factorial(x - y)
en = lambda x: list(enumerate(x))
ip = lambda : input()
ii = lambda : int(input())
r = lambda : map(int, input().split())
rr = lambda : list(r())
s = ip()
x = Counter(s)
x = sum([i % 2 for i in x.values()])
print('First' if x < 2 or x % 2 else 'Second')


s = input()
st = set()
mp = dict()
for i in s:
	if i in st:
		mp[i] += 1
	else:
		mp[i] = 1
		st.add(i)
(od, ev) = (0, 0)
for i in st:
	if mp[i] % 2:
		od += 1
	else:
		ev += 1
if od % 2 == 1 or od == 0:
	print('First')
else:
	print('Second')


s = input()
freq = [0] * 26
for c in s:
	freq[ord(c) - ord('a')] += 1
odds = 0
for i in freq:
	if i % 2 == 1:
		odds += 1
if odds <= 1:
	print('First')
elif odds % 2:
	print('First')
else:
	print('Second')


def can_became_palindrome(s):
	letters = dict()
	for character in s:
		if character in letters:
			del letters[character]
		else:
			letters[character] = 1
	return sum(letters.values()) <= 1
s = input()
print('First') if can_became_palindrome(s) or len(s) % 2 == 1 else print('Second')


import os
import sys
from io import BytesIO, IOBase
from collections import Counter

def canpalidrom(d):
	values = list(d.values())
	odd = 0
	for item in values:
		if item % 2 == 1:
			odd += 1
	if odd == 1 or odd == 0:
		return 1
	else:
		return 0

def removearb(d):
	lst = list(d.keys())
	flag = 0
	for item in lst:
		if d[item] % 2 == 0 and d[item] > 0:
			d[item] -= 1
			flag = 1
			break
	if not flag:
		for item in lst:
			if d[item] > 0:
				d[item] -= 1
				break

def main():
	d = dict(Counter(input()))
	n = 1
	while True:
		if n % 2 == 1:
			if canpalidrom(d):
				print('First')
				break
			else:
				removearb(d)
		elif canpalidrom(d):
			print('Second')
			break
		else:
			removearb(d)
		n += 1

def nouse0():
	a = 420
	b = 420
	print(f'i am nitish{(a + b) // 2}')

def nouse1():
	a = 420
	b = 420
	print(f'i am nitish{(a + b) // 2}')

def nouse2():
	a = 420
	b = 420
	print(f'i am nitish{(a + b) // 2}')
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def nouse3():
	a = 420
	b = 420
	print(f'i am nitish{(a + b) // 2}')

def nouse4():
	a = 420
	b = 420
	print(f'i am nitish{(a + b) // 2}')

def nouse5():
	a = 420
	b = 420
	print(f'i am nitish{(a + b) // 2}')
main()


import sys
from collections import Counter
input = lambda : sys.stdin.readline().strip('\r\n')
s = list(input())
c = Counter(s)
odd = 0
for val in c.values():
	if val % 2 == 1:
		odd += 1
if odd <= 1 or odd % 2 == 1:
	print('First')
else:
	print('Second')


import sys

def Out(x):
	sys.stdout.write(str(x) + '\n')

def In():
	return sys.stdin.readline().strip()

def main():
	s = str(input())
	Map = {}
	for word in s:
		if word not in Map:
			Map[word] = 1
		else:
			Map[word] += 1
	odd = 0
	for (key, value) in Map.items():
		if value & 1 == 1:
			odd += 1
	if odd & 1 or odd == 0:
		print('First')
	else:
		print('Second')
main()


s = input()
freq = [0] * 26
for i in s:
	freq[ord(i) - ord('a')] += 1
ct = 0
for a in freq:
	if a % 2 != 0:
		ct += 1
if ct == 0 or ct == 1:
	print('First')
elif ct % 2 == 0:
	print('Second')
else:
	print('First')


s = input()
d = {}
count = 0
for i in range(len(s)):
	if s[i] not in d:
		d[s[i]] = 1
	else:
		d[s[i]] += 1
for value in d.values():
	if value % 2 == 1:
		count += 1
count = count - 1 if count != 0 else 0
if count % 2 == 0:
	print('First')
else:
	print('Second')


def is_palindrome(counter):
	count = sum(counter.values())
	odd_count = 0
	for val in counter:
		if counter[val] % 2 != 0:
			odd_count += 1
	return odd_count <= 1

def calc(s):
	counter = {}
	for (i, char) in enumerate(s):
		counter[char] = counter.get(char, 0) + 1
	(p1, p2) = ('First', 'Second')
	cur_player = p2
	odd_count = sum([counter[key] % 2 != 0 for key in counter])
	if odd_count == 0 or odd_count == 1:
		return p1
	return p1 if odd_count % 2 != 0 else p2
print(calc(input()))


from sys import stdin, stdout
import math
from itertools import permutations, combinations
from collections import defaultdict
from bisect import bisect_left
from bisect import bisect_right
from collections import deque

def L():
	return list(map(int, stdin.readline().split()))

def In():
	return map(int, stdin.readline().split())

def I():
	return int(stdin.readline())
P = 1000000007

def main():
	s = input()
	lis = [0 for i in range(26)]
	for i in range(len(s)):
		lis[ord(s[i]) - 97] += 1
	c = 0
	for i in range(26):
		c += lis[i] % 2
	if c == 0 or (c - 1) % 2 == 0:
		print('First')
	else:
		print('Second')
main()


string = input()
length = len(string)
countarr = [0] * 26
for i in range(length):
	countarr[ord(string[i]) - 97] += 1
move = 0

def checkpalindrome(countarr):
	if sum(countarr) % 2 == 0:
		for i in range(26):
			if countarr[i] % 2 == 0:
				continue
			else:
				return 0
		return 1
	else:
		flag = 0
		for i in range(26):
			if countarr[i] % 2 == 0:
				continue
			elif countarr[i] % 2 == 1 and flag == 0:
				flag = 1
				continue
			else:
				return 0
		return 1
while True:
	if checkpalindrome(countarr) == 1:
		break
	if length % 2 == 0:
		for i in range(26):
			if countarr[i] % 2 == 0:
				continue
			else:
				countarr[i] -= 1
				length -= 1
				move += 1
				break
	else:
		flag = 0
		for i in range(26):
			if countarr[i] % 2 == 0:
				continue
			elif countarr[i] % 2 == 1 and flag == 0:
				flag = 1
				continue
			else:
				countarr[i] -= 1
				length -= 1
				move += 1
				break
if move % 2 == 0:
	print('First')
else:
	print('Second')


s = input()
d = {}
r = []
for i in s:
	if i in d:
		d[i] += 1
	else:
		d[i] = 1
for (k, v) in d.items():
	if v % 2 != 0:
		r.append(k)
if len(r) % 2 != 0 or len(r) == 0:
	print('First')
else:
	print('Second')


from collections import Counter
s = input()
f = 0
for i in Counter(s).values():
	f += i % 2
if f <= 1:
	exit(print('First'))
if len(s) % 2:
	exit(print('First'))
print('Second')


s = input()
if len(s) % 2 == 0:
	if sum((s.count(i) % 2 for i in s)) == 0:
		print('First')
	elif sum((s.count(i) % 2 for i in s)) % 2 == 0:
		print('Second')
	else:
		print('First')
elif sum((s.count(i) % 2 for i in s)) == 1:
	print('First')
elif sum((s.count(i) % 2 for i in s)) % 2 == 0:
	print('Second')
else:
	print('First')


from collections import Counter
x = list(input())
a = Counter(x)
b = set(x)
c = 0
d = 0
for i in b:
	if a[i] % 2 == 0:
		c += 1
	else:
		d += 1
if d == 0 or d == 1:
	print('First')
else:
	d -= 1
	if d % 2 == 0:
		print('First')
	else:
		print('Second')


from collections import Counter
s = list(map(str, input().strip()))
c = Counter(s)
x = 0
for i in c:
	if c[i] % 2 == 1:
		x += 1
if x < 2:
	print('First')
elif x == 2:
	print('Second')
elif x % 2 == 0:
	print('Second')
else:
	print('First')


f = [0] * 26

def winning():
	global f
	x = [0, 0]
	for i in f:
		if i != 0:
			x[i % 2] += 1
	return x[1] <= 1
s = input()
for i in range(len(s)):
	f[ord(s[i]) - ord('a')] += 1
player = 0
while True:
	if winning():
		break
	else:
		flag = 0
		for i in range(len(f)):
			if f[i] % 2 == 0 and f[i] != 0:
				f[i] -= 1
				flag = 1
				break
		if flag == 0:
			for i in range(len(f)):
				if f[i] > 0:
					f[i] -= 1
					break
	player = (player + 1) % 2
name = ['First', 'Second']
print(name[player])


S = input()
S1 = 'abcdefghijklmnopqrstuvwxyz'
c = 1
for i in range(len(S1)):
	if S.count(S1[i]) % 2 != 0:
		c = 0
if c == 1:
	print('First')
elif len(S) % 2 != 0:
	print('First')
else:
	print('Second')


from string import ascii_lowercase
s = input()
k = 0
for c in ascii_lowercase:
	if s.count(c) % 2 != 0:
		k += 1
if k == 0 or k == 1 or k % 2 != 0:
	print('First')
else:
	print('Second')


s = input()
s = list(s)
s.sort()
l = ['Second', 'First']
counter = 0
i = 0
while i < len(s):
	if s.count(s[i]) % 2 != 0:
		counter += 1
		i += s.count(s[i])
		continue
	i += s.count(s[i])
if counter == 0:
	print('First')
else:
	print(l[counter % 2])


entrada = input()
dic = {}
impares = 0
for c in entrada:
	try:
		dic[c] += 1
		if dic[c] % 2 == 0:
			impares -= 1
		else:
			impares += 1
	except:
		dic[c] = 1
		impares += 1
if impares == 0:
	print('First')
elif impares % 2 == 0:
	print('Second')
else:
	print('First')


def checkPalindrome(s):
	return s == s[::-1]
s = input()
s = list(s)
freq = [0] * 10 ** 3
flag = 0
total = []
if checkPalindrome(s):
	print('First')
else:
	for i in range(len(s)):
		freq[ord(s[i]) - 97] += 1
	for i in range(len(freq)):
		if freq[i] % 2 != 0:
			if freq[i] == 1 and flag == 0:
				flag = 1
				continue
			total.append(freq[i])
	if flag == 0 and len(total) > 0:
		tsum = sum(total) - 1
	else:
		tsum = sum(total)
	if tsum % 2 == 0:
		print('First')
	else:
		print('Second')


word = input()
lets = [0] * 26
for c in word:
	lets[ord(c) - 97] += 1
c = 0
for e in lets:
	if e % 2 == 1:
		c += 1
if c == 0 or c % 2 == 1:
	print('First')
else:
	print('Second')


s = input().rstrip()
p = dict()
for i in s:
	if i in p:
		p[i] += 1
	else:
		p[i] = 1
odd = 0
for i in p:
	if p[i] % 2 == 1:
		odd += 1
if odd == 0:
	print('First')
elif odd == 1:
	print('First')
elif odd % 2 == 0:
	print('Second')
else:
	print('First')


import sys
s = sys.stdin.readline().strip()
hash = [0] * 256
for ch in s:
	hash[ord(ch) - 97] += 1
count = 0
for i in range(256):
	count += 1 if hash[i] % 2 != 0 else 0
if count == 0 or count % 2 != 0:
	print('First')
else:
	print('Second')


s = input()
d = {}
for i in range(len(s)):
	d.setdefault(s[i], 0)
	d[s[i]] += 1
total_count = 0
enter = True
for i in d:
	if d[i] % 2 != 0 and enter == True:
		enter = False
	elif d[i] % 2 != 0:
		total_count += 1
if total_count % 2 == 1:
	print('Second')
else:
	print('First')


from collections import Counter
s = list(input())
dct = Counter(s)
ol = 0
for (key, value) in dct.items():
	if value % 2:
		ol += 1
print('First' if ol < 2 or ol % 2 else 'Second')


from collections import Counter
c = Counter(input())
count = 0
for v in c.values():
	count += v & 1
if count == 0 or count == 1:
	print('First')
	exit()
print('First' if count & 1 else 'Second')


n = input()
n = sorted(n)
c = 0
for i in range(len(n)):
	if n.count(n[i]) % 2 != 0:
		c = c + 1
if c >= 1:
	c = c - 1
if c % 2 == 0:
	print('First')
else:
	print('Second')


st = input()
arr_letters = [0] * 26
arr_odds = []
for i in st:
	arr_letters[ord(i) - 97] += 1
for i in arr_letters:
	if i % 2 == 1:
		arr_odds.append(i)
no_removes = 0
while len(arr_odds) > 1:
	no_removes += 1
	arr_odds.pop()
if no_removes % 2 == 0:
	print('First')
else:
	print('Second')


d = {}
s = input()
for i in range(len(s)):
	if s[i] in d:
		d[s[i]] = d[s[i]] + 1
	else:
		d[s[i]] = 1
r = 0
for key in d:
	if d[key] % 2 != 0:
		r = r + 1
if r == 1:
	print('First')
elif r == 0:
	print('First')
elif r % 2 == 0:
	print('Second')
else:
	print('First')


s = input()
d1 = {}
for i in s:
	if i in d1.keys():
		d1[i] += 1
	else:
		d1[i] = 1
check0 = 0
check1 = 0
for i in list(d1.keys()):
	if d1[i] % 2:
		check1 += 1
	else:
		check0 += 1
if check1 < 1:
	print('First')
elif check1 == 2 and check0 == 0:
	print('Second')
else:
	p = len(s)
	if p % 2:
		print('First')
	else:
		print('Second')


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def fact(x):
	if x == 0:
		return 1
	else:
		return x * fact(x - 1)

def lower_bound(li, num):
	answer = -1
	start = 0
	end = len(li) - 1
	while start <= end:
		middle = (end + start) // 2
		if li[middle] >= num:
			answer = middle
			end = middle - 1
		else:
			start = middle + 1
	return answer

def upper_bound(li, num):
	answer = -1
	start = 0
	end = len(li) - 1
	while start <= end:
		middle = (end + start) // 2
		if li[middle] <= num:
			answer = middle
			start = middle + 1
		else:
			end = middle - 1
	return answer

def abs(x):
	return x if x >= 0 else -x

def binary_search(li, val, lb, ub):
	ans = 0
	while lb <= ub:
		mid = (lb + ub) // 2
		if li[mid] > val:
			ub = mid - 1
		elif val > li[mid]:
			lb = mid + 1
		else:
			ans = 1
			break
	return ans

def sieve_of_eratosthenes(n):
	ans = []
	arr = [1] * (n + 1)
	(arr[0], arr[1], i) = (0, 0, 2)
	while i * i <= n:
		if arr[i] == 1:
			j = i + i
			while j <= n:
				arr[j] = 0
				j += i
		i += 1
	for k in range(n):
		if arr[k] == 1:
			ans.append(k)
	return ans

def nc2(x):
	if x == 1:
		return 0
	else:
		return x * (x - 1) // 2
from collections import Counter
for _ in range(1):
	li = list(input())
	cnt = Counter(li)
	k = 0
	for i in list(cnt.values()):
		if i & 1:
			k += 1
	if k <= 1 or k & 1 == 1:
		print('First')
	else:
		print('Second')


word = sorted(list(input()))
player = 0
stack = []
for letter in word:
	last = len(stack) - 1
	if stack != [] and stack[last] == letter:
		stack.pop()
	else:
		stack.append(letter)
while len(stack) > 1:
	player = (player + 1) % 2
	stack.pop()
if player == 0:
	print('First')
else:
	print('Second')


s = list(input())
cnt = [0] * 26
odd = 0
for i in range(len(s)):
	cnt[ord(s[i]) - ord('a')] += 1
for i in range(26):
	if cnt[i] & 1:
		odd += 1
if odd == 0 or odd & 1:
	print('First')
else:
	print('Second')


s = list(input())
alpha = 'abcdefghijklmnopqrstuvwxyz'
counts = {ch: 0 for ch in alpha}
for ele in s:
	counts[ele] += 1
counts = [counts[k] for k in counts.keys()]
counts = [cnt for cnt in counts if cnt != 0]
ods = 0
for ele in counts:
	if ele % 2:
		ods += 1
dc = {'First': 'Second', 'Second': 'First'}
curl = len(s)
cur = 'First'
while True:
	ak = curl % 2
	if ods - ak == 0 or ods == 0:
		print(cur)
		break
	else:
		for i in range(len(counts)):
			if counts[i] % 2 == 0:
				counts[i] -= 1
				break
		else:
			counts[0] -= 1
			ods -= 1
			if counts[0] == 0:
				counts = counts[1:]
	cur = dc[cur]
	curl -= 1


s = input()
a = []
if s.count('a') != 0:
	a.append(s.count('a'))
if s.count('b') != 0:
	a.append(s.count('b'))
if s.count('c') != 0:
	a.append(s.count('c'))
if s.count('d') != 0:
	a.append(s.count('d'))
if s.count('e') != 0:
	a.append(s.count('e'))
if s.count('f') != 0:
	a.append(s.count('f'))
if s.count('g') != 0:
	a.append(s.count('g'))
if s.count('h') != 0:
	a.append(s.count('h'))
if s.count('i') != 0:
	a.append(s.count('i'))
if s.count('j') != 0:
	a.append(s.count('j'))
if s.count('k') != 0:
	a.append(s.count('k'))
if s.count('l') != 0:
	a.append(s.count('l'))
if s.count('m') != 0:
	a.append(s.count('m'))
if s.count('n') != 0:
	a.append(s.count('n'))
if s.count('o') != 0:
	a.append(s.count('o'))
if s.count('p') != 0:
	a.append(s.count('p'))
if s.count('q') != 0:
	a.append(s.count('q'))
if s.count('r') != 0:
	a.append(s.count('r'))
if s.count('s') != 0:
	a.append(s.count('s'))
if s.count('t') != 0:
	a.append(s.count('t'))
if s.count('u') != 0:
	a.append(s.count('u'))
if s.count('v') != 0:
	a.append(s.count('v'))
if s.count('w') != 0:
	a.append(s.count('w'))
if s.count('x') != 0:
	a.append(s.count('x'))
if s.count('y') != 0:
	a.append(s.count('y'))
if s.count('z') != 0:
	a.append(s.count('z'))
l = len(a)
c = nc = 0
for i in range(l):
	if a[i] % 2 == 0:
		c += 1
	else:
		nc += 1
if nc == 0 or nc % 2 != 0:
	print('First')
else:
	print('Second')


from functools import reduce
strr = input()
num = sum((strr.count(a) % 2 for a in strr))
print('First') if num % 2 == 1 or num == 0 else print('Second')


s = input()
letters = [0] * 26
for x in range(len(s)):
	letter = s[x]
	letters[ord(letter) - ord('a')] += 1
letters = [letters[x] % 2 for x in range(len(letters))]
if sum(letters) == 0 or sum(letters) % 2 == 1:
	print('First')
else:
	print('Second')


from collections import defaultdict
REMOVE = 97

def hasWon(chars):
	odds = 0
	evens = 0
	for val in chars:
		if val % 2 == 0:
			evens += 1
		else:
			odds += 1
	return odds <= 1

def solve(string):
	chars = [0 for _ in range(26)]
	for char in string:
		chars[ord(char) - REMOVE] += 1
	counter = 0
	while True:
		if hasWon(chars):
			break
		remove = None
		oddVal = None
		for (index, ele) in enumerate(chars):
			if ele > 0 and ele % 2 == 0:
				remove = index
				break
			if ele > 0 and ele % 2 == 1:
				oddVal = index
		if remove == None:
			remove = oddVal
		chars[remove] -= 1
		counter += 1
	if counter % 2 == 0:
		return 'First'
	return 'Second'

def readinput():
	string = str(input())
	print(solve(string))
readinput()


lets = []
lets[0:] = input()
yum = 0
for item in lets:
	yum += lets.count(item) % 2
if yum % 2 == 0:
	if yum < 1:
		print('First')
	else:
		print('Second')
else:
	print('First')


s = input()
alpha = [0] * 27
for item in s:
	alpha[ord(item) - ord('a')] += 1
odd = 0
for i in alpha:
	if i != 0:
		if i % 2 != 0:
			odd += 1
if odd == 0 or odd == 1:
	print('First')
elif odd % 2 == 0:
	print('Second')
else:
	print('First')


def pal(s):
	s1 = []
	for i in range(26):
		s1.append(0)
	for x in s:
		s1[ord(x) - 97] += 1
	if len(s) % 2 == 0:
		flag = 0
		for x in s1:
			if x % 2 == 0:
				continue
			else:
				flag = 1
				break
	else:
		flag = 0
		l = 0
		for x in s1:
			if x % 2 == 0:
				continue
			else:
				l += 1
				if l > 1:
					flag = 1
					break
	if flag == 0:
		return 1
	else:
		return 0
g = input()
if pal(g) == 1:
	print('First')
elif len(g) % 2 == 0:
	print('Second')
else:
	print('First')


s = str(input())
D = {}
for letter in s:
	if letter in D:
		D[letter] += 1
	else:
		D[letter] = 1
wins = True
if len(s) % 2 == 0:
	for (key, item) in D.items():
		if not item % 2 == 0:
			wins = False
			break
	if wins == False:
		print('Second')
	else:
		print('First')
else:
	print('First')


def palindrome(str):
	return str[::-1] == str
s = input()
if palindrome(s):
	print('First')
else:
	li = []
	for i in set(list(s)):
		li.append(s.count(i))
	odds = 0
	for i in li:
		if i & 1:
			odds += 1
	if odds & 1 or odds == 0:
		print('First')
	else:
		print('Second')


def main():
	s = input()
	st = (i for i in s)
	k = 0
	for i in st:
		if s.count(i) % 2:
			k += 1
	if k <= 1 or (k > 1 and k % 2 == 1):
		print('First')
		return 0
	if k % 2 == 0:
		print('Second')
	return 0
main()


import sys
input = sys.stdin.readline

def multi_input():
	return map(int, input().split())

def array_print(arr):
	print(' '.join(map(str, arr)))

def check_palindrome(s, a):
	for i in range(len(s) - 1):
		j = ord(s[i]) - ord('a')
		a[j] += 1
	odd = 0
	for i in range(26):
		if a[i] % 2 != 0:
			odd += 1
	if odd > 1:
		return False
	else:
		return True
s = list(input())
n = len(s)
curr_player = 0
while len(s) > 1:
	a = [0] * 26
	if check_palindrome(s, a):
		if curr_player == 0:
			print('First')
			break
		else:
			print('Second')
			break
	else:
		flag = 0
		for i in range(26):
			if a[i] > 0 and a[i] % 2 == 0:
				s.remove(chr(i + ord('a')))
				a[i] -= 1
				flag = 1
				break
		if flag == 0:
			for i in range(26):
				if a[i] > 0:
					s.remove(chr(i + ord('a')))
					a[i] -= 1
					break
	curr_player = 1 - curr_player


def mi():
	return map(int, input().split())
s = input()
c = [0] * 26
for i in s:
	c[ord(i) - ord('a')] += 1
flag = 0
for i in c:
	if i % 2:
		flag += 1
if flag <= 1 or flag % 2 == 1:
	print('First')
else:
	print('Second')


inp = input()
d = dict()
odd = 0
for s in inp:
	if s in d.keys():
		d[s] += 1
	else:
		d[s] = 1
for k in d.values():
	if k % 2 == 1:
		odd += 1
if odd > 1:
	if (odd - 1) % 2 == 0:
		print('First')
	else:
		print('Second')
else:
	print('First')


from collections import Counter
s = input()
d = Counter(s)
count = 0
for (k, v) in d.items():
	if v % 2 == 1:
		count += 1
if count == 0 or count == 1:
	print('First')
else:
	z = count - 1
	if z % 2 == 1:
		print('Second')
	else:
		print('First')


s = input()
from collections import Counter
c = Counter(s)
oc = 0
for i in c:
	if c[i] & 1:
		oc += 1
if oc <= 1:
	print('First')
	exit()
if oc % 2 == 1:
	print('First')
else:
	print('Second')


from collections import Counter
odd_vals = sum([i % 2 for i in Counter(input().strip()).values()])
if odd_vals == 0:
	print('First')
else:
	odd_vals -= 1
	if odd_vals % 2 == 0:
		print('First')
	else:
		print('Second')


string = list(input())
freq = {}
ans = 0
for x in string:
	try:
		freq[x] += 1
	except KeyError:
		freq[x] = 1
for x in freq.values():
	if x % 2 != 0:
		ans += 1
if ans % 2 == 0 and ans != 0:
	print('Second')
else:
	print('First')


from collections import defaultdict
s = [i for i in input()]
d = defaultdict(int)
for i in s:
	d[i] += 1
ar = [v for (k, v) in d.items() if v % 2]
ar.sort()
if sum(ar) % 2 or sum(ar) == 0:
	print('First')
else:
	print('Second')


import sys
import math
import collections
import bisect

def get_ints():
	return map(int, sys.stdin.readline().strip().split())

def get_list():
	return list(map(int, sys.stdin.readline().strip().split()))

def get_string():
	return sys.stdin.readline().strip()
for t in range(1):
	string = list(get_string())
	counter = collections.Counter(string)
	odd = 0
	for i in counter:
		if counter[i] % 2 == 1:
			odd += 1
	if odd <= 1 or odd % 2 == 1:
		print('First')
	else:
		print('Second')


a = input()
l = [i for i in a]
c = 1
d = {}
for i in a:
	if a.count(i) % 2 == 0:
		d[i] = 2
	else:
		d[i] = 1
while l != l[::-1]:
	r = list(set(d.values()))
	condition1 = len(a) % 2 == 0 and len(r) == 1 and (r[0] % 2 == 0)
	condition2 = len(a) % 2 == 1 and len(r) == 2 and (list(d.values()).count(1) == 1)
	if condition1 or condition2:
		break
	elif len(a) % 2 == 0 and list(d.values()).count(1) > 1 or (len(r) != 2 and list(d.values()).count(1) > 1):
		for i in d:
			if d[i] == 1:
				d.pop(i)
				break
		c += 1
	elif len(a) % 2 == 1 and len(r) == 2:
		for i in d:
			if d[i] == 1:
				d.pop(i)
				break
		c += 1
	else:
		break
if c % 2 == 1:
	print('First')
else:
	print('Second')


def igra(s):
	letters = {}
	for elem in s:
		if elem in letters:
			del letters[elem]
		else:
			letters[elem] = 1
	return sum(letters.values()) <= 1
t = input()
if igra(t) or len(t) % 2 == 1:
	print('First')
else:
	print('Second')


import math
s = input()
alphabets = 'abcdefghijklmnopqrstuvwxyz'
alphabet_counts = {}
for alphabet in alphabets:
	alphabet_counts[alphabet] = 0
for letter in s:
	alphabet_counts[letter] += 1
odd_count = 0
for alphabet in alphabet_counts:
	if alphabet_counts[alphabet] % 2 == 1:
		odd_count += 1
if odd_count == 0 or odd_count % 2 == 1:
	print('First')
elif odd_count % 2 == 0:
	print('Second')


import sys
inp = input()
k = 0
count = {}
for i in inp:
	if i not in count:
		count[i] = 1
	else:
		count[i] = (count[i] + 1) % 2
odd = 0
for key in count:
	if count[key]:
		odd += 1
if odd == 0:
	print('First')
elif odd == 1:
	print('First')
elif odd & 1:
	print('First')
else:
	print('Second')


import collections
s = input()
l = []
for i in range(len(s)):
	l.append(s[i])
l = collections.Counter(l)
l = list(l.values())
ans = 0
for i in range(len(l)):
	if l[i] % 2 != 0:
		ans += 1
if ans % 2 != 0 or ans == 0:
	print('First')
else:
	print('Second')


import collections

def solve(n, s):
	counts = collections.Counter(s)
	numOdd = 0
	for c in counts:
		if counts[c] & 1:
			numOdd += 1
	if numOdd == 0 or numOdd == 1:
		return 'First'
	elif numOdd & 1:
		return 'First'
	else:
		return 'Second'
s = input()
n = len(s)
print(solve(n, s))