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

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

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



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

Input

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

Output

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

Examples

Input

aba


Output

First


Input

abca


Output

Second

Solution (in JAVA):

Solution:
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.*;

public class Codeforces {

    private static Print writer;

    private static Scan reader;

    static class Scan {
        private byte[] buf = new byte[1024];  //Buffer of Bytes
        private int index;
        private InputStream in;
        private int total;

        public Scan() throws IOException {
            in = System.in;
        }

        int next() throws IOException {  //Scan method used to scan buf
            if (total < 0)
                throw new InputMismatchException();
            if (index >= total) {
                index = 0;
                total = in.read(buf);
                if (total <= 0)
                    return -1;
            }
            return buf[index++];
        }

        int ni() throws IOException {
            int integer = 0;
            int n = next();
            while (isWhiteSpace(n))   //Removing startPointing whitespaces
                n = next();
            int neg = 1;
            if (n == '-') {           //If Negative Sign encounters
                neg = -1;
                n = next();
            }
            while (!isWhiteSpace(n)) {
                if (n >= '0' && n <= '9') {
                    integer *= 10;
                    integer += n - '0';
                    n = next();
                } else throw new InputMismatchException();
            }
            return neg * integer;
        }

        long nl() throws IOException {
            long integer = 0;
            int n = next();
            while (isWhiteSpace(n))   //Removing startPointing whitespaces
                n = next();
            int neg = 1;
            if (n == '-') {           //If Negative Sign encounters
                neg = -1;
                n = next();
            }
            while (!isWhiteSpace(n)) {
                if (n >= '0' && n <= '9') {
                    integer *= 10;
                    integer += n - '0';
                    n = next();
                } else throw new InputMismatchException();
            }
            return neg * integer;
        }

        String line() throws IOException {
            StringBuilder sb = new StringBuilder();
            int n = next();
            while (isWhiteSpace(n)) n = next();
            while (!isNewLine(n)) {
                sb.append((char) n);
                n = next();
            }
            return sb.toString();
        }

        private boolean isNewLine(int n) {
            return n == '\n' || n == '\r' || n == -1;
        }

        private boolean isWhiteSpace(int n) {
            return n == ' ' || isNewLine(n) || n == '\t';
        }

        int[] nia(int n) throws Exception {
            if (n < 0) throw new Exception("Array size should be non negative");
            int[] array = new int[n];
            for (int i = 0; i < n; i++) array[i] = ni();
            return array;
        }

        int[][] n2dia(int r, int c) throws Exception {
            if (r < 0 || c < 0) throw new Exception("Array size should be non negative");
            int[][] array = new int[r][c];
            for (int i = 0; i < r; i++) array[i] = nia(c);
            return array;
        }

        long[] nla(int n) throws Exception {
            if (n < 0) throw new Exception("Array size should be non negative");
            long[] array = new long[n];
            for (int i = 0; i < n; i++) array[i] = nl();
            return array;
        }

        float[] nfa(int n) throws Exception {
            if (n < 0) throw new Exception("Array size should be non negative");
            float[] array = new float[n];
            for (int i = 0; i < n; i++) array[i] = nl();
            return array;
        }

        double[] nda(int n) throws Exception {
            if (n < 0) throw new Exception("Array size should be non negative");
            double[] array = new double[n];
            for (int i = 0; i < n; i++) array[i] = nl();
            return array;
        }
    }

    static class Print {
        private final BufferedWriter bw;


        Print() {
            bw = new BufferedWriter(new OutputStreamWriter(System.out));
        }

        <T> void print(T str) {
            try {
                bw.append(str.toString());
            } catch (IOException e) {
                System.out.println(e.toString());
            }
        }

        void println() {
            print("\n");
        }

        <T> void println(T str) {
            print(str + "\n");
        }

        void flush() throws IOException {
            bw.flush();
        }

        void close() {
            try {
                bw.close();
            } catch (IOException e) {
                System.out.println(e.toString());
            }
        }
    }

    public static void main (String[] args) throws Exception {
        long startPointTime = System.currentTimeMillis();
        reader = new Scan();
        writer = new Print();
        main2();
        long endTime = System.currentTimeMillis();
        float totalProgramTime = endTime - startPointTime;
        if (args.length > 0 && args[0].equals("time"))
            writer.print("Execution time is " + totalProgramTime + " (" + (totalProgramTime / 1000) + "s)");
        writer.close();
    }

    static class DisjointSet {
        int[] arr;
        int[] size;

        DisjointSet(int n) {
            arr = new int[n + 1];
            size = new int[n + 1];
            size[0] = 0;
            makeSet();
        }
        void makeSet() {
            for (int i = 0; i < arr.length; i++) {
                arr[i] = i;
                size[i] = 1;
            }
        }
        void union(int i, int j) {
            j = find(j);
            i = find(i);
            if (i == j) return;
            arr[j] = arr[i];
            size[i] += size[j];
        }
        int find(int i) {
            if (arr[i] != i) {
                arr[i] = find(arr[i]);
            }
            return arr[i];
        }
        int getSize(int i) {
            i = find(i);
            return size[i];
        }
        public String toString() {
            return Arrays.toString(arr);
        }
    }

    static long MOD = 1_000_000_007L;
    static void main2 () throws Exception {
        String s = reader.line();
        int[] c = new int[26];
        Arrays.fill(c, 0);
        for (int i = 0; i < s.length(); i++) {
            c[s.charAt(i) - 'a']++;
        }
        int odd = 0;
        for (int i = 0; i < 26; i++) {
            if (c[i] % 2 == 1) odd++;
        }
        if(odd <= 1) {
            writer.println("First");
        } else {
            if(odd % 2 == 0)
            writer.println("Second");
            else writer.println("First");
        }
    }
}