#!/usr/bin/env python
from __future__ import division, print_function

import os
import sys
from io import BytesIO, IOBase
import datetime

if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip

def main():
    starttime=datetime.datetime.now()
    #ifndef ONLINE_JUDGE
    # sys.stdin=open('input.txt','r')
    # sys.stdout=open('output.txt','w')
    #endif
    for _ in range(int(input())):
        s=input()
        z=len(s)
        l=0
        r=0
        k=0
        m=99999999999999
        for i in range(z-1):
            if s[i]!=s[i+1]:
                l=i
                k=ord(s[i])+ord(s[i+1])
                break
        for i in range(l+1,z-1):
            if s[i]!=s[i+1]:
                if ord(s[i])+ord(s[i+1])==k:
                    l=i
                else:
                    r=i
                    m=min(r-l+2,m)
                    k=ord(s[i])+ord(s[i+1])
                    l=i
        if m==99999999999999:
            print(0)
        else:
            print(m)

    endtime=datetime.datetime.now()
    time=(endtime-starttime).total_seconds()*1000
    # print("Time:",time,"ms")

# region fastio

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")

def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", "\n"))
    if kwargs.pop("flush", False):
        file.flush()

if sys.version_info[0] < 3:
    sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
    sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)

input = lambda: sys.stdin.readline().rstrip("\r\n")

# endregion

if __name__ == "__main__":
    main()


import sys, os, io
def rs(): return sys.stdin.readline().rstrip()
def ri(): return int(sys.stdin.readline())
def ria(): return list(map(int, sys.stdin.readline().split()))
def ws(s): sys.stdout.write(s + '\n')
def wi(n): sys.stdout.write(str(n) + '\n')
def wia(a): sys.stdout.write(' '.join([str(x) for x in a]) + '\n')
import math
from collections import deque
import collections

def main():

    for _ in range(int(input())):
        s=rs()
        z=len(s)
        l=0
        r=0
        k=0
        m=99999999999999
        for i in range(z-1):
            if s[i]!=s[i+1]:
                l=i
                k=ord(s[i])+ord(s[i+1])
                break
        for i in range(l+1,z-1):
            if s[i]!=s[i+1]:
                if ord(s[i])+ord(s[i+1])==k:
                    l=i
                else:
                    r=i
                    m=min(r-l+2,m)
                    k=ord(s[i])+ord(s[i+1])
                    l=i
        if m==99999999999999:
            wi(0)
        else:
            wi(m)

class FastReader(io.IOBase):
    newlines = 0

    def __init__(self, fd, chunk_size=1024 * 8):
        self._fd = fd
        self._chunk_size = chunk_size
        self.buffer = io.BytesIO()

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, self._chunk_size))
            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, size=-1):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, self._chunk_size if size == -1 else size))
            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()

class FastWriter(io.IOBase):

    def __init__(self, fd):
        self._fd = fd
        self.buffer = io.BytesIO()
        self.write = self.buffer.write

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

class FastStdin(io.IOBase):
    def __init__(self, fd=0):
        self.buffer = FastReader(fd)
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")

class FastStdout(io.IOBase):
    def __init__(self, fd=1):
        self.buffer = FastWriter(fd)
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.flush = self.buffer.flush

if __name__ == '__main__':
    sys.stdin = FastStdin()
    sys.stdout = FastStdout()
    main()


for _ in range(int(input())):
    s=input()
    ar=[-1,-1,-1]
    ans=2e6
    z=1
    for i in range(len(s)):
        ar[int(s[i])-1]=i
        if ar.count(-1)==0:
            z=0
            ans=min(ans,max(ar)-min(ar)+1)
    if z: print(0)
    else: print(ans)


t=int(input())
for _ in range(t):
    s=input()
    l=len(s)
    ans=l
    i,j=0,0
    ar=[0,0,0]
    ar[int(s[0])-1]=1
    if s.count('1')!=0 and s.count('2')!=0 and s.count('3')!=0:
        while j<l:
            while ar.count(0)!=0 and j<l-1:
                j+=1
                ar[int(s[j])-1]+=1
                #print(ar,s[j],i,j)
            while ar.count(0)==0 and i<j:
                ar[int(s[i])-1]-=1
                if ar.count(0)==1:
                    ans=min(ans,j-i+1)
                    break
                i+=1
                #print(ar,s[i],i,j)
            j+=1
        print(ans)
    else: print(0)


t=int(input())
for _ in range(t):
    s=input()
    l=len(s)
    ans=l
    i,j=0,0
    ar=[0,0,0]
    ar[int(s[0])-1]=1
    if s.count('1')!=0 and s.count('2')!=0 and s.count('3')!=0:
        while j<l:
            while ar.count(0)!=0 and j<l-1:
                j+=1
                ar[int(s[j])-1]+=1
                #print(ar,s[j],i,j)
            while i<j:
                ar[int(s[i])-1]-=1
                if ar.count(0)==1:
                    ar[int(s[i])-1]+=1
                    ans=min(ans,j-i+1)
                    break
                i+=1
               # print(ar,s[i],i,j)

            j+=1
        print(ans)
    else: print(0)


import sys
LI=lambda:list(map(int, sys.stdin.readline().split()))
MI=lambda:map(int, sys.stdin.readline().split())
SI=lambda:sys.stdin.readline().strip('\n')
II=lambda:int(sys.stdin.readline())

for _ in range(II()):
    s=SI()
    elm={1:set(), 2:set(), 3:set()}
    ind={1:[], 2:[], 3:[]}
    ans=1e18
    for i, c in enumerate(s, 1):
        for j in range(1, 4):
            if int(c)==j and len(elm[j])==1:
                elm[j].clear()
                ind[j].clear()
                elm[j].add(c)
                ind[j].append(i)
            if int(c)==j and len(elm[j])==0:
                elm[j].add(c)
                ind[j].append(i)
            if c not in elm[j]:
                elm[j].add(c)
                ind[j].append(i)
                if len(elm[j])==3:
#                    print(j, elm[j], ind[j])
                    ans=min(ans, ind[j][2]-ind[j][0]+1)
                    elm[j].clear()
                    ind[j].clear()
    print(ans if ans!=1e18 else 0)


import sys
LI=lambda:list(map(int, sys.stdin.readline().split()))
MI=lambda:map(int, sys.stdin.readline().split())
SI=lambda:sys.stdin.readline().strip('\n')
II=lambda:int(sys.stdin.readline())

for _ in range(II()):
    s=SI()
    elm={1:set(), 2:set(), 3:set()}
    ind={1:[], 2:[], 3:[]}
    ans=1e18
    for i, c in enumerate(s, 1):
        for j in range(1, 4):
            if int(c)==j and len(elm[j])==1:
                elm[j].clear()
                ind[j].clear()
                elm[j].add(c)
                ind[j].append(i)
            if int(c)==j and len(elm[j])==0:
                elm[j].add(c)
                ind[j].append(i)
            if c not in elm[j] and int(c)!=j:
                elm[j].add(c)
                ind[j].append(i)
                if len(elm[j])==3:
#                    print(j, elm[j], ind[j])
                    ans=min(ans, ind[j][2]-ind[j][0]+1)
                    elm[j].clear()
                    ind[j].clear()
    print(ans if ans!=1e18 else 0)


import sys
LI=lambda:list(map(int, sys.stdin.readline().split()))
MI=lambda:map(int, sys.stdin.readline().split())
SI=lambda:sys.stdin.readline().strip('\n')
II=lambda:int(sys.stdin.readline())

for _ in range(II()):
    s=SI()
    elm={1:set(), 2:set(), 3:set()}
    ind={1:[], 2:[], 3:[]}
    ans=1e18
    for i, c in enumerate(s, 1):
        for j in range(1, 4):
            if int(c)==j and len(elm[j])==1:
                elm[j].clear()
                ind[j].clear()
                elm[j].add(c)
                ind[j].append(i)
            if int(c)==j and len(elm[j])==0:
                elm[j].add(c)
                ind[j].append(i)
            if c not in elm[j] and len(elm[j]):
                elm[j].add(c)
                ind[j].append(i)
                if len(elm[j])==3:
#                    print(j, elm[j], ind[j])
                    ans=min(ans, ind[j][2]-ind[j][0]+1)
                    elm[j].clear()
                    ind[j].clear()
    print(ans if ans!=1e18 else 0)


import sys
LI=lambda:list(map(int, sys.stdin.readline().split()))
MI=lambda:map(int, sys.stdin.readline().split())
SI=lambda:sys.stdin.readline().strip('\n')
II=lambda:int(sys.stdin.readline())

def upr(s, t):
    global val
    l, r=0, len(val[t])-1
    ret=-1
    while l<=r:
        m=(l+r)//2
        if val[t][m]>=s:
            r=m-1
            ret=m
        else:
            l=m+1
    return ret
def lwr(s, t):
    global val
    l, r=0, len(val[t])-1
    ret=-1
    while l<=r:
        m=(l+r)//2
        if val[t][m]<=s:
            l=m+1
            ret=m
        else:
            r=m-1
    return ret
for _ in range(II()):
    s=SI()
    val={1:[], 2:[], 3:[]}
    for i, c in enumerate(s, 1):
        if c=='1':
            val[1].append(i)
        elif c=='2':
            val[2].append(i)
        else:
            val[3].append(i)
    ans=1e18
    #print(val)
    for i, c in enumerate(s, 1):
        if c=='1':
            _2l, _2u, _3l, _3u=lwr(i, 2), upr(i, 2), lwr(i, 3), upr(i, 3)
            if _2l!=-1 and _3u!=-1:
                ans=min(ans, val[3][_3u]-val[2][_2l]+1)
            if _3l!=-1 and _2u!=-1:
                ans=min(ans, val[2][_2u]-val[3][_3l]+1)
            #print(c, i, _2l, _2u, _3l, _3u)
        elif c=='2':
            _1l, _1u, _3l, _3u=lwr(i, 1), upr(i, 1), lwr(i, 3), upr(i, 3)
            if _1l!=-1 and _3u!=-1:
                ans=min(ans, val[3][_3u]-val[1][_1l]+1)
            if _3l!=-1 and _1u!=-1:
                ans=min(ans, val[1][_1u]-val[3][_3l]+1)
            #print(c, i, _1l, _1u, _3l, _3u)
        else:
            _2l, _2u, _1l, _1u=lwr(i, 2), upr(i, 2), lwr(i, 1), upr(i, 1)
            if _2l!=-1 and _1u!=-1:
                ans=min(ans, val[1][_1u]-val[2][_2l]+1)
            if _1l!=-1 and _2u!=-1:
                ans=min(ans, val[2][_2u]-val[1][_1l]+1)
            #print(c, i, _2l, _2u, _1l, _1u)
    print(ans if ans!=1e18 else 0)


for _ in range(int(input())):
    s=input()
    ch=[-1]*4
    l=len(s)
    ind=l
    for i in range(ind):
        ch[int(s[i])]=i
        if(ch[1]!=-2 and ch[2]!=-1 and ch[3]!=-1):
            a=min(ch[1],ch[2],ch[3])
            b=max(ch[1],ch[2],ch[3])
            if(b-a+1<l):
                l=b-a+1
    if(ch[1]==-1 or ch[2]==-1 or ch[3]==-1):
        print(0)
    else:
        print(l)


for _ in range(int(input())):
    s=input()
    ch=[-1]*4
    l=len(s)
    ind=l
    for i in range(ind):
        ch[int(s[i])]=i
        if(ch[1]!=-2 and ch[2]!=-1 and ch[3]!=-1):
            a=min(ch[1],ch[2],ch[3])
            b=max(ch[1],ch[2],ch[3])
            if(b-a+1<l):
                l=b-a+1
    if(ch[1]!=-1 and ch[2]!=-1 and ch[3]!=-1):
        print(l)
    else:
        print(0)


for _ in range(int(input())):
	s=input()
	vis=[-1]*(4)
	l=len(s)
	p=l
	for i in range(p):
		vis[int(s[i])]=i
		if vis[1]!=-1 and vis[2]!=-1 and vis[3]!=-1:
			m=min(vis[1],vis[2],vis[3])
			n=max(vis[1],vis[2],vis[3])
			if n-m+1<l:
			    l=n-m+1
	if vis[1]!=-1 and vis[2]!=-1 and vis[3]!=-1:
		print(l)
	else:
		print(0)


for _ in range(int(input())):
    s=input()
    ch=[-1]*4
    l=len(s)
    ind=l
    for i in range(ind):
        ch[int(s[i])]=i
        if(ch[1]!=-2 and ch[2]!=-1 and ch[3]!=-1):
            a=min(ch[1],ch[2],ch[3])
            b=max(ch[1],ch[2],ch[3])
            if(b-a+1<l):
                l=b-a+1
    if(ch[1]==-1 and ch[2]==-1 and ch[3]==-1):
        print(0)
    else:
        print(l)


import sys
n = int(input())
for _ in range(n):
    a = input()
    c = len(a)
    rr = set(a)

    p = sys.maxsize-1
    for i in range(0,c):
        z = 0
        for j in range(i+1,c):
            if(a[i]!=a[j] and z==0):
                z = 1
                q = i
                w = j
                continue
            if(z==1 and a[q]!=a[j] and a[j]!=a[w]):
                o = j
                t = max(q,max(w,o))
                l = min(q,min(w,o))
                jj = t+1-l
                p = min(p,jj)
                break
    if(p==2147483646):
        p = 0
    print(p)


import sys
for _ in range(int(input())):
    a = input()
    w = len(a)
    l = set(a)
    if(len(l)<3):
        print(0)
        continue
    p = sys.maxsize - 1
    b,c,d =-1,-1,-1
    for i in range(w):
        if(a[i]=="1"):
            b = i
        elif(a[i]=="2"):
            c = i
        elif(a[i]=="3"):
            d = i
        if(b>-1 and c>-1 and d>-1):
            t = max(b, max(c, d))
            o = min(b, min(c, d))
            jj = t + 1 - o
            p = min(p, jj)
    print(p)


import java.io.*;
import java.util.*;
import java.math.*;

public class F {
    static final boolean RUN_TIMING = false;
    static char[] inputBuffer = new char[1 << 20];
    static PushbackReader in = new PushbackReader(new BufferedReader(new InputStreamReader(System.in)), 1 << 20);
    static PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)), true);
    long[] piles;

    public void go() throws IOException {
        // in = new PushbackReader(new BufferedReader(new FileReader(new File("test.txt"))), 1 << 20);
        // out = new PrintWriter(new FileWriter(new File("output.txt")));
        piles = new long[] {ipar(), ipar(), ipar()};
        // playOne();
        playTwo();
    }

    public void playTwo() throws IOException {
        out.println("Second");
        int prev = -1;
        for (int t = 0; t < 1000; t++) {
            long y = lpar();
            if (y == -1 || y == 0) {
                return;
            }
            HashSet<Integer> choose = new HashSet<>();
            choose.add(0);
            choose.add(1);
            choose.add(2);
            choose.remove(prev);
            // if (piles[0] + y == piles[1] || piles[0] + y == piles[2]) {
            //     choose.remove(0);
            // }
            // if (piles[1] + y == piles[0] || piles[1] + y == piles[2]) {
            //     choose.remove(1);
            // }
            // if (piles[2] + y == piles[0] || piles[2] + y == piles[1]) {
            //     choose.remove(2);
            // }
            // piles[0] += y;
            // if (piles[0] > piles[1] && piles[0] > piles[2]) {
            //     long[] other = {Math.min(piles[1], piles[2]), Math.max(piles[1], piles[2])};
            //     if (other[1] - other[0] == piles[0] - other[1]) {
            //         choose.remove(0);
            //     }
            // }
            // piles[0] -= y;
            // piles[1] += y;
            // if (piles[1] > piles[0] && piles[1] > piles[2]) {
            //     long[] other = {Math.min(piles[0], piles[2]), Math.max(piles[0], piles[2])};
            //     if (other[1] - other[0] == piles[1] - other[1]) {
            //         choose.remove(1);
            //     }
            // }
            // piles[1] -= y;
            // piles[2] += y;
            // if (piles[2] > piles[1] && piles[2] > piles[0]) {
            //     long[] other = {Math.min(piles[1], piles[0]), Math.max(piles[1], piles[0])};
            //     if (other[1] - other[0] == piles[2] - other[1]) {
            //         choose.remove(2);
            //     }
            // }
            // piles[2] -= y;
            if (choose.isEmpty()) {
                if (prev == 0) {
                    out.println(2);
                    piles[1] += y;
                    prev = 1;
                } else {
                    out.println(1);
                    piles[0] += y;
                    prev = 0;
                }
            } else {
                ArrayList<Integer> list = new ArrayList<>(choose);
                int p = list.get((int)(Math.random()*list.size()));
                out.println(p+1);
                piles[p] += y;
                prev = p;
            }
            // out.println(Arrays.toString(piles));
        }
    }

    public void playOne() throws IOException {
        out.println("First");
        long[] temp = new long[3];
        int prev = query(1);
        // out.println(Arrays.toString(piles));
        for (int i = 1; i < 1000; i++) {
            long[] diff;
            if (prev == 1) {
                diff = new long[]{piles[0] - piles[1], piles[0] - piles[2]};
            } else if (prev == 2) {
                diff = new long[]{piles[1] - piles[0], piles[1] - piles[2]};
            } else {
                diff = new long[]{piles[2] - piles[0], piles[2] - piles[1]};
            }
            if (diff[0] < 0 && diff[1] < 0) {
                prev = query(1);
            } else if (diff[0] < 0) {
                prev = query(diff[1]/2+1);
            } else if (diff[1] < 0) {
                prev = query(diff[0]/2+1);
            } else if (diff[0] < diff[1]) {
                prev = query(diff[0]);
            } else {
                prev = query(diff[1]);
            }
            // out.println(Arrays.toString(piles));
        }
    }

    public int query(long x) throws IOException {
        out.println(x);
        int p = ipar();
        if (p < 1) {
            System.exit(-p);
        }
        piles[p-1] += x;
        return p;
    }

    public int ipar() throws IOException {
        return Integer.parseInt(spar());
    }

    public int[] iapar(int n) throws IOException {
        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = ipar();
        }
        return arr;
    }

    public long lpar() throws IOException {
        return Long.parseLong(spar());
    }

    public long[] lapar(int n) throws IOException {
        long[] arr = new long[n];
        for (int i = 0; i < n; i++) {
            arr[i] = lpar();
        }
        return arr;
    }

    public double dpar() throws IOException {
        return Double.parseDouble(spar());
    }

    public String spar() throws IOException {
        int len = 0;
        int c;
        do {
            c = in.read();
        } while (Character.isWhitespace(c) && c != -1);
        if (c == -1) {
            throw new NoSuchElementException("Reached EOF");
        }
        do {
            inputBuffer[len] = (char)c;
            len++;
            c = in.read();
        } while (!Character.isWhitespace(c) && c != -1);
        while (c != '\n' && Character.isWhitespace(c) && c != -1) {
            c = in.read();
        }
        if (c != -1 && c != '\n') {
            in.unread(c);
        }
        return new String(inputBuffer, 0, len);
    }

    public String linepar() throws IOException {
        int len = 0;
        int c;
        while ((c = in.read()) != '\n' && c != -1) {
            if (c == '\r') {
                continue;
            }
            inputBuffer[len] = (char)c;
            len++;
        }
        return new String(inputBuffer, 0, len);
    }

    public boolean haspar() throws IOException {
        String line = linepar();
        if (line.isEmpty()) {
            return false;
        }
        in.unread('\n');
        in.unread(line.toCharArray());
        return true;
    }

    public static void main(String[] args) throws IOException {
        long time = 0;
        time -= System.nanoTime();
        new F().go();
        time += System.nanoTime();
        if (RUN_TIMING) {
            System.out.printf("%.3f ms%n", time / 1000000.0);
        }
        out.flush();
        in.close();
    }
}


import java.io.*;
import java.util.*;
import java.math.*;

public class F {
    static final boolean RUN_TIMING = false;
    static char[] inputBuffer = new char[1 << 20];
    static PushbackReader in = new PushbackReader(new BufferedReader(new InputStreamReader(System.in)), 1 << 20);
    static PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)), true);
    long[] piles;

    public void go() throws IOException {
        // in = new PushbackReader(new BufferedReader(new FileReader(new File("test.txt"))), 1 << 20);
        // out = new PrintWriter(new FileWriter(new File("output.txt")));
        piles = new long[] {ipar(), ipar(), ipar()};
        // playOne();
        playTwo();
    }

    public void playTwo() throws IOException {
        out.println("Second");
        int prev = -1;
        for (int t = 0; t < 1000; t++) {
            long y = lpar();
            if (y == -1) {
                return;
            }
            HashSet<Integer> choose = new HashSet<>();
            choose.add(0);
            choose.add(1);
            choose.add(2);
            choose.remove(prev);
            if (piles[0] + y == piles[1] || piles[0] + y == piles[2]) {
                choose.remove(0);
            }
            if (piles[1] + y == piles[0] || piles[1] + y == piles[2]) {
                choose.remove(1);
            }
            if (piles[2] + y == piles[0] || piles[2] + y == piles[1]) {
                choose.remove(2);
            }
            // piles[0] += y;
            // if (piles[0] > piles[1] && piles[0] > piles[2]) {
            //     long[] other = {Math.min(piles[1], piles[2]), Math.max(piles[1], piles[2])};
            //     if (other[1] - other[0] == piles[0] - other[1]) {
            //         choose.remove(0);
            //     }
            // }
            // piles[0] -= y;
            // piles[1] += y;
            // if (piles[1] > piles[0] && piles[1] > piles[2]) {
            //     long[] other = {Math.min(piles[0], piles[2]), Math.max(piles[0], piles[2])};
            //     if (other[1] - other[0] == piles[1] - other[1]) {
            //         choose.remove(1);
            //     }
            // }
            // piles[1] -= y;
            // piles[2] += y;
            // if (piles[2] > piles[1] && piles[2] > piles[0]) {
            //     long[] other = {Math.min(piles[1], piles[0]), Math.max(piles[1], piles[0])};
            //     if (other[1] - other[0] == piles[2] - other[1]) {
            //         choose.remove(2);
            //     }
            // }
            // piles[2] -= y;
            if (choose.isEmpty()) {
                if (prev == 0) {
                    out.println(2);
                    piles[1] += y;
                    prev = 1;
                } else {
                    out.println(1);
                    piles[0] += y;
                    prev = 0;
                }
            } else {
                ArrayList<Integer> list = new ArrayList<>(choose);
                int p = list.get((int)(Math.random()*list.size()));
                out.println(p+1);
                piles[p] += y;
                prev = p;
            }
            // out.println(Arrays.toString(piles));
        }
        ipar();
    }

    public void playOne() throws IOException {
        out.println("First");
        long[] temp = new long[3];
        int prev = query(1);
        // out.println(Arrays.toString(piles));
        for (int i = 1; i < 1000; i++) {
            long[] diff;
            if (prev == 1) {
                diff = new long[]{piles[0] - piles[1], piles[0] - piles[2]};
            } else if (prev == 2) {
                diff = new long[]{piles[1] - piles[0], piles[1] - piles[2]};
            } else {
                diff = new long[]{piles[2] - piles[0], piles[2] - piles[1]};
            }
            if (diff[0] < 0 && diff[1] < 0) {
                prev = query(1);
            } else if (diff[0] < 0) {
                prev = query(diff[1]/2+1);
            } else if (diff[1] < 0) {
                prev = query(diff[0]/2+1);
            } else if (diff[0] < diff[1]) {
                prev = query(diff[0]);
            } else {
                prev = query(diff[1]);
            }
            // out.println(Arrays.toString(piles));
        }
    }

    public int query(long x) throws IOException {
        out.println(x);
        int p = ipar();
        if (p < 1) {
            System.exit(-p);
        }
        piles[p-1] += x;
        return p;
    }

    public int ipar() throws IOException {
        return Integer.parseInt(spar());
    }

    public int[] iapar(int n) throws IOException {
        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = ipar();
        }
        return arr;
    }

    public long lpar() throws IOException {
        return Long.parseLong(spar());
    }

    public long[] lapar(int n) throws IOException {
        long[] arr = new long[n];
        for (int i = 0; i < n; i++) {
            arr[i] = lpar();
        }
        return arr;
    }

    public double dpar() throws IOException {
        return Double.parseDouble(spar());
    }

    public String spar() throws IOException {
        int len = 0;
        int c;
        do {
            c = in.read();
        } while (Character.isWhitespace(c) && c != -1);
        if (c == -1) {
            throw new NoSuchElementException("Reached EOF");
        }
        do {
            inputBuffer[len] = (char)c;
            len++;
            c = in.read();
        } while (!Character.isWhitespace(c) && c != -1);
        while (c != '\n' && Character.isWhitespace(c) && c != -1) {
            c = in.read();
        }
        if (c != -1 && c != '\n') {
            in.unread(c);
        }
        return new String(inputBuffer, 0, len);
    }

    public String linepar() throws IOException {
        int len = 0;
        int c;
        while ((c = in.read()) != '\n' && c != -1) {
            if (c == '\r') {
                continue;
            }
            inputBuffer[len] = (char)c;
            len++;
        }
        return new String(inputBuffer, 0, len);
    }

    public boolean haspar() throws IOException {
        String line = linepar();
        if (line.isEmpty()) {
            return false;
        }
        in.unread('\n');
        in.unread(line.toCharArray());
        return true;
    }

    public static void main(String[] args) throws IOException {
        long time = 0;
        time -= System.nanoTime();
        new F().go();
        time += System.nanoTime();
        if (RUN_TIMING) {
            System.out.printf("%.3f ms%n", time / 1000000.0);
        }
        out.flush();
        in.close();
    }
}


import java.io.*;
import java.util.*;

import static java.lang.Math.*;
import static java.util.Arrays.*;

public class cf1375f {

    public static void main(String[] args) throws IOException {
        long a[] = rla(3), op;
        prln("First");
        flush();
        prln(op = maxof(a));
        flush();
        a[ri() - 1] += op;
        sort(a);
        prln(2 * a[2] - a[1] - a[0]);
        flush();
        rline();
        close();
    }

    static BufferedReader __in = new BufferedReader(new InputStreamReader(System.in));
    static PrintWriter __out = new PrintWriter(new OutputStreamWriter(System.out));
    static StringTokenizer input;
    static Random rand = new Random();

    // references
    // IBIG = 1e9 + 7
    // IRAND ~= 3e8
    // IMAX ~= 2e10
    // LMAX ~= 9e18
    // constants
    static final int IBIG = 1000000007;
    static final int IRAND = 327859546;
    static final int IMAX = 2147483647;
    static final int IMIN = -2147483648;
    static final long LMAX = 9223372036854775807L;
    static final long LMIN = -9223372036854775808L;
    // util
    static int minof(int a, int b, int c) {return min(a, min(b, c));}
    static int minof(int... x) {if(x.length == 1) return x[0]; if(x.length == 2) return min(x[0], x[1]); if(x.length == 3) return min(x[0], min(x[1], x[2])); int min = x[0]; for(int i = 1; i < x.length; ++i) if(x[i] < min) min = x[i]; return min;}
    static long minof(long a, long b, long c) {return min(a, min(b, c));}
    static long minof(long... x) {if(x.length == 1) return x[0]; if(x.length == 2) return min(x[0], x[1]); if(x.length == 3) return min(x[0], min(x[1], x[2])); long min = x[0]; for(int i = 1; i < x.length; ++i) if(x[i] < min) min = x[i]; return min;}
    static int maxof(int a, int b, int c) {return max(a, max(b, c));}
    static int maxof(int... x) {if(x.length == 1) return x[0]; if(x.length == 2) return max(x[0], x[1]); if(x.length == 3) return max(x[0], max(x[1], x[2])); int max = x[0]; for(int i = 1; i < x.length; ++i) if(x[i] > max) max = x[i]; return max;}
    static long maxof(long a, long b, long c) {return max(a, max(b, c));}
    static long maxof(long... x) {if(x.length == 1) return x[0]; if(x.length == 2) return max(x[0], x[1]); if(x.length == 3) return max(x[0], max(x[1], x[2])); long max = x[0]; for(int i = 1; i < x.length; ++i) if(x[i] > max) max = x[i]; return max;}
    static int powi(int a, int b) {if(a == 0) return 0; int ans = 1; while(b > 0) {if((b & 1) > 0) ans *= a; a *= a; b >>= 1;} return ans;}
    static long powl(long a, int b) {if(a == 0) return 0; long ans = 1; while(b > 0) {if((b & 1) > 0) ans *= a; a *= a; b >>= 1;} return ans;}
    static int floori(double d) {return (int)d;}
    static int ceili(double d) {return (int)ceil(d);}
    static long floorl(double d) {return (long)d;}
    static long ceill(double d) {return (long)ceil(d);}
    static void shuffle(int[] a) {int n = a.length - 1; for(int i = 0; i < n; ++i) {int ind = randInt(i, n); int swap = a[i]; a[i] = a[ind]; a[ind] = swap;}}
    static void shuffle(long[] a) {int n = a.length - 1; for(int i = 0; i < n; ++i) {int ind = randInt(i, n); long swap = a[i]; a[i] = a[ind]; a[ind] = swap;}}
    static void shuffle(double[] a) {int n = a.length - 1; for(int i = 0; i < n; ++i) {int ind = randInt(i, n); double swap = a[i]; a[i] = a[ind]; a[ind] = swap;}}
    static <T> void shuffle(T[] a) {int n = a.length - 1; for(int i = 0; i < n; ++i) {int ind = randInt(i, n); T swap = a[i]; a[i] = a[ind]; a[ind] = swap;}}
    static void rsort(int[] a) {shuffle(a); sort(a);}
    static void rsort(long[] a) {shuffle(a); sort(a);}
    static void rsort(double[] a) {shuffle(a); sort(a);}
    static int randInt(int min, int max) {return rand.nextInt(max - min + 1) + min;}
    // input
    static void r() throws IOException {input = new StringTokenizer(__in.readLine());}
    static int ri() throws IOException {return Integer.parseInt(__in.readLine());}
    static long rl() throws IOException {return Long.parseLong(__in.readLine());}
    static int[] ria(int n) throws IOException {int[] a = new int[n]; input = new StringTokenizer(__in.readLine()); for(int i = 0; i < n; ++i) a[i] = Integer.parseInt(input.nextToken()); return a;}
    static long[] rla(int n) throws IOException {long[] a = new long[n]; input = new StringTokenizer(__in.readLine()); for(int i = 0; i < n; ++i) a[i] = Long.parseLong(input.nextToken()); return a;}
    static char[] rcha() throws IOException {return __in.readLine().toCharArray();}
    static String rline() throws IOException {return __in.readLine();}
    static int rni() throws IOException {input = new StringTokenizer(__in.readLine()); return Integer.parseInt(input.nextToken());}
    static int ni() {return Integer.parseInt(input.nextToken());}
    static long rnl() throws IOException {input = new StringTokenizer(__in.readLine()); return Long.parseLong(input.nextToken());}
    static long nl() {return Long.parseLong(input.nextToken());}
    // output
    static void pr(int i) {__out.print(i);}
    static void prln(int i) {__out.println(i);}
    static void pr(long l) {__out.print(l);}
    static void prln(long l) {__out.println(l);}
    static void pr(double d) {__out.print(d);}
    static void prln(double d) {__out.println(d);}
    static void pr(char c) {__out.print(c);}
    static void prln(char c) {__out.println(c);}
    static void pr(char[] s) {__out.print(new String(s));}
    static void prln(char[] s) {__out.println(new String(s));}
    static void pr(String s) {__out.print(s);}
    static void prln(String s) {__out.println(s);}
    static void pr(Object o) {__out.print(o);}
    static void prln(Object o) {__out.println(o);}
    static void prln() {__out.println();}
    static void pryes() {__out.println("yes");}
    static void pry() {__out.println("Yes");}
    static void prY() {__out.println("YES");}
    static void prno() {__out.println("no");}
    static void prn() {__out.println("No");}
    static void prN() {__out.println("NO");}
    static void pryesno(boolean b) {__out.println(b ? "yes" : "no");};
    static void pryn(boolean b) {__out.println(b ? "Yes" : "No");}
    static void prYN(boolean b) {__out.println(b ? "YES" : "NO");}
    static void prln(int... a) {for(int i = 0, len = a.length - 1; i < len; __out.print(a[i]), __out.print(' '), ++i); __out.println(a[a.length - 1]);}
    static void prln(long... a) {for(int i = 0, len = a.length - 1; i < len; __out.print(a[i]), __out.print(' '), ++i); __out.println(a[a.length - 1]);}
    static <T> void prln(Collection<T> c) {int n = c.size() - 1; Iterator<T> iter = c.iterator(); for(int i = 0; i < n; __out.print(iter.next()), __out.print(' '), ++i); if(n >= 0) __out.println(iter.next());}
    static void h() {__out.println("hlfd");}
    static void flush() {__out.flush();}
    static void close() {__out.close();}
}


import java.io.*;
import java.util.*;

import static java.lang.Math.*;
import static java.util.Arrays.*;

// +8

public class cf1375f {

    public static void main(String[] args) throws IOException {
        long a[][] = new long[3][2];
        r();
        for (int i = 0; i < 3; ++i) {
            a[i][0] = nl();
            a[i][1] = i;
        }
        sort(a, (aa, bb) -> Long.compare(aa[0], bb[0]));
        prln("First");
        flush();
        long delta = a[2][0] - a[0][0];
        prln(delta);
        flush();
        int ind = ri() - 1;
        for (int i = 0; i < 3; ++i) {
            if (a[i][1] == ind) {
                a[i][0] += delta;
                break;
            }
        }
        sort(a, (aa, bb) -> Long.compare(aa[0], bb[0]));
        delta = 2 * a[2][0] - a[1][0] - a[0][0];
        prln(delta);
        flush();
        ind = ri() - 1;
        for (int i = 0; i < 3; ++i) {
            if (a[i][1] == ind) {
                a[i][0] += delta;
                break;
            }
        }
        sort(a, (aa, bb) -> Long.compare(aa[0], bb[0]));
        delta = a[1][0] - a[0][0];
        prln(delta);
        close();
    }

    static BufferedReader __in = new BufferedReader(new InputStreamReader(System.in));
    static PrintWriter __out = new PrintWriter(new OutputStreamWriter(System.out));
    static StringTokenizer input;
    static Random __rand = new Random();

    // references
    // IBIG = 1e9 + 7
    // IMAX ~= 2e9
    // LMAX ~= 9e18

    // constants
    static final int IBIG = 1000000007;
    static final int IMAX = 2147483647;
    static final int IMIN = -2147483648;
    static final long LMAX = 9223372036854775807L;
    static final long LMIN = -9223372036854775808L;
    // math util
    static int minof(int a, int b, int c) {return min(a, min(b, c));}
    static int minof(int... x) {if (x.length == 1) return x[0]; if (x.length == 2) return min(x[0], x[1]); if (x.length == 3) return min(x[0], min(x[1], x[2])); int min = x[0]; for (int i = 1; i < x.length; ++i) if (x[i] < min) min = x[i]; return min;}
    static long minof(long a, long b, long c) {return min(a, min(b, c));}
    static long minof(long... x) {if (x.length == 1) return x[0]; if (x.length == 2) return min(x[0], x[1]); if (x.length == 3) return min(x[0], min(x[1], x[2])); long min = x[0]; for (int i = 1; i < x.length; ++i) if (x[i] < min) min = x[i]; return min;}
    static int maxof(int a, int b, int c) {return max(a, max(b, c));}
    static int maxof(int... x) {if (x.length == 1) return x[0]; if (x.length == 2) return max(x[0], x[1]); if (x.length == 3) return max(x[0], max(x[1], x[2])); int max = x[0]; for (int i = 1; i < x.length; ++i) if (x[i] > max) max = x[i]; return max;}
    static long maxof(long a, long b, long c) {return max(a, max(b, c));}
    static long maxof(long... x) {if (x.length == 1) return x[0]; if (x.length == 2) return max(x[0], x[1]); if (x.length == 3) return max(x[0], max(x[1], x[2])); long max = x[0]; for (int i = 1; i < x.length; ++i) if (x[i] > max) max = x[i]; return max;}
    static int powi(int a, int b) {if (a == 0) return 0; int ans = 1; while (b > 0) {if ((b & 1) > 0) ans *= a; a *= a; b >>= 1;} return ans;}
    static long powl(long a, int b) {if (a == 0) return 0; long ans = 1; while (b > 0) {if ((b & 1) > 0) ans *= a; a *= a; b >>= 1;} return ans;}
    static int fli(double d) {return (int) d;}
    static int cei(double d) {return (int) ceil(d);}
    static long fll(double d) {return (long) d;}
    static long cel(double d) {return (long) ceil(d);}
    static int gcf(int a, int b) {return b == 0 ? a : gcf(b, a % b);}
    static long gcf(long a, long b) {return b == 0 ? a : gcf(b, a % b);}
    static int lcm(int a, int b) {return a * b / gcf(a, b);}
    static long lcm(long a, long b) {return a * b / gcf(a, b);}
    static int randInt(int min, int max) {return __rand.nextInt(max - min + 1) + min;}
    static long mix(long x) {x += 0x9e3779b97f4a7c15L; x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9L; x = (x ^ (x >> 27)) * 0x94d049bb133111ebL; return x ^ (x >> 31);}
    // array util
    static void reverse(int[] a) {for (int i = 0, n = a.length, half = n / 2; i < half; ++i) {int swap = a[i]; a[i] = a[n - i - 1]; a[n - i - 1] = swap;}}
    static void reverse(long[] a) {for (int i = 0, n = a.length, half = n / 2; i < half; ++i) {long swap = a[i]; a[i] = a[n - i - 1]; a[n - i - 1] = swap;}}
    static void reverse(double[] a) {for (int i = 0, n = a.length, half = n / 2; i < half; ++i) {double swap = a[i]; a[i] = a[n - i - 1]; a[n - i - 1] = swap;}}
    static void reverse(char[] a) {for (int i = 0, n = a.length, half = n / 2; i < half; ++i) {char swap = a[i]; a[i] = a[n - i - 1]; a[n - i - 1] = swap;}}
    static void shuffle(int[] a) {int n = a.length - 1; for (int i = 0; i < n; ++i) {int ind = randInt(i, n); int swap = a[i]; a[i] = a[ind]; a[ind] = swap;}}
    static void shuffle(long[] a) {int n = a.length - 1; for (int i = 0; i < n; ++i) {int ind = randInt(i, n); long swap = a[i]; a[i] = a[ind]; a[ind] = swap;}}
    static void shuffle(double[] a) {int n = a.length - 1; for (int i = 0; i < n; ++i) {int ind = randInt(i, n); double swap = a[i]; a[i] = a[ind]; a[ind] = swap;}}
    static void rsort(int[] a) {shuffle(a); sort(a);}
    static void rsort(long[] a) {shuffle(a); sort(a);}
    static void rsort(double[] a) {shuffle(a); sort(a);}
    static int[] copy(int[] a) {int[] ans = new int[a.length]; for (int i = 0; i < a.length; ++i) ans[i] = a[i]; return ans;}
    static long[] copy(long[] a) {long[] ans = new long[a.length]; for (int i = 0; i < a.length; ++i) ans[i] = a[i]; return ans;}
    static double[] copy(double[] a) {double[] ans = new double[a.length]; for (int i = 0; i < a.length; ++i) ans[i] = a[i]; return ans;}
    static char[] copy(char[] a) {char[] ans = new char[a.length]; for (int i = 0; i < a.length; ++i) ans[i] = a[i]; return ans;}
    // graph util
    static List<List<Integer>> g(int n) {List<List<Integer>> g = new ArrayList<>(); for (int i = 0; i < n; ++i) g.add(new ArrayList<>()); return g;}
    static List<Set<Integer>> sg(int n) {List<Set<Integer>> g = new ArrayList<>(); for (int i = 0; i < n; ++i) g.add(new HashSet<>()); return g;}
    static void c(List<? extends Collection<Integer>> g, int u, int v) {g.get(u).add(v); g.get(v).add(u);}
    static void cto(List<? extends Collection<Integer>> g, int u, int v) {g.get(u).add(v);}
    static void dc(List<? extends Collection<Integer>> g, int u, int v) {g.get(u).remove(v); g.get(v).remove(u);}
    static void dcto(List<? extends Collection<Integer>> g, int u, int v) {g.get(u).remove(v);}
    // input
    static void r() throws IOException {input = new StringTokenizer(rline());}
    static int ri() throws IOException {return Integer.parseInt(rline());}
    static long rl() throws IOException {return Long.parseLong(rline());}
    static double rd() throws IOException {return Double.parseDouble(rline());}
    static int[] ria(int n) throws IOException {int[] a = new int[n]; r(); for (int i = 0; i < n; ++i) a[i] = ni(); return a;}
    static int[] riam1(int n) throws IOException {int[] a = new int[n]; r(); for (int i = 0; i < n; ++i) a[i] = ni() - 1; return a;}
    static long[] rla(int n) throws IOException {long[] a = new long[n]; r(); for (int i = 0; i < n; ++i) a[i] = nl(); return a;}
    static double[] rda(int n) throws IOException {double[] a = new double[n]; r(); for (int i = 0; i < n; ++i) a[i] = nd(); return a;}
    static char[] rcha() throws IOException {return rline().toCharArray();}
    static String rline() throws IOException {return __in.readLine();}
    static String n() {return input.nextToken();}
    static int rni() throws IOException {r(); return ni();}
    static int ni() {return Integer.parseInt(n());}
    static long rnl() throws IOException {r(); return nl();}
    static long nl() {return Long.parseLong(n());}
    static double rnd() throws IOException {r(); return nd();}
    static double nd() {return Double.parseDouble(n());}
    static List<List<Integer>> rg(int n, int m) throws IOException {List<List<Integer>> g = g(n); for (int i = 0; i < m; ++i) c(g, rni() - 1, ni() - 1); return g;}
    static void rg(List<List<Integer>> g, int m) throws IOException {for (int i = 0; i < m; ++i) c(g, rni() - 1, ni() - 1);}
    static List<List<Integer>> rdg(int n, int m) throws IOException {List<List<Integer>> g = g(n); for (int i = 0; i < m; ++i) cto(g, rni() - 1, ni() - 1); return g;}
    static void rdg(List<List<Integer>> g, int m) throws IOException {for (int i = 0; i < m; ++i) cto(g, rni() - 1, ni() - 1);}
    static List<Set<Integer>> rsg(int n, int m) throws IOException {List<Set<Integer>> g = sg(n); for (int i = 0; i < m; ++i) c(g, rni() - 1, ni() - 1); return g;}
    static void rsg(List<Set<Integer>> g, int m) throws IOException {for (int i = 0; i < m; ++i) c(g, rni() - 1, ni() - 1);}
    static List<Set<Integer>> rdsg(int n, int m) throws IOException {List<Set<Integer>> g = sg(n); for (int i = 0; i < m; ++i) cto(g, rni() - 1, ni() - 1); return g;}
    static void rdsg(List<Set<Integer>> g, int m) throws IOException {for (int i = 0; i < m; ++i) cto(g, rni() - 1, ni() - 1);}
    // output
    static void pr(int i) {__out.print(i);}
    static void prln(int i) {__out.println(i);}
    static void pr(long l) {__out.print(l);}
    static void prln(long l) {__out.println(l);}
    static void pr(double d) {__out.print(d);}
    static void prln(double d) {__out.println(d);}
    static void pr(char c) {__out.print(c);}
    static void prln(char c) {__out.println(c);}
    static void pr(char[] s) {__out.print(new String(s));}
    static void prln(char[] s) {__out.println(new String(s));}
    static void pr(String s) {__out.print(s);}
    static void prln(String s) {__out.println(s);}
    static void pr(Object o) {__out.print(o);}
    static void prln(Object o) {__out.println(o);}
    static void prln() {__out.println();}
    static void pryes() {prln("yes");}
    static void pry() {prln("Yes");}
    static void prY() {prln("YES");}
    static void prno() {prln("no");}
    static void prn() {prln("No");}
    static void prN() {prln("NO");}
    static void pryesno(boolean b) {prln(b ? "yes" : "no");};
    static void pryn(boolean b) {prln(b ? "Yes" : "No");}
    static void prYN(boolean b) {prln(b ? "YES" : "NO");}
    static void prln(int... a) {for (int i = 0, len = a.length - 1; i < len; pr(a[i]), pr(' '), ++i); if (a.length > 0) prln(a[a.length - 1]); else prln();}
    static void prln(long... a) {for (int i = 0, len = a.length - 1; i < len; pr(a[i]), pr(' '), ++i); if (a.length > 0) prln(a[a.length - 1]); else prln();}
    static void prln(double... a) {for (int i = 0, len = a.length - 1; i < len; pr(a[i]), pr(' '), ++i); if (a.length > 0) prln(a[a.length - 1]); else prln();}
    static <T> void prln(Collection<T> c) {int n = c.size() - 1; Iterator<T> iter = c.iterator(); for (int i = 0; i < n; pr(iter.next()), pr(' '), ++i); if (n >= 0) prln(iter.next()); else prln();}
    static void h() {prln("hlfd"); flush();}
    static void flush() {__out.flush();}
    static void close() {__out.close();}}


import java.io.*;
import java.util.*;

import static java.lang.Math.*;
import static java.util.Arrays.*;

public class cf1375f {

    public static void main(String[] args) throws IOException {
        long a[] = rla(3), op;
        prln("First");
        flush();
        prln(op = maxof(a));
        flush();
        a[ri() - 1] += op;
        sort(a);
        prln(2 * a[2] - a[1] - a[0]);
        flush();
        close();
    }

    static BufferedReader __in = new BufferedReader(new InputStreamReader(System.in));
    static PrintWriter __out = new PrintWriter(new OutputStreamWriter(System.out));
    static StringTokenizer input;
    static Random rand = new Random();

    // references
    // IBIG = 1e9 + 7
    // IRAND ~= 3e8
    // IMAX ~= 2e10
    // LMAX ~= 9e18
    // constants
    static final int IBIG = 1000000007;
    static final int IRAND = 327859546;
    static final int IMAX = 2147483647;
    static final int IMIN = -2147483648;
    static final long LMAX = 9223372036854775807L;
    static final long LMIN = -9223372036854775808L;
    // util
    static int minof(int a, int b, int c) {return min(a, min(b, c));}
    static int minof(int... x) {if(x.length == 1) return x[0]; if(x.length == 2) return min(x[0], x[1]); if(x.length == 3) return min(x[0], min(x[1], x[2])); int min = x[0]; for(int i = 1; i < x.length; ++i) if(x[i] < min) min = x[i]; return min;}
    static long minof(long a, long b, long c) {return min(a, min(b, c));}
    static long minof(long... x) {if(x.length == 1) return x[0]; if(x.length == 2) return min(x[0], x[1]); if(x.length == 3) return min(x[0], min(x[1], x[2])); long min = x[0]; for(int i = 1; i < x.length; ++i) if(x[i] < min) min = x[i]; return min;}
    static int maxof(int a, int b, int c) {return max(a, max(b, c));}
    static int maxof(int... x) {if(x.length == 1) return x[0]; if(x.length == 2) return max(x[0], x[1]); if(x.length == 3) return max(x[0], max(x[1], x[2])); int max = x[0]; for(int i = 1; i < x.length; ++i) if(x[i] > max) max = x[i]; return max;}
    static long maxof(long a, long b, long c) {return max(a, max(b, c));}
    static long maxof(long... x) {if(x.length == 1) return x[0]; if(x.length == 2) return max(x[0], x[1]); if(x.length == 3) return max(x[0], max(x[1], x[2])); long max = x[0]; for(int i = 1; i < x.length; ++i) if(x[i] > max) max = x[i]; return max;}
    static int powi(int a, int b) {if(a == 0) return 0; int ans = 1; while(b > 0) {if((b & 1) > 0) ans *= a; a *= a; b >>= 1;} return ans;}
    static long powl(long a, int b) {if(a == 0) return 0; long ans = 1; while(b > 0) {if((b & 1) > 0) ans *= a; a *= a; b >>= 1;} return ans;}
    static int floori(double d) {return (int)d;}
    static int ceili(double d) {return (int)ceil(d);}
    static long floorl(double d) {return (long)d;}
    static long ceill(double d) {return (long)ceil(d);}
    static void shuffle(int[] a) {int n = a.length - 1; for(int i = 0; i < n; ++i) {int ind = randInt(i, n); int swap = a[i]; a[i] = a[ind]; a[ind] = swap;}}
    static void shuffle(long[] a) {int n = a.length - 1; for(int i = 0; i < n; ++i) {int ind = randInt(i, n); long swap = a[i]; a[i] = a[ind]; a[ind] = swap;}}
    static void shuffle(double[] a) {int n = a.length - 1; for(int i = 0; i < n; ++i) {int ind = randInt(i, n); double swap = a[i]; a[i] = a[ind]; a[ind] = swap;}}
    static <T> void shuffle(T[] a) {int n = a.length - 1; for(int i = 0; i < n; ++i) {int ind = randInt(i, n); T swap = a[i]; a[i] = a[ind]; a[ind] = swap;}}
    static void rsort(int[] a) {shuffle(a); sort(a);}
    static void rsort(long[] a) {shuffle(a); sort(a);}
    static void rsort(double[] a) {shuffle(a); sort(a);}
    static int randInt(int min, int max) {return rand.nextInt(max - min + 1) + min;}
    // input
    static void r() throws IOException {input = new StringTokenizer(__in.readLine());}
    static int ri() throws IOException {return Integer.parseInt(__in.readLine());}
    static long rl() throws IOException {return Long.parseLong(__in.readLine());}
    static int[] ria(int n) throws IOException {int[] a = new int[n]; input = new StringTokenizer(__in.readLine()); for(int i = 0; i < n; ++i) a[i] = Integer.parseInt(input.nextToken()); return a;}
    static long[] rla(int n) throws IOException {long[] a = new long[n]; input = new StringTokenizer(__in.readLine()); for(int i = 0; i < n; ++i) a[i] = Long.parseLong(input.nextToken()); return a;}
    static char[] rcha() throws IOException {return __in.readLine().toCharArray();}
    static String rline() throws IOException {return __in.readLine();}
    static int rni() throws IOException {input = new StringTokenizer(__in.readLine()); return Integer.parseInt(input.nextToken());}
    static int ni() {return Integer.parseInt(input.nextToken());}
    static long rnl() throws IOException {input = new StringTokenizer(__in.readLine()); return Long.parseLong(input.nextToken());}
    static long nl() {return Long.parseLong(input.nextToken());}
    // output
    static void pr(int i) {__out.print(i);}
    static void prln(int i) {__out.println(i);}
    static void pr(long l) {__out.print(l);}
    static void prln(long l) {__out.println(l);}
    static void pr(double d) {__out.print(d);}
    static void prln(double d) {__out.println(d);}
    static void pr(char c) {__out.print(c);}
    static void prln(char c) {__out.println(c);}
    static void pr(char[] s) {__out.print(new String(s));}
    static void prln(char[] s) {__out.println(new String(s));}
    static void pr(String s) {__out.print(s);}
    static void prln(String s) {__out.println(s);}
    static void pr(Object o) {__out.print(o);}
    static void prln(Object o) {__out.println(o);}
    static void prln() {__out.println();}
    static void pryes() {__out.println("yes");}
    static void pry() {__out.println("Yes");}
    static void prY() {__out.println("YES");}
    static void prno() {__out.println("no");}
    static void prn() {__out.println("No");}
    static void prN() {__out.println("NO");}
    static void pryesno(boolean b) {__out.println(b ? "yes" : "no");};
    static void pryn(boolean b) {__out.println(b ? "Yes" : "No");}
    static void prYN(boolean b) {__out.println(b ? "YES" : "NO");}
    static void prln(int... a) {for(int i = 0, len = a.length - 1; i < len; __out.print(a[i]), __out.print(' '), ++i); __out.println(a[a.length - 1]);}
    static void prln(long... a) {for(int i = 0, len = a.length - 1; i < len; __out.print(a[i]), __out.print(' '), ++i); __out.println(a[a.length - 1]);}
    static <T> void prln(Collection<T> c) {int n = c.size() - 1; Iterator<T> iter = c.iterator(); for(int i = 0; i < n; __out.print(iter.next()), __out.print(' '), ++i); if(n >= 0) __out.println(iter.next());}
    static void h() {__out.println("hlfd");}
    static void flush() {__out.flush();}
    static void close() {__out.close();}
}


import java.io.*;
import java.util.*;

import static java.lang.Math.*;
import static java.util.Arrays.*;

public class cf1375f {

    public static void main(String[] args) throws IOException {
        long a[] = rla(3), op;
        prln("First");
        flush();
        prln(op = maxof(a));
        flush();
        a[ri() - 1] += op;
        long b[] = {a[0], a[1], a[2]};
        sort(b);
        prln(op = 2 * b[2] - b[1] - b[0]);
        flush();
        a[ri() - 1] += op;
        sort(a);
        prln(a[1] - a[0]);
        flush();
        rline();
        close();
    }

    static BufferedReader __in = new BufferedReader(new InputStreamReader(System.in));
    static PrintWriter __out = new PrintWriter(new OutputStreamWriter(System.out));
    static StringTokenizer input;
    static Random rand = new Random();

    // references
    // IBIG = 1e9 + 7
    // IRAND ~= 3e8
    // IMAX ~= 2e10
    // LMAX ~= 9e18
    // constants
    static final int IBIG = 1000000007;
    static final int IRAND = 327859546;
    static final int IMAX = 2147483647;
    static final int IMIN = -2147483648;
    static final long LMAX = 9223372036854775807L;
    static final long LMIN = -9223372036854775808L;
    // util
    static int minof(int a, int b, int c) {return min(a, min(b, c));}
    static int minof(int... x) {if(x.length == 1) return x[0]; if(x.length == 2) return min(x[0], x[1]); if(x.length == 3) return min(x[0], min(x[1], x[2])); int min = x[0]; for(int i = 1; i < x.length; ++i) if(x[i] < min) min = x[i]; return min;}
    static long minof(long a, long b, long c) {return min(a, min(b, c));}
    static long minof(long... x) {if(x.length == 1) return x[0]; if(x.length == 2) return min(x[0], x[1]); if(x.length == 3) return min(x[0], min(x[1], x[2])); long min = x[0]; for(int i = 1; i < x.length; ++i) if(x[i] < min) min = x[i]; return min;}
    static int maxof(int a, int b, int c) {return max(a, max(b, c));}
    static int maxof(int... x) {if(x.length == 1) return x[0]; if(x.length == 2) return max(x[0], x[1]); if(x.length == 3) return max(x[0], max(x[1], x[2])); int max = x[0]; for(int i = 1; i < x.length; ++i) if(x[i] > max) max = x[i]; return max;}
    static long maxof(long a, long b, long c) {return max(a, max(b, c));}
    static long maxof(long... x) {if(x.length == 1) return x[0]; if(x.length == 2) return max(x[0], x[1]); if(x.length == 3) return max(x[0], max(x[1], x[2])); long max = x[0]; for(int i = 1; i < x.length; ++i) if(x[i] > max) max = x[i]; return max;}
    static int powi(int a, int b) {if(a == 0) return 0; int ans = 1; while(b > 0) {if((b & 1) > 0) ans *= a; a *= a; b >>= 1;} return ans;}
    static long powl(long a, int b) {if(a == 0) return 0; long ans = 1; while(b > 0) {if((b & 1) > 0) ans *= a; a *= a; b >>= 1;} return ans;}
    static int floori(double d) {return (int)d;}
    static int ceili(double d) {return (int)ceil(d);}
    static long floorl(double d) {return (long)d;}
    static long ceill(double d) {return (long)ceil(d);}
    static void shuffle(int[] a) {int n = a.length - 1; for(int i = 0; i < n; ++i) {int ind = randInt(i, n); int swap = a[i]; a[i] = a[ind]; a[ind] = swap;}}
    static void shuffle(long[] a) {int n = a.length - 1; for(int i = 0; i < n; ++i) {int ind = randInt(i, n); long swap = a[i]; a[i] = a[ind]; a[ind] = swap;}}
    static void shuffle(double[] a) {int n = a.length - 1; for(int i = 0; i < n; ++i) {int ind = randInt(i, n); double swap = a[i]; a[i] = a[ind]; a[ind] = swap;}}
    static <T> void shuffle(T[] a) {int n = a.length - 1; for(int i = 0; i < n; ++i) {int ind = randInt(i, n); T swap = a[i]; a[i] = a[ind]; a[ind] = swap;}}
    static void rsort(int[] a) {shuffle(a); sort(a);}
    static void rsort(long[] a) {shuffle(a); sort(a);}
    static void rsort(double[] a) {shuffle(a); sort(a);}
    static int randInt(int min, int max) {return rand.nextInt(max - min + 1) + min;}
    // input
    static void r() throws IOException {input = new StringTokenizer(__in.readLine());}
    static int ri() throws IOException {return Integer.parseInt(__in.readLine());}
    static long rl() throws IOException {return Long.parseLong(__in.readLine());}
    static int[] ria(int n) throws IOException {int[] a = new int[n]; input = new StringTokenizer(__in.readLine()); for(int i = 0; i < n; ++i) a[i] = Integer.parseInt(input.nextToken()); return a;}
    static long[] rla(int n) throws IOException {long[] a = new long[n]; input = new StringTokenizer(__in.readLine()); for(int i = 0; i < n; ++i) a[i] = Long.parseLong(input.nextToken()); return a;}
    static char[] rcha() throws IOException {return __in.readLine().toCharArray();}
    static String rline() throws IOException {return __in.readLine();}
    static int rni() throws IOException {input = new StringTokenizer(__in.readLine()); return Integer.parseInt(input.nextToken());}
    static int ni() {return Integer.parseInt(input.nextToken());}
    static long rnl() throws IOException {input = new StringTokenizer(__in.readLine()); return Long.parseLong(input.nextToken());}
    static long nl() {return Long.parseLong(input.nextToken());}
    // output
    static void pr(int i) {__out.print(i);}
    static void prln(int i) {__out.println(i);}
    static void pr(long l) {__out.print(l);}
    static void prln(long l) {__out.println(l);}
    static void pr(double d) {__out.print(d);}
    static void prln(double d) {__out.println(d);}
    static void pr(char c) {__out.print(c);}
    static void prln(char c) {__out.println(c);}
    static void pr(char[] s) {__out.print(new String(s));}
    static void prln(char[] s) {__out.println(new String(s));}
    static void pr(String s) {__out.print(s);}
    static void prln(String s) {__out.println(s);}
    static void pr(Object o) {__out.print(o);}
    static void prln(Object o) {__out.println(o);}
    static void prln() {__out.println();}
    static void pryes() {__out.println("yes");}
    static void pry() {__out.println("Yes");}
    static void prY() {__out.println("YES");}
    static void prno() {__out.println("no");}
    static void prn() {__out.println("No");}
    static void prN() {__out.println("NO");}
    static void pryesno(boolean b) {__out.println(b ? "yes" : "no");};
    static void pryn(boolean b) {__out.println(b ? "Yes" : "No");}
    static void prYN(boolean b) {__out.println(b ? "YES" : "NO");}
    static void prln(int... a) {for(int i = 0, len = a.length - 1; i < len; __out.print(a[i]), __out.print(' '), ++i); __out.println(a[a.length - 1]);}
    static void prln(long... a) {for(int i = 0, len = a.length - 1; i < len; __out.print(a[i]), __out.print(' '), ++i); __out.println(a[a.length - 1]);}
    static <T> void prln(Collection<T> c) {int n = c.size() - 1; Iterator<T> iter = c.iterator(); for(int i = 0; i < n; __out.print(iter.next()), __out.print(' '), ++i); if(n >= 0) __out.println(iter.next());}
    static void h() {__out.println("hlfd");}
    static void flush() {__out.flush();}
    static void close() {__out.close();}
}


import static java.lang.Integer.parseInt;
import static java.lang.Long.parseLong;
import static java.lang.Math.max;
import static java.lang.Math.min;
import static java.lang.System.exit;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class F {

	static void solve() throws Exception {
		long a[] = {scanInt(), scanInt(), scanInt()};
		out.println("First");
		long min = min(min(a[0], a[1]), a[2]);
		long max = max(max(a[0], a[1]), a[2]);
		long y = max - min;
		out.println(y);
		out.flush();
		int i = scanInt() - 1;
		if (i < 0) {
			return;
		}
		a[i] += y;
		long sum = a[0] + a[1] + a[2];
		y = 3 * a[i] - sum;
		out.println(y);
		out.flush();
		i = scanInt() - 1;
		if (i < 0) {
			return;
		}
		a[i] += y;
		y = min(a[i] - a[(i + 1) % 3], a[i] - a[(i + 2) % 3]);
		out.println(y);
		out.flush();
		i = scanInt() - 1;
		if (i < 0) {
			return;
		}
		throw new AssertionError();
	}

	static int scanInt() throws IOException {
		return parseInt(scanString());
	}

	static long scanLong() throws IOException {
		return parseLong(scanString());
	}

	static String scanString() throws IOException {
		while (tok == null || !tok.hasMoreTokens()) {
			tok = new StringTokenizer(in.readLine());
		}
		return tok.nextToken();
	}

	static BufferedReader in;
	static PrintWriter out;
	static StringTokenizer tok;

	public static void main(String[] args) {
		try {
			in = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(System.out);
			solve();
			in.close();
			out.close();
		} catch (Throwable e) {
			e.printStackTrace();
			exit(1);
		}
	}
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.PrintStream;
import java.io.IOException;
import java.util.InputMismatchException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.io.BufferedReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		Input in = new Input(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		FIntegerGame solver = new FIntegerGame();
		solver.solve(1, in, out);
		out.close();
	}
	static class FIntegerGame {
		public void solve(int testNumber, Input in, PrintWriter out) {
			long[] arr = new long[] {in.nextInt(), in.nextInt(), in.nextInt()};
			out.println("First");
			out.flush();
			int large = 0, ot1 = -1, ot2 = -1;
			if(arr[1]>arr[0]&&arr[1]>arr[2]) {
				large = 1;
			}else if(arr[2]>arr[0]&&arr[2]>arr[1]) {
				large = 2;
			}
			for(int i = 0; i<3; i++) {
				if(i!=large) {
					if(ot1==-1) {
						ot1 = i;
					}else {
						ot2 = i;
					}
				}
			}
			long y = 2*arr[large]-arr[ot1]-arr[ot2];
			out.println(y);
			out.flush();
			int response = in.nextInt()-1;
			if(response!=large) {
				out.println(arr[large]-arr[response==ot1 ? ot2 : ot1]);
				out.flush();
				response = in.nextInt();
				if(response==0) {
					System.exit(0);
				}else {
					System.out.println("The judge is trolling");
				}
			}else {
				arr[large] += y;
				out.println(2*arr[large]-arr[ot1]-arr[ot2]);
				out.flush();
				response = in.nextInt()-1;
				out.println(arr[large]-arr[response==ot1 ? ot2 : ot1]);
				out.flush();
				response = in.nextInt();
				if(response==0) {
					System.exit(0);
				}else {
					System.out.println("The judge is trolling");
				}
			}
		}

	}

	static class Input {
		BufferedReader br;
		StringTokenizer st;

		public Input(InputStream is) {
			br = new BufferedReader(new InputStreamReader(is));
			try {
				st = new StringTokenizer(br.readLine());
			}catch(IOException e) {
				e.printStackTrace();
			}
		}

		public boolean hasNext() {
			try {
				while(!st.hasMoreTokens()) {
					String s = br.readLine();
					if(s==null) {
						return false;
					}
					st = new StringTokenizer(s);
				}
				return true;
			}catch(Exception e) {
				return false;
			}
		}

		public String next() {
			if(!hasNext()) {
				throw new InputMismatchException();
			}
			return st.nextToken("\r\n\t\f ");
		}

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

	}
}


import java.io.*;
import java.util.*;
import java.math.*;
public class F {
	public static void main(String[] args)throws IOException {
		Scanner sc = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		long a = sc.nextInt();
		long b = sc.nextInt();
		long c = sc.nextInt();
		long query = 10000000000L;
		System.out.println("First");
		System.out.println(query);
		int idx = sc.nextInt();
		if(idx==1) {
			a+=query;
			System.out.println((a-b-(c-a)));
			int ok = sc.nextInt();
			if(ok==2) {
				System.out.println(Math.abs(c-a));
			}else {
				System.out.println(Math.abs(a-b));
			}
		}else if(idx==2) {
			b+=query;
			System.out.println(b-a-(c-b));
			int ok = sc.nextInt();
			if(ok==1) {
				System.out.println(Math.abs(c-b));
			}else {
				System.out.println(Math.abs(b-a));
			}
		}else if(idx==3) {
			c+=query;
			System.out.println(c-a-(b-c));
			int ok = sc.nextInt();
			if(ok==1) {
				System.out.println(Math.abs(b-c));
			}else {
				System.out.println(Math.abs(c-a));
			}
		}
		idx = sc.nextInt();

		out.close();
	}
	static class FastIO {
		InputStream dis;
		byte[] buffer = new byte[1 << 17];
		int pointer = 0;
		public FastIO(String fileName) throws IOException {
			dis = new FileInputStream(fileName);
		}
		public FastIO(InputStream is) throws IOException {
			dis = is;
		}
		int nextInt() throws IOException {
			int ret = 0;

			byte b;
			do {
				b = nextByte();
			} while (b <= ' ');
			boolean negative = false;
			if (b == '-') {
				negative = true;
				b = nextByte();
			}
			while (b >= '0' && b <= '9') {
				ret = 10 * ret + b - '0';
				b = nextByte();
			}

			return (negative) ? -ret : ret;
		}
		long nextLong() throws IOException {
			long ret = 0;

			byte b;
			do {
				b = nextByte();
			} while (b <= ' ');
			boolean negative = false;
			if (b == '-') {
				negative = true;
				b = nextByte();
			}
			while (b >= '0' && b <= '9') {
				ret = 10 * ret + b - '0';
				b = nextByte();
			}
			return (negative) ? -ret : ret;
		}
		byte nextByte() throws IOException {
			if (pointer == buffer.length) {
				dis.read(buffer, 0, buffer.length);
				pointer = 0;
			}
			return buffer[pointer++];
		}
		String next() throws IOException {
			StringBuffer ret = new StringBuffer();

			byte b;
			do {
				b = nextByte();
			} while (b <= ' ');
			while (b > ' ') {
				ret.appendCodePoint(b);
				b = nextByte();
			}

			return ret.toString();
		}
	}
}


//package global9;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Scanner;

public class F2 {
	Scanner in;
	PrintWriter out;
	String INPUT = "";

	void solve()
	{
		int n = 3;
		long[] a = new long[n];
		for(int i = 0;i < n;i++) {
			a[i] = ni();
		}
		out.println("First");
		out.flush();

		long m = 0;
		for(long v : a) {
			m = Math.max(m, v);
		}
		out.println(m);
		out.flush();
		int w = ni()-1;
		if(w == -1)return;
		a[w] += m;

		long max = a[w];
		// a b c
		// 2c-a-b
		out.println(2*max-(a[0]+a[1]+a[2]-a[w]));
		out.flush();

		int t = ni()-1;
		if(t == -1)return;
		a[t] += 2*max-(a[0]+a[1]+a[2]-a[w]);
		Arrays.sort(a);
		out.println(a[1] - a[0]);

		out.flush();
	}

	void run() throws Exception
	{
		in = oj ? new Scanner(System.in) : new Scanner(INPUT);
		out = new PrintWriter(System.out);

		long s = System.currentTimeMillis();
		solve();
		out.flush();
		tr(System.currentTimeMillis()-s+"ms");
	}

	public static void main(String[] args) throws Exception
	{
		new F2().run();
	}

	int ni() { return Integer.parseInt(in.next()); }
	long nl() { return Long.parseLong(in.next()); }
	double nd() { return Double.parseDouble(in.next()); }
	boolean oj = System.getProperty("ONLINE_JUDGE") != null;
	void tr(Object... o) { if(!oj)System.out.println(Arrays.deepToString(o)); }
}


import java.util.*;
import java.io.*;

public class Main {
    public static void main(String[] args)  {

      try{
       PrintWriter out = new PrintWriter(System.out);
                long[] a=new long[3];
                for(int i=0;i<3;i++){
                    a[i]=in.nextInt();

                }
                out.println("First");
                out.println("100000000000");
                int id=in.nextInt();
                a[id-1]+=100000000000l;
                Integer[] pos=new Integer[]{0,1,2};
            Arrays.sort(pos,(p,q)->{
              return Long.compare(a[p],a[q]);
            });
            long y=a[pos[2]]*2-a[pos[0]]-a[pos[1]];
            out.println(y);
            id=in.nextInt();
            if(id==pos[0]+1){
                out.println(a[pos[2]]-a[pos[1]]);
            }else{
                out.println(a[pos[2]]-a[pos[0]]);
            }
             out.flush();
              id=in.nextInt();
           // System.ot.println();

      }catch(Exception e){
          System.out.println(e);
      }
	}

    static class FastReader
    {
        BufferedReader br;
        StringTokenizer st;

        public FastReader()
        {
            br = new BufferedReader(new
                    InputStreamReader(System.in));
        }

        String next()
        {
            while (st == null || !st.hasMoreElements())
            {
                try
                {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException e)
                {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

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

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

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

        String nextLine()
        {
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
    }

    static FastReader in = new FastReader();

}


import java.util.*;
import java.io.*;

public class Main {
    public static void main(String[] args)  {

      try{
       PrintWriter out = new PrintWriter(System.out);
                long[] a=new long[3];
                for(int i=0;i<3;i++){
                    a[i]=in.nextInt();

                }
                out.println("First");
                  out.flush();
                out.println("100000000000");
                  out.flush();
                int id=in.nextInt();
                a[id-1]+=100_000_000_000L;
                Integer[] pos=new Integer[]{0,1,2};
            Arrays.sort(pos,(p,q)->{
              return Long.compare(a[p],a[q]);
            });
            long y=a[pos[2]]*2-a[pos[0]]-a[pos[1]];
            out.println(y);
              out.flush();
            id=in.nextInt();
            if(id==pos[0]+1){
                out.println(a[pos[2]]-a[pos[1]]);
                  out.flush();
            }else{
                out.println(a[pos[2]]-a[pos[0]]);
                  out.flush();
            }
             out.flush();
              id=in.nextInt();
           // System.ot.println();

      }catch(Exception e){
          System.out.println(e);
      }
	}

    static class FastReader
    {
        BufferedReader br;
        StringTokenizer st;

        public FastReader()
        {
            br = new BufferedReader(new
                    InputStreamReader(System.in));
        }

        String next()
        {
            while (st == null || !st.hasMoreElements())
            {
                try
                {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException e)
                {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

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

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

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

        String nextLine()
        {
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
    }

    static FastReader in = new FastReader();

}


import java.io.*;
import java.text.*;
import java.util.*;
import java.math.*;
public class F {
	public static void main(String[] args) throws Exception {
		new F().run();
	}
	public void run() throws Exception {
		FastScanner f = new FastScanner();
		PrintWriter out = new PrintWriter(System.out);
		long[] arr = {f.nextLong(), f.nextLong(), f.nextLong()};
		out.println("Second");
		out.flush();
		int prev = -1;
		while(true) {
			long l = f.nextLong();
			if(l == 0) break;
			for(int i = 0; i < 3; i++) {
				if(i == prev) continue;
				arr[i] += l;
				if(!bad(arr, i)) {
					out.println(i);
					out.flush();
					prev = i;
					break;
				}
				arr[i] -= l;
			}
		}
		out.flush();
	}
	public boolean bad(long[] a, int i) {
		long[] t = new long[3];
		for(int q = 0; q < 3; q++) t[q] = a[q];
		Arrays.sort(t);
		return t[1]-t[0] == t[2]-t[1];
	}
///
	static class FastScanner {
		public BufferedReader reader;
		public StringTokenizer tokenizer;
		public FastScanner() {
			reader = new BufferedReader(new InputStreamReader(System.in), 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 int nextInt() {
			return Integer.parseInt(next());
		}
		public long nextLong() {
			return Long.parseLong(next());
		}
		public double nextDouble() {
			return Double.parseDouble(next());
		}
		public String nextLine() {
			try {
				return reader.readLine();
			} catch(IOException e) {
				throw new RuntimeException(e);
			}
		}
	}
}


import java.io.*;
import java.text.*;
import java.util.*;
import java.math.*;
public class template {
	public static void main(String[] args) throws Exception {
		new template().run();
	}
	public void run() throws Exception {
		FastScanner f = new FastScanner();
		PrintWriter out = new PrintWriter(System.out);
		///
		long[] a = {f.nextLong(), f.nextLong(), f.nextLong()};
		long s = a[0] + a[1] + a[2];
		out.println("First\n10000000000");
		out.flush();
		int i = f.nextInt()-1;
		a[i] += 10000000000L;
		out.println(a[i]*3-10000000000L-s);
		out.flush();
		int j = f.nextInt()-1;
		a[j] += a[i]*3-10000000000L-s;
		out.println(a[j]-a[i]);
		out.flush();
		f.nextInt();
///
		out.flush();
	}
///
	static class FastScanner {
		public BufferedReader reader;
		public StringTokenizer tokenizer;
		public FastScanner() {
			reader = new BufferedReader(new InputStreamReader(System.in), 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 int nextInt() {
			return Integer.parseInt(next());
		}
		public long nextLong() {
			return Long.parseLong(next());
		}
		public double nextDouble() {
			return Double.parseDouble(next());
		}
		public String nextLine() {
			try {
				return reader.readLine();
			} catch(IOException e) {
				throw new RuntimeException(e);
			}
		}
	}
}


import java.io.*;
import java.text.*;
import java.util.*;
import java.math.*;
public class F {
	public static void main(String[] args) throws Exception {
		new F().run();
	}
	public void run() throws Exception {
		FastScanner f = new FastScanner();
		PrintWriter out = new PrintWriter(System.out);
		long[] arr = {f.nextLong(), f.nextLong(), f.nextLong()};
		out.println("Second");
		out.flush();
		int prev = -1;
		while(true) {
			long l = f.nextLong();
			if(l == 0) break;
			for(int i = 0; i < 3; i++) {
				if(i == prev) continue;
				arr[i] += l;
				if(!bad(arr, i)) {
					out.println(i+1);
					out.flush();
					prev = i;
					break;
				}
				arr[i] -= l;
			}
		}
		out.flush();
	}
	public boolean bad(long[] a, int i) {
		long[] t = new long[3];
		for(int q = 0; q < 3; q++) t[q] = a[q];
		Arrays.sort(t);
		return t[1]-t[0] == t[2]-t[1];
	}
///
	static class FastScanner {
		public BufferedReader reader;
		public StringTokenizer tokenizer;
		public FastScanner() {
			reader = new BufferedReader(new InputStreamReader(System.in), 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 int nextInt() {
			return Integer.parseInt(next());
		}
		public long nextLong() {
			return Long.parseLong(next());
		}
		public double nextDouble() {
			return Double.parseDouble(next());
		}
		public String nextLine() {
			try {
				return reader.readLine();
			} catch(IOException e) {
				throw new RuntimeException(e);
			}
		}
	}
}


import java.util.*;

public class Question6 {
static Scanner sc = new Scanner(System.in);

	public static void main(String[] args) {
		long[] arr = new long[3];
		arr[0] = sc.nextLong();
		arr[1] = sc.nextLong();
		arr[2] = sc.nextLong();

		long max = -1;long other = -1;
		long maxi = 0;long min = -1;
		if(arr[0] >= arr[1] && arr[0]>= arr[2]) {
			max = arr[0];
			maxi = 1;
			other = arr[1] + arr[2];
			if(arr[1] < arr[2])min = arr[1];
			else min = arr[2];
		}
		else if(arr[1] >= arr[0] && arr[1] >= arr[2]) {
			max = arr[1];
			maxi = 2;
			other = arr[0] + arr[2];
			if(arr[0] < arr[2])min = arr[0];
			else min = arr[2];
		}
		else {
			max = arr[2];
			maxi = 3;
			other = arr[0] + arr[1];
			if(arr[0] < arr[1])min = arr[0];
			else min = arr[1];

		}
		long val = (2 * max) - other;
		System.out.println("First");

		System.out.println(val);
		long zx = sc.nextInt();
		if(zx == maxi) {

			max = max + val;
			arr[(int)maxi - 1] = max;

			val = (2 * max) - other;
			System.out.println(val);
			long x = sc.nextInt();

			if(x == 1)System.out.println(Math.abs(arr[1] - arr[2]));
			else if(x == 2)System.out.println(Math.abs(arr[0] - arr[2]));
			else System.out.println(Math.abs(arr[0] - arr[1]));
		}
		else {
			if(zx == 1)System.out.println(Math.abs(arr[1] - arr[2]));
			else if(zx == 2)System.out.println(Math.abs(arr[0] - arr[2]));
			else System.out.println(Math.abs(arr[0] - arr[1]));
		}

	}

}


import java.util.*;

public class Question6 {
static Scanner sc = new Scanner(System.in);

	public static void main(String[] args) {
		int[] arr = new int[3];
		arr[0] = sc.nextInt();
		arr[1] = sc.nextInt();
		arr[2] = sc.nextInt();

		int max = -1;int other = -1;
		int maxi = 0;int min = -1;
		if(arr[0] >= arr[1] && arr[0]>= arr[2]) {
			max = arr[0];
			maxi = 1;
			other = arr[1] + arr[2];
			if(arr[1] < arr[2])min = arr[1];
			else min = arr[2];
		}
		else if(arr[1] >= arr[0] && arr[1] >= arr[2]) {
			max = arr[1];
			maxi = 2;
			other = arr[0] + arr[2];
			if(arr[0] < arr[2])min = arr[0];
			else min = arr[2];
		}
		else {
			max = arr[2];
			maxi = 3;
			other = arr[0] + arr[1];
			if(arr[0] < arr[1])min = arr[0];
			else min = arr[1];

		}
		int val = (2 * max) - other;
		System.out.println("First");

		System.out.println(val);
		int zx = sc.nextInt();
		if(zx == maxi) {

			max = max + val;
			val = (2 * max) - other;
			System.out.println(val);
			int x = sc.nextInt();

			if(x == 1)System.out.println(Math.abs(arr[1] - arr[2]));
			else if(x == 2)System.out.println(Math.abs(arr[0] - arr[2]));
			else System.out.println(Math.abs(arr[0] - arr[1]));
		}
		else {
			if(zx == 1)System.out.println(Math.abs(arr[1] - arr[2]));
			else if(zx == 2)System.out.println(Math.abs(arr[0] - arr[2]));
			else System.out.println(Math.abs(arr[0] - arr[1]));
		}

	}
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FastReader in = new FastReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        FIntegerGame solver = new FIntegerGame();
        solver.solve(1, in, out);
        out.close();
    }

    static class FIntegerGame {
        public void solve(int testNumber, FastReader s, PrintWriter out) {
            long a = s.nextLong(), b = s.nextLong(), c = s.nextLong();
            out.println("First");
            out.flush();
            func(a, b, c, s, out);
        }

        private void func(long a, long b, long c, FastReader s, PrintWriter out) {
            FIntegerGame.pair[] arr = new FIntegerGame.pair[3];
            arr[0] = new FIntegerGame.pair(a, 1);
            arr[1] = new FIntegerGame.pair(b, 2);
            arr[2] = new FIntegerGame.pair(c, 3);
            Arrays.sort(arr);
            out.println(2L * arr[2].val - arr[1].val - arr[0].val);
            out.flush();
            int curr = s.nextInt();
            if (curr == arr[0].ind) {
                out.println(arr[2].val - arr[1].val);
                out.flush();
                int curr1 = s.nextInt();
            } else if (curr == arr[1].ind) {
                out.println(arr[2].val - arr[0].val);
                out.flush();
                int curr1 = s.nextInt();
            } else {
                arr[2].val = 3L * arr[2].val - arr[1].val - arr[0].val;
                out.println(2L * arr[2].val - arr[1].val - arr[0].val);
                out.flush();
                int currN = s.nextInt();
                if (currN == arr[0].ind) {
                    out.println(arr[2].val - arr[1].val);
                    out.flush();
                    int curr1 = s.nextInt();
                } else {
                    out.println(arr[2].val - arr[0].val);
                    out.flush();
                    int curr1 = s.nextInt();
                }
            }
        }

        private static class pair implements Comparable<FIntegerGame.pair> {
            long val;
            long ind;

            public pair(long val, int ind) {
                this.val = val;
                this.ind = ind;
            }

            public int compareTo(FIntegerGame.pair o) {
                return Long.compare(this.val, o.val);
            }

        }

    }

    static class FastReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private FastReader.SpaceCharFilter filter;

        public FastReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int nextInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public long nextLong() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            long res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }
}


#include <bits/stdc++.h>
using namespace std;

int a,b,c;
int ask(long long x)
{

    cout << x << "\n";
    int y;
    cin >> y;
    if (y==0) exit(0);
    if (y==1) a+=x;
    if (y==2) b+=x;
    if (y==3) c+=x;
}

void solve()
{

  cin >> a >> b >> c;
  cout << "FIRST\n";
  ask(a+b+c);
  vector <long long> z = {a,b,c};
  sort(z.begin(),z.end());
  long long x= z[1]-z[0];
  long long y=z[2]-z[1];
  ask(x+2*y);
  z = {a,b,c};
  sort(z.begin(),z.end());
  x=z[1] - z[0];
  y=z[2] - z[1];
  ask(x);
}

int main()
{

int t=1;
//cin >> t;
while (t--) solve();

}

/*
10
10 3
1 2 3 4 5 6 7 8 9 10
3 3 4
*/


#include <bits/stdc++.h>
using namespace std;

int a,b,c;
void ask(long long x)
{

    cout << x << "\n";
    int y;
    cin >> y;
    if (y==0) exit(0);
    if (y==1) a+=x;
    if (y==2) b+=x;
    if (y==3) c+=x;
}

void solve()
{

  cin >> a >> b >> c;
  cout << "FIRST\n";
  ask(a+b+c);
  vector <long long> z = {a,b,c};
  sort(z.begin(),z.end());
  long long x= z[1]-z[0];
  long long y=z[2]-z[1];
  ask(x+2*y);
  z = {a,b,c};
  sort(z.begin(),z.end());
  x=z[1] - z[0];
  y=z[2] - z[1];
  assert(x == y);
  ask(x);
  assert(false);
}

int main()
{

 cin >> a >> b >> c;
  cout << "First\n";
  ask(a+b+c);
  vector <long long> z = {a,b,c};
  sort(z.begin(),z.end());
  long long x=z[1]-z[0];
  long long y=z[2]-z[1];
  ask(x+2*y);
  z = {a,b,c};
  sort(z.begin(),z.end());
  x=z[1] - z[0];
  y=z[2] - z[1];
  //assert(x == y);
  ask(x);
  //assert(false);
  return 0;
}

/*
10
10 3
1 2 3 4 5 6 7 8 9 10
3 3 4
*/


#include <bits/stdc++.h>
using namespace std;

long long  a,b,c;
void ask(long long x)
{

    cout << x << "\n";
    int y;
    cin >> y;
    if (y<=0) exit(0);
    if (y==1) a+=x;
    if (y==2) b+=x;
    if (y==3) c+=x;
}

void solve()
{

  cin >> a >> b >> c;
  cout << "FIRST\n";
  ask(a+b+c);
  vector <long long> z = {a,b,c};
  sort(z.begin(),z.end());
  long long x= z[1]-z[0];
  long long y=z[2]-z[1];
  ask(x+2*y);
  z = {a,b,c};
  sort(z.begin(),z.end());
  x=z[1] - z[0];
  y=z[2] - z[1];
  assert(x == y);
  ask(x);
  assert(false);
}

int main()
{

 cin >> a >> b >> c;
  cout << "First\n";
  ask(a+b+c);
  vector <long long> z = {a,b,c};
  sort(z.begin(),z.end());
  long long x=z[1]-z[0];
  long long y=z[2]-z[1];
  ask(x+2*y);
  z = {a,b,c};
  sort(z.begin(),z.end());
  x=z[1] - z[0];
  y=z[2] - z[1];
  //assert(x == y);
  ask(x);
  //assert(false);
  return 0;
}

/*
10
10 3
1 2 3 4 5 6 7 8 9 10
3 3 4
*/


#include <bits/stdc++.h>
using namespace std;

void solve()
{

  vector <pair<int,int>> a(3);
  cin >> a[0].first >> a[1].first >> a[2].first;
    a[0].second=1; a[1].second=2; a[2].second=3;

  sort(a.begin(),a.end());

  int xx[3];
  xx[0] = a[0].second;
  xx[1] = a[1].second;
  xx[2] = a[2].second;

  //sort(a,a+3);
  cout << "First\n";
  cout << 2*a[2].first- a[1].first - a[0].first <<"\n";
  fflush(stdout);

  int x;
  cin >> x;
  x=xx[x-1];
  if (x==1)
    cout << a[2].first-a[1].first;
  if (x==2)
    cout << a[2].first-a[0].first;
  if (x==3) {
    a[2].first+=2*a[2].first - a[1].first - a[0].first;
    cout << 2*a[2].first - a[1].first - a[0].first;

  }
    cout << "\n"; fflush(stdout);

 cin >> x;
    if (x==0){return;}

sort(a.begin(),a.end());
    cout << a[1].first-a[0].first;
    fflush(stdout);

}

int main()
{

int t=1;
//cin >> t;
while (t--) solve();
}

/*
10
10 3
1 2 3 4 5 6 7 8 9 10
3 3 4
*/


#include <bits/stdc++.h>
using namespace std;

void solve()
{

  vector <pair<int,int>> a(3);
  cin >> a[0].first >> a[1].first >> a[2].first;
    a[0].second=0; a[1].second=1; a[2].second=2;

  sort(a.begin(),a.end());

  int xx[3];
  xx[0] = a[0].second;
  xx[1] = a[1].second;
  xx[2] = a[2].second;

  //sort(a,a+3);
  cout << "First\n";
  cout << 2*a[2].first- a[1].first - a[0].first <<"\n";
  fflush(stdout);

  int x;
  cin >> x;
  x=xx[x-1]+1;
  if (x==1)
    cout << a[2].first-a[1].first;
  if (x==2)
    cout << a[2].first-a[0].first;
  if (x==3) {
    a[2].first+=2*a[2].first - a[1].first - a[0].first;
    cout << 2*a[2].first - a[1].first - a[0].first;

  }
    cout << "\n"; fflush(stdout);

 cin >> x;
    if (x==0){return;}

 a[xx[x-1]].first+=2*a[2].first - a[1].first - a[0].first;

sort(a.begin(),a.end());
//cout << a[0].first << " " << a[1].first << " " << a[2].first << "\n";

    cout << a[1].first-a[0].first;
    fflush(stdout);

}

int main()
{

int t=1;
//cin >> t;
while (t--) solve();

}

/*
10
10 3
1 2 3 4 5 6 7 8 9 10
3 3 4
*/


#include <bits/stdc++.h>

using namespace std;

int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  long long a, b, c;
  cin >> a >> b >> c;
  cout << "First" << endl;
  auto Ask = [&](long long x) {
    cout << x << endl;
    int y;
    cin >> y;
    if (y <= 0) {
      exit(0);
    }
    if (y == 1) {
      a += x;
    }
    if (y == 2) {
      b += x;
    }
    if (y == 3) {
      c += x;
    }
  };
  Ask(a + b + c);
  vector<long long> z = {a, b, c};
  sort(z.begin(), z.end());
  long long x = z[1] - z[0];
  long long y = z[2] - z[1];
  Ask(x + 2 * y);
  z = {a, b, c};
  sort(z.begin(), z.end());
  x = z[1] - z[0];
  y = z[2] - z[1];
  assert(x == y);
  Ask(x);
  assert(false);
  return 0;
}


#include <bits/stdc++.h>
using namespace std;

int a,b,c;
void ask(long long x)
{

    cout << x << "\n";
    int y;
    cin >> y;
    if (y==0) exit(0);
    if (y==1) a+=x;
    if (y==2) b+=x;
    if (y==3) c+=x;
}

void solve()
{

  cin >> a >> b >> c;
  cout << "FIRST\n";
  ask(a+b+c);
  vector <long long> z = {a,b,c};
  sort(z.begin(),z.end());
  long long x= z[1]-z[0];
  long long y=z[2]-z[1];
  ask(x+2*y);
  z = {a,b,c};
  sort(z.begin(),z.end());
  x=z[1] - z[0];
  y=z[2] - z[1];
  assert(x == y);
  ask(x);
  assert(false);
}

int main()
{

 cin >> a >> b >> c;
  cout << "First\n";
  ask(a+b+c);
  vector <long long> z = {a,b,c};
  sort(z.begin(),z.end());
  long long x=z[1]-z[0];
  long long y=z[2]-z[1];
  ask(x+2*y);
  z = {a,b,c};
  sort(z.begin(),z.end());
  x=z[1] - z[0];
  y=z[2] - z[1];
  assert(x == y);
  ask(x);
  assert(false);
  return 0;
}

/*
10
10 3
1 2 3 4 5 6 7 8 9 10
3 3 4
*/


#include <bits/stdc++.h>
using namespace std;

int a,b,c;
void ask(long long x)
{

    cout << x << "\n";
    int y;
    cin >> y;
    if (y==0) exit(0);
    if (y==1) a+=x;
    if (y==2) b+=x;
    if (y==3) c+=x;
}

void solve()
{

  cin >> a >> b >> c;
  cout << "FIRST\n";
  ask(a+b+c);
  vector <long long> z = {a,b,c};
  sort(z.begin(),z.end());
  long long x= z[1]-z[0];
  long long y=z[2]-z[1];
  ask(x+2*y);
  z = {a,b,c};
  sort(z.begin(),z.end());
  x=z[1] - z[0];
  y=z[2] - z[1];
  assert(x == y);
  ask(x);
  assert(false);
}

int main()
{

 cin >> a >> b >> c;
  cout << "First\n";
  ask(a+b+c);
  vector <long long> z = {a,b,c};
  sort(z.begin(),z.end());
  long long x=z[1]-z[0];
  long long y=z[2]-z[1];
  ask(x+2*y);
  z = {a,b,c};
  sort(z.begin(),z.end());
  x=z[1] - z[0];
  y=z[2] - z[1];
  assert(x == y);
  ask(x);
  assert(false);
}

/*
10
10 3
1 2 3 4 5 6 7 8 9 10
3 3 4
*/


#include <bits/stdc++.h>
using namespace std;

int a,b,c;
void ask(long long x)
{

    cout << x << "\n";
    int y;
    cin >> y;
    if (y==0) exit(0);
    if (y==1) a+=x;
    if (y==2) b+=x;
    if (y==3) c+=x;
}

void solve()
{

  cin >> a >> b >> c;
  cout << "FIRST\n";
  ask(a+b+c);
  vector <long long> z = {a,b,c};
  sort(z.begin(),z.end());
  long long x= z[1]-z[0];
  long long y=z[2]-z[1];
  ask(x+2*y);
  z = {a,b,c};
  sort(z.begin(),z.end());
  x=z[1] - z[0];
  y=z[2] - z[1];
  assert(x == y);
  Ask(x);
  assert(false);
}

int main()
{

int t=1;
//cin >> t;
while (t--) solve();

}

/*
10
10 3
1 2 3 4 5 6 7 8 9 10
3 3 4
*/


#include <bits/stdc++.h>
using namespace std;

int a,b,c;
void ask(long long x)
{

    cout << x << "\n";
    int y;
    cin >> y;
    if (y==0) exit(0);
    if (y==1) a+=x;
    if (y==2) b+=x;
    if (y==3) c+=x;
}

void solve()
{

  cin >> a >> b >> c;
  cout << "FIRST\n";
  ask(a+b+c);
  vector <long long> z = {a,b,c};
  sort(z.begin(),z.end());
  long long x= z[1]-z[0];
  long long y=z[2]-z[1];
  ask(x+2*y);
  z = {a,b,c};
  sort(z.begin(),z.end());
  x=z[1] - z[0];
  y=z[2] - z[1];
  assert(x == y);
  ask(x);
  assert(false);
}

int main()
{

int t=1;
//cin >> t;
while (t--) solve();

}

/*
10
10 3
1 2 3 4 5 6 7 8 9 10
3 3 4
*/


//g++ -std=c++17 -Wall t.cpp -o test -g -O2
#include <bits/stdc++.h>
#define ff first
#define ss second
#define ll long long
#define ld long double
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define mt make_tuple
#define pii pair<int, int>
#define vi vector<int>
#define vl vector<ll>
#define vii vector<pii>
#define sws ios_base::sync_with_stdio(false);cin.tie(NULL)
// #define endl '\n'
#define teto(a, b) (a+b-1)/(b)

const int MAX = 2000000;
const ll MOD = 1e9+7;
const int INF = 0x3f3f3f3f;
const ll LLINF = 0x3f3f3f3f3f3f3f3f;
const ld EPS = 1e-7;
const ld PI = acosl(-1.0);

using namespace std;

// End - Template //

void choose(bool opt){
    if(opt)
        cout << "First" << endl;
    else
        cout << "Second" << endl;
    cout.flush();
}

ll read(){
    ll ans;
    cin >> ans;
    if(ans<=0)
        exit(0);
    return ans;
}

void print(ll x){
    cout << x << endl;
    cout.flush();
}

int main()
{sws;

    vi vet(3);
    cin >> vet[0] >> vet[1] >> vet[2];
    vii vet2 = {{vet[0], 1}, {vet[1], 2}, {vet[2], 3}};
    sort(vet2.begin(), vet2.end());
    map<int, int> m;
    for(int i=0;i<3;i++)
        m[vet2[i].ss]=i+1;

    choose(1);
    cout << "ok\n";
    print(2*vet[2]-vet[1]-vet[0]);
    ll ans = m[read()];
    if(ans==1)
        print(vet[2]-vet[1]);
    else if(ans==2)
        print(vet[2]-vet[0]);
    else{
        vet[2]=3*vet[2]-vet[1]-vet[0];
        print(2*vet[2]-vet[1]-vet[0]);
        ll ans = m[read()-1];
        if(ans==1)
            print(vet[2]-vet[1]);
        else
            print(vet[2]-vet[0]);
    }

    read();

    return 0;
}


//g++ -std=c++17 -Wall t.cpp -o test -g -O2
#include <bits/stdc++.h>
#define ff first
#define ss second
#define ll long long
#define ld long double
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define mt make_tuple
#define pii pair<int, int>
#define vi vector<int>
#define vl vector<ll>
#define vii vector<pii>
#define sws ios_base::sync_with_stdio(false);cin.tie(NULL)
// #define endl '\n'
#define teto(a, b) (a+b-1)/(b)

const int MAX = 2000000;
const ll MOD = 1e9+7;
const int INF = 0x3f3f3f3f;
const ll LLINF = 0x3f3f3f3f3f3f3f3f;
const ld EPS = 1e-7;
const ld PI = acosl(-1.0);

using namespace std;

// End - Template //

void choose(bool opt){
    if(opt)
        cout << "First" << endl;
    else
        cout << "Second" << endl;
    cout.flush();
}

int read(){
    int ans;
    cin >> ans;
    if(ans<=0)
        exit(0);
    return ans;
}

void print(ll x){
    cout << x << endl;
    cout.flush();
}

int main()
{sws;

    vector<ll> vet(3);
    cin >> vet[0] >> vet[1] >> vet[2];
    vector<pair<ll,ll> > vet2 = {{vet[0], 1}, {vet[1], 2}, {vet[2], 3}};
    sort(vet2.begin(), vet2.end());
    sort(vet.begin(), vet.end());

    map<int, int> m;
    for(int i=0;i<3;i++)
        m[vet2[i].ss]=i+1;

    choose(1);
    print(2*vet[2]-vet[1]-vet[0]);
    int ans = m[read()];
    if(ans==1)
        print(vet[2]-vet[1]);
    else if(ans==2)
        print(vet[2]-vet[0]);
    else{
        vet[2]=3*vet[2]-vet[1]-vet[0];
        print(2*vet[2]-vet[1]-vet[0]);
        int ans = m[read()];
        if(ans==1)
            print(vet[2]-vet[1]);
        else
            print(vet[2]-vet[0]);
    }

    read();

    return 0;
}


//g++ -std=c++17 -Wall t.cpp -o test -g -O2
#include <bits/stdc++.h>
#define ff first
#define ss second
#define ll long long
#define ld long double
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define mt make_tuple
#define pii pair<int, int>
#define vi vector<int>
#define vl vector<ll>
#define vii vector<pii>
#define sws ios_base::sync_with_stdio(false);cin.tie(NULL)
// #define endl '\n'
#define teto(a, b) (a+b-1)/(b)

const int MAX = 2000000;
const ll MOD = 1e9+7;
const int INF = 0x3f3f3f3f;
const ll LLINF = 0x3f3f3f3f3f3f3f3f;
const ld EPS = 1e-7;
const ld PI = acosl(-1.0);

using namespace std;

// End - Template //

void choose(bool opt){
    if(opt)
        cout << "First" << endl;
    else
        cout << "Second" << endl;
    cout.flush();
}

ll read(){
    ll ans;
    cin >> ans;
    if(ans<=0)
        exit(0);
    return ans;
}

void print(ll x){
    cout << x << endl;
    cout.flush();
}

int main()
{sws;

    vi vet(3);
    cin >> vet[0] >> vet[1] >> vet[2];
    vii vet2 = {{vet[0], 1}, {vet[1], 2}, {vet[2], 3}};
    sort(vet2.begin(), vet2.end());
    map<int, int> m;
    for(int i=0;i<3;i++)
        m[vet2[i].ss]=i+1;

    choose(1);
    print(2*vet[2]-vet[1]-vet[0]);
    ll ans = m[read()];
    if(ans==1)
        print(vet[2]-vet[1]);
    else if(ans==2)
        print(vet[2]-vet[0]);
    else{
        vet[2]=3*vet[2]-vet[1]-vet[0];
        print(2*vet[2]-vet[1]-vet[0]);
        ll ans = m[read()-1];
        if(ans==1)
            print(vet[2]-vet[1]);
        else
            print(vet[2]-vet[0]);
    }

    read();

    return 0;
}