Two people play the following string game. Initially the players have got some string s. The players move in turns, the player who cannot make a move loses. 

Before the game began, the string is written on a piece of paper, one letter per cell.

<image> An example of the initial situation at s = "abacaba"

A player's move is the sequence of actions:

  1. The player chooses one of the available pieces of paper with some string written on it. Let's denote it is t. Note that initially, only one piece of paper is available. 
  2. The player chooses in the string t = t1t2... t|t| character in position i (1 ≤ i ≤ |t|) such that for some positive integer l (0 < i - l; i + l ≤ |t|) the following equations hold: ti - 1 = ti + 1, ti - 2 = ti + 2, ..., ti - l = ti + l. 
  3. Player cuts the cell with the chosen character. As a result of the operation, he gets three new pieces of paper, the first one will contain string t1t2... ti - 1, the second one will contain a string consisting of a single character ti, the third one contains string ti + 1ti + 2... t|t|. 

<image> An example of making action (i = 4) with string s = «abacaba»

Your task is to determine the winner provided that both players play optimally well. If the first player wins, find the position of character that is optimal to cut in his first move. If there are multiple positions, print the minimal possible one.

Input

The first line contains string s (1 ≤ |s| ≤ 5000). It is guaranteed that string s only contains lowercase English letters.

Output

If the second player wins, print in the single line "Second" (without the quotes). Otherwise, print in the first line "First" (without the quotes), and in the second line print the minimal possible winning move — integer i (1 ≤ i ≤ |s|).

Examples

Input

abacaba


Output

First
2


Input

abcde


Output

Second

Note

In the first sample the first player has multiple winning moves. But the minimum one is to cut the character in position 2. 

In the second sample the first player has no available moves.
import java.io.*;
import java.util.*;
import java.util.List;


/**
 * Created by Katushka on 11.03.2020.
 */
public class Main {

    static void sortArray(int[] a) {
        Random random = new Random();

        for (int i = 0; i < a.length; i++) {
            int randomPos = random.nextInt(a.length);
            int t = a[i];
            a[i] = a[randomPos];
            a[randomPos] = t;
        }
        Arrays.sort(a);
    }

    static int[] readArray(int size, InputReader in, boolean subOne) {
        int[] a = new int[size];
        for (int i = 0; i < size; i++) {
            a[i] = in.nextInt() + (subOne ? -1 : 0);
        }
        return a;
    }

    static long[] readLongArray(int size, InputReader in) {
        long[] a = new long[size];
        for (int i = 0; i < size; i++) {
            a[i] = in.nextLong();
        }
        return a;
    }

    private static final boolean DEBUG = false;
    private static final long MOD = 1000000007;


    private static int[] getBinary(long a, int size) {
        int[] result = new int[size];
        for (int i = 0; i < size; i++) {
            result[i] = (int) ((a >> i) & 1);
        }
        return result;
    }

    private static long fastPow(long x, long y, long mod) {
        if (x == 1) {
            return 1;
        }
        if (y == 0) {
            return 1;
        }
        long p = fastPow(x, y / 2, mod) % mod;
        p = p * p % mod;
        if (y % 2 == 1) {
            p = p * x % mod;
        }
        return p;
    }

    private static long inv(long x, long mod) {
        return fastPow(x, mod - 2, mod);

    }

    private static long addMod(long x, long y, long mod) {
        long res = x + y;
        if (res >= mod) {
            return res - mod;
        }
        return res;
    }

    private static long multMod(long x, long y, long mod) {
        long res = x * y;
        if (res >= mod) {
            return res % mod;
        }
        return res;
    }

    private static long subMod(long x, long y, long mod) {
        long res = x - y;
        if (res < 0) {
            return res + mod;
        }
        return res;
    }

    public static void main(String[] args) throws FileNotFoundException {
//        InputReader in = new InputReader(new FileInputStream("input.txt"));
//        PrintWriter out = new PrintWriter(new BufferedOutputStream(new FileOutputStream("seating.out")));

        InputReader in = new InputReader(System.in);
        PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));

        String s = in.nextString();
        int n = s.length();

        int[] grundy = new int[n];
        grundy[1] = 1;
        grundy[2] = 1;
        for (int i = 3; i < n; i++) {
            Set<Integer> nums = new HashSet<>();
            nums.add(grundy[i - 2]);
            for (int j = 0; j <= i - 3; j++) {
                nums.add(grundy[j] ^ grundy[i - 3 - j]);
            }
            for (int j = 0; j < nums.size() + 1; j++) {
                if (!nums.contains(j)) {
                    grundy[i] = j;
                    break;
                }
            }
        }

        List<Integer> intervals = new ArrayList<>();
        List<Integer> intervalStarts = new ArrayList<>();
        int intervalStart = -1;
        for (int i = 1; i < n - 1; i++) {
            if (s.charAt(i - 1) == s.charAt(i + 1)) {
                if (intervalStart == -1) {
                    intervalStart = i;
                }
            } else {
                if (intervalStart != -1) {
                    intervals.add(i - intervalStart);
                    intervalStarts.add(intervalStart);
                }
                intervalStart = -1;
            }
        }
        if (intervalStart != -1) {
            intervals.add(n - 1 - intervalStart);
            intervalStarts.add(intervalStart);
        }

        int xor = 0;
        for (int i = 0; i < intervals.size(); i++) {
            xor = xor ^ grundy[intervals.get(i)];
        }

        if (xor == 0) {
            out.println("Second");
        } else {
            out.println("First");
            outer: for (int i = 0; i < intervals.size(); i++) {
                int interval = intervals.get(i);
                intervalStart = intervalStarts.get(i);
                int newXor = xor ^ grundy[interval];

                if (interval == 1) {
                    if (newXor == 0) {
                        out.println(intervalStart + 1);
                        break;
                    }
                } else {
                    if ((newXor ^ grundy[interval - 2]) == 0) {
                        out.println(intervalStart + 1);
                        break;
                    }
                    for (int j = 0; j <= interval - 3; j++) {
                        if ((grundy[j] ^ grundy[interval - 3 - j] ^ newXor) == 0) {
                            out.println(intervalStart + 1 + j + 1);
                            break outer;
                        }
                    }
                }
            }
        }


        out.close();

    }


    private static void outputArray(long[] ans, PrintWriter out, boolean addOne) {
        StringBuilder str = new StringBuilder();
        for (int i = 0; i < ans.length; i++) {
            long an = ans[i] + (addOne ? 1 : 0);
            str.append(an).append('\t');
        }
        out.println(str);
        out.flush();
    }

    private static void outputArray(List<Long> ans, PrintWriter out) {
        StringBuilder str = new StringBuilder();
        for (long an : ans) {
            str.append(an).append(' ');
        }
        out.println(str);
        out.flush();
    }


    private static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public String nextString() {
            try {
                return reader.readLine();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

        public char nextChar() {
            return next().charAt(0);
        }

        public String nextWord() {
            return next();
        }

        private List<Integer>[] readTree(int n) {
            List<Integer>[] result = new ArrayList[n];
            for (int i = 0; i < n; i++) {
                result[i] = new ArrayList<>();
            }
            for (int i = 0; i < n - 1; i++) {
                int u = nextInt() - 1;
                int v = nextInt() - 1;
                result[u].add(v);
                result[v].add(u);
            }
            return result;
        }

    }
}