# include <bits/stdc++.h>

using namespace std;

// struct comp
// {
//     bool operator() (const pair<int,int> &a, const pair<int,int> &b) const
//     {
//         if(a.first!= b.first)   return a.first<b.first;
//         else    return a.second<b.second;
//     }
// };
// vector<int> ans;
// vector<int> pseudo;
// vector<int> adj[100001];
// // int visited[100001] = {0};
// int color[100001] = {0};
// int flag =0;
// int imp = 0;

// bool DFSutil(int a)
// {
//     color[a] = 1;

//     for(int i=0;i<adj[a].size();i++)
//     {
//         int t = adj[a][i];
//         // cout << '+' << t;
//         if(color[t]==0)
//         {
//             if(DFSutil(t))
//             {
//                 pseudo.push_back(t);
//                 if(t==imp)
//                     ans = pseudo;
//                 return true;
//             }

//         }
//         if(color[t]==1)
//         {
//             flag=1;
//             ans.push_back(t);
//             imp = t;
//             return true;
//         }
//     }

//     color[a] = 2;
//     return false;
// }

// int p[10000001];
// // vector<int> prim;

// void prime()
// {
//     for(int i = 2;i<=sqrt(10000001);i++)
//     {
//         if(p[i]!=i)
//             continue;
//         else
//         {
//             for(int j=i*i;j<10000001;j=j+i)
//             {
//                 if(p[j]==j)
//                     p[j] = i;
//             }
//         }
//     }
// }

// void addedge(int a, int b)
// {
//     adj[a].push_back(b);
//     adj[b].push_back(a);
// }

int main()
{
    ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);

    // int test;
    // cin >> test;

    // while(test--)
    {
        int a[3];
        cin >> a[0] >> a[1] >> a[2];

        cout <<"\nFirst\n" << flush;

        int x = max(a[0],a[1]);
        x = max(x,a[2]);

        int r = x-a[0]+x-a[1]+x-a[2];

        cout << r <<'\n';
        cout.flush();

        int inp;
        cin >> inp;

        if(a[inp-1]!=x)
        {
            int ans = 0;
            for(int i=0;i<3;i++)
            {
                if(i+1==inp)
                    continue;
                ans += x-a[i];
            }
            cout << ans << '\n' << flush;
        }
        else
        {
            a[inp-1] += r;

            r = x-a[0]+x-a[1]+x-a[2];

            cout << r <<'\n';
            cout.flush();

            inp;
            cin >> inp;

            int ans = 0;
            for(int i=0;i<3;i++)
            {
                if(i+1==inp)
                    continue;
                ans += x-a[i];
            }
            cout << ans << '\n' << flush;
        }

        // cout <<'\n';
  }

  return 0;
}


# include <bits/stdc++.h>

using namespace std;

// struct comp
// {
//     bool operator() (const pair<int,int> &a, const pair<int,int> &b) const
//     {
//         if(a.first!= b.first)   return a.first<b.first;
//         else    return a.second<b.second;
//     }
// };
// vector<int> ans;
// vector<int> pseudo;
// vector<int> adj[100001];
// // int visited[100001] = {0};
// int color[100001] = {0};
// int flag =0;
// int imp = 0;

// bool DFSutil(int a)
// {
//     color[a] = 1;

//     for(int i=0;i<adj[a].size();i++)
//     {
//         int t = adj[a][i];
//         // cout << '+' << t;
//         if(color[t]==0)
//         {
//             if(DFSutil(t))
//             {
//                 pseudo.push_back(t);
//                 if(t==imp)
//                     ans = pseudo;
//                 return true;
//             }

//         }
//         if(color[t]==1)
//         {
//             flag=1;
//             ans.push_back(t);
//             imp = t;
//             return true;
//         }
//     }

//     color[a] = 2;
//     return false;
// }

// int p[10000001];
// // vector<int> prim;

// void prime()
// {
//     for(int i = 2;i<=sqrt(10000001);i++)
//     {
//         if(p[i]!=i)
//             continue;
//         else
//         {
//             for(int j=i*i;j<10000001;j=j+i)
//             {
//                 if(p[j]==j)
//                     p[j] = i;
//             }
//         }
//     }
// }

// void addedge(int a, int b)
// {
//     adj[a].push_back(b);
//     adj[b].push_back(a);
// }

int main()
{
    ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);

    // int test;
    // cin >> test;

    // while(test--)
    {
        int a[3];
        cin >> a[0] >> a[1] >> a[2];

        cout <<"First\n";

        int x = max(a[0],a[1]);
        x = max(x,a[2]);

        int r = x-a[0]+x-a[1]+x-a[2];

        cout << r <<'\n';
        cout.flush();

        int inp;
        cin >> inp;

        if(a[inp-1]!=x)
        {
            int ans = 0;
            for(int i=0;i<3;i++)
            {
                if(i+1==inp)
                    continue;
                ans += x-a[i];
            }
            cout << ans << '\n' << flush;
        }
        else
        {
            a[inp-1] += r;

            r = x-a[0]+x-a[1]+x-a[2];

            cout << r <<'\n';
            cout.flush();

            inp;
            cin >> inp;

            int ans = 0;
            for(int i=0;i<3;i++)
            {
                if(i+1==inp)
                    continue;
                ans += x-a[i];
            }
            cout << ans << '\n' << flush;
        }

        // cout <<'\n';
  }

  return 0;
}


# include <bits/stdc++.h>

using namespace std;

// struct comp
// {
//     bool operator() (const pair<int,int> &a, const pair<int,int> &b) const
//     {
//         if(a.first!= b.first)   return a.first<b.first;
//         else    return a.second<b.second;
//     }
// };
// vector<int> ans;
// vector<int> pseudo;
// vector<int> adj[100001];
// // int visited[100001] = {0};
// int color[100001] = {0};
// int flag =0;
// int imp = 0;

// bool DFSutil(int a)
// {
//     color[a] = 1;

//     for(int i=0;i<adj[a].size();i++)
//     {
//         int t = adj[a][i];
//         // cout << '+' << t;
//         if(color[t]==0)
//         {
//             if(DFSutil(t))
//             {
//                 pseudo.push_back(t);
//                 if(t==imp)
//                     ans = pseudo;
//                 return true;
//             }

//         }
//         if(color[t]==1)
//         {
//             flag=1;
//             ans.push_back(t);
//             imp = t;
//             return true;
//         }
//     }

//     color[a] = 2;
//     return false;
// }

// int p[10000001];
// // vector<int> prim;

// void prime()
// {
//     for(int i = 2;i<=sqrt(10000001);i++)
//     {
//         if(p[i]!=i)
//             continue;
//         else
//         {
//             for(int j=i*i;j<10000001;j=j+i)
//             {
//                 if(p[j]==j)
//                     p[j] = i;
//             }
//         }
//     }
// }

// void addedge(int a, int b)
// {
//     adj[a].push_back(b);
//     adj[b].push_back(a);
// }

int main()
{
    ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);

    // int test;
    // cin >> test;

    // while(test--)
    {
        int a[3];
        cin >> a[0] >> a[1] >> a[2];

        cout <<"First\n" << flush;

        int x = max(a[0],a[1]);
        x = max(x,a[2]);

        int r = x-a[0]+x-a[1]+x-a[2];

        cout << r <<'\n';
        cout.flush();

        int inp;
        cin >> inp;

        if(a[inp-1]!=x)
        {
            int ans = 0;
            for(int i=0;i<3;i++)
            {
                if(i+1==inp)
                    continue;
                ans += x-a[i];
            }
            cout << ans << '\n' << flush;
        }
        else
        {
            a[inp-1] += r;

            r = x-a[0]+x-a[1]+x-a[2];

            cout << r <<'\n';
            cout.flush();

            inp;
            cin >> inp;

            int ans = 0;
            for(int i=0;i<3;i++)
            {
                if(i+1==inp)
                    continue;
                ans += x-a[i];
            }
            cout << ans << '\n' << flush;
        }

        // cout <<'\n';
  }

  return 0;
}


# include <bits/stdc++.h>

using namespace std;

// struct comp
// {
//     bool operator() (const pair<int,int> &a, const pair<int,int> &b) const
//     {
//         if(a.first!= b.first)   return a.first<b.first;
//         else    return a.second<b.second;
//     }
// };
// vector<int> ans;
// vector<int> pseudo;
// vector<int> adj[100001];
// // int visited[100001] = {0};
// int color[100001] = {0};
// int flag =0;
// int imp = 0;

// bool DFSutil(int a)
// {
//     color[a] = 1;

//     for(int i=0;i<adj[a].size();i++)
//     {
//         int t = adj[a][i];
//         // cout << '+' << t;
//         if(color[t]==0)
//         {
//             if(DFSutil(t))
//             {
//                 pseudo.push_back(t);
//                 if(t==imp)
//                     ans = pseudo;
//                 return true;
//             }

//         }
//         if(color[t]==1)
//         {
//             flag=1;
//             ans.push_back(t);
//             imp = t;
//             return true;
//         }
//     }

//     color[a] = 2;
//     return false;
// }

// int p[10000001];
// // vector<int> prim;

// void prime()
// {
//     for(int i = 2;i<=sqrt(10000001);i++)
//     {
//         if(p[i]!=i)
//             continue;
//         else
//         {
//             for(int j=i*i;j<10000001;j=j+i)
//             {
//                 if(p[j]==j)
//                     p[j] = i;
//             }
//         }
//     }
// }

// void addedge(int a, int b)
// {
//     adj[a].push_back(b);
//     adj[b].push_back(a);
// }

int main()
{
    ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);

    // int test;
    // cin >> test;

    // while(test--)
    {
        int a[3];
        cin >> a[0] >> a[1] >> a[2];

        int x = max(a[0],a[1]);
        x = max(x,a[2]);

        cout <<"First\n" << flush;

        int r = x-a[0]+x-a[1]+x-a[2];

        cout << r <<'\n';
        cout.flush();

        int inp;
        cin >> inp;

        if(a[inp-1]!=x)
        {
            int ans = 0;
            for(int i=0;i<3;i++)
            {
                if(i+1==inp)
                    continue;
                ans += x-a[i];
            }
            cout << ans << '\n' << flush;
        }
        else
        {
            a[inp-1] += r;

            r = x-a[0]+x-a[1]+x-a[2];

            cout << r <<'\n';
            cout.flush();

            inp;
            cin >> inp;

            int ans = 0;
            for(int i=0;i<3;i++)
            {
                if(i+1==inp)
                    continue;
                ans += x-a[i];
            }
            cout << ans << '\n' << flush;
        }

        // cout <<'\n';
  }

  return 0;
}


# include <bits/stdc++.h>

using namespace std;

// struct comp
// {
//     bool operator() (const pair<int,int> &a, const pair<int,int> &b) const
//     {
//         if(a.first!= b.first)   return a.first<b.first;
//         else    return a.second<b.second;
//     }
// };
// vector<int> ans;
// vector<int> pseudo;
// vector<int> adj[100001];
// // int visited[100001] = {0};
// int color[100001] = {0};
// int flag =0;
// int imp = 0;

// bool DFSutil(int a)
// {
//     color[a] = 1;

//     for(int i=0;i<adj[a].size();i++)
//     {
//         int t = adj[a][i];
//         // cout << '+' << t;
//         if(color[t]==0)
//         {
//             if(DFSutil(t))
//             {
//                 pseudo.push_back(t);
//                 if(t==imp)
//                     ans = pseudo;
//                 return true;
//             }

//         }
//         if(color[t]==1)
//         {
//             flag=1;
//             ans.push_back(t);
//             imp = t;
//             return true;
//         }
//     }

//     color[a] = 2;
//     return false;
// }

// int p[10000001];
// // vector<int> prim;

// void prime()
// {
//     for(int i = 2;i<=sqrt(10000001);i++)
//     {
//         if(p[i]!=i)
//             continue;
//         else
//         {
//             for(int j=i*i;j<10000001;j=j+i)
//             {
//                 if(p[j]==j)
//                     p[j] = i;
//             }
//         }
//     }
// }

// void addedge(int a, int b)
// {
//     adj[a].push_back(b);
//     adj[b].push_back(a);
// }

int main()
{
    ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);

    // int test;
    // cin >> test;

    // while(test--)
    {
        int a[3];
        cin >> a[0] >> a[1] >> a[2];

        cout <<"First\n" << flush;

        int x = max(a[0],a[1]);
        x = max(x,a[2]);

        int r = x-a[0]+x-a[1]+x-a[2];

        cout << r <<'\n';
        cout.flush();

        int inp;
        cin >> inp;

        if(a[inp-1]!=x)
        {
            int ans = 0;
            for(int i=0;i<3;i++)
            {
                if(i+1==inp)
                    continue;
                ans += x-a[i];
            }
            cout << ans << '\n' << flush;
        }
        else
        {
            a[inp-1] += r;
            x+=r;

            r = x-a[0]+x-a[1]+x-a[2];

            cout << r <<'\n';
            cout.flush();

            inp;
            cin >> inp;

            int ans = 0;
            for(int i=0;i<3;i++)
            {
                if(i+1==inp)
                    continue;
                ans += x-a[i];
            }
            cout << ans << '\n' << flush;
        }

        // cout <<'\n';
  }

  return 0;
}


# include <bits/stdc++.h>

using namespace std;

// struct comp
// {
//     bool operator() (const pair<int,int> &a, const pair<int,int> &b) const
//     {
//         if(a.first!= b.first)   return a.first<b.first;
//         else    return a.second<b.second;
//     }
// };
// vector<int> ans;
// vector<int> pseudo;
// vector<int> adj[100001];
// // int visited[100001] = {0};
// int color[100001] = {0};
// int flag =0;
// int imp = 0;

// bool DFSutil(int a)
// {
//     color[a] = 1;

//     for(int i=0;i<adj[a].size();i++)
//     {
//         int t = adj[a][i];
//         // cout << '+' << t;
//         if(color[t]==0)
//         {
//             if(DFSutil(t))
//             {
//                 pseudo.push_back(t);
//                 if(t==imp)
//                     ans = pseudo;
//                 return true;
//             }

//         }
//         if(color[t]==1)
//         {
//             flag=1;
//             ans.push_back(t);
//             imp = t;
//             return true;
//         }
//     }

//     color[a] = 2;
//     return false;
// }

// int p[10000001];
// // vector<int> prim;

// void prime()
// {
//     for(int i = 2;i<=sqrt(10000001);i++)
//     {
//         if(p[i]!=i)
//             continue;
//         else
//         {
//             for(int j=i*i;j<10000001;j=j+i)
//             {
//                 if(p[j]==j)
//                     p[j] = i;
//             }
//         }
//     }
// }

// void addedge(int a, int b)
// {
//     adj[a].push_back(b);
//     adj[b].push_back(a);
// }

int main()
{
    ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);

    // int test;
    // cin >> test;

    // while(test--)
    {
        long long int a[3];
        cin >> a[0] >> a[1] >> a[2];

        cout <<"First\n" << flush;

        long long int x = max(a[0],a[1]);
        x = max(x,a[2]);

        long long int r = x-a[0]+x-a[1]+x-a[2];

        cout << r <<'\n';
        cout.flush();

        int inp;
        cin >> inp;

        if(a[inp-1]!=x)
        {
            long long int ans = 0;
            for(int i=0;i<3;i++)
            {
                if(i+1==inp)
                    continue;
                ans += x-a[i];
            }
            cout << ans << '\n' << flush;
        }
        else
        {
            a[inp-1] += r;
            x+=r;

            r = x-a[0]+x-a[1]+x-a[2];

            cout << r <<'\n';
            cout.flush();

            inp;
            cin >> inp;

            long long int ans = 0;
            for(int i=0;i<3;i++)
            {
                if(i+1==inp)
                    continue;
                ans += x-a[i];
            }
            cout << ans << '\n' << flush;
        }

        // cout <<'\n';
  }

  return 0;
}


# include <bits/stdc++.h>

using namespace std;

// struct comp
// {
//     bool operator() (const pair<int,int> &a, const pair<int,int> &b) const
//     {
//         if(a.first!= b.first)   return a.first<b.first;
//         else    return a.second<b.second;
//     }
// };
// vector<int> ans;
// vector<int> pseudo;
// vector<int> adj[100001];
// // int visited[100001] = {0};
// int color[100001] = {0};
// int flag =0;
// int imp = 0;

// bool DFSutil(int a)
// {
//     color[a] = 1;

//     for(int i=0;i<adj[a].size();i++)
//     {
//         int t = adj[a][i];
//         // cout << '+' << t;
//         if(color[t]==0)
//         {
//             if(DFSutil(t))
//             {
//                 pseudo.push_back(t);
//                 if(t==imp)
//                     ans = pseudo;
//                 return true;
//             }

//         }
//         if(color[t]==1)
//         {
//             flag=1;
//             ans.push_back(t);
//             imp = t;
//             return true;
//         }
//     }

//     color[a] = 2;
//     return false;
// }

// int p[10000001];
// // vector<int> prim;

// void prime()
// {
//     for(int i = 2;i<=sqrt(10000001);i++)
//     {
//         if(p[i]!=i)
//             continue;
//         else
//         {
//             for(int j=i*i;j<10000001;j=j+i)
//             {
//                 if(p[j]==j)
//                     p[j] = i;
//             }
//         }
//     }
// }

// void addedge(int a, int b)
// {
//     adj[a].push_back(b);
//     adj[b].push_back(a);
// }

int main()
{
    ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);

    // int test;
    // cin >> test;

    // while(test--)
    {
        long long int a[3];
        cin >> a[0] >> a[1] >> a[2];

        cout <<"First\n" << flush;

        long long int x = max(a[0],a[1]);
        x = max(x,a[2]);

        long long int r = x-a[0]+x-a[1]+x-a[2];

        cout << r <<'\n';
        cout.flush();

        int inp;
        cin >> inp;

        if(a[inp-1]!=x)
        {
            long long int ans = 0;
            for(int i=0;i<3;i++)
            {
                if(i+1==inp)
                    continue;
                ans += x-a[i];
            }
            cout << ans << '\n' << flush;
        }
        else
        {
            a[inp-1] += r;

            r = x-a[0]+x-a[1]+x-a[2];

            cout << r <<'\n';
            cout.flush();

            inp;
            cin >> inp;

            long long int ans = 0;
            for(int i=0;i<3;i++)
            {
                if(i+1==inp)
                    continue;
                ans += x-a[i];
            }
            cout << ans << '\n' << flush;
        }

        // cout <<'\n';
  }

  return 0;
}


# include <bits/stdc++.h>

using namespace std;

// struct comp
// {
//     bool operator() (const pair<int,int> &a, const pair<int,int> &b) const
//     {
//         if(a.first!= b.first)   return a.first<b.first;
//         else    return a.second<b.second;
//     }
// };
// vector<int> ans;
// vector<int> pseudo;
// vector<int> adj[100001];
// // int visited[100001] = {0};
// int color[100001] = {0};
// int flag =0;
// int imp = 0;

// bool DFSutil(int a)
// {
//     color[a] = 1;

//     for(int i=0;i<adj[a].size();i++)
//     {
//         int t = adj[a][i];
//         // cout << '+' << t;
//         if(color[t]==0)
//         {
//             if(DFSutil(t))
//             {
//                 pseudo.push_back(t);
//                 if(t==imp)
//                     ans = pseudo;
//                 return true;
//             }

//         }
//         if(color[t]==1)
//         {
//             flag=1;
//             ans.push_back(t);
//             imp = t;
//             return true;
//         }
//     }

//     color[a] = 2;
//     return false;
// }

// int p[10000001];
// // vector<int> prim;

// void prime()
// {
//     for(int i = 2;i<=sqrt(10000001);i++)
//     {
//         if(p[i]!=i)
//             continue;
//         else
//         {
//             for(int j=i*i;j<10000001;j=j+i)
//             {
//                 if(p[j]==j)
//                     p[j] = i;
//             }
//         }
//     }
// }

// void addedge(int a, int b)
// {
//     adj[a].push_back(b);
//     adj[b].push_back(a);
// }

int main()
{
    ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);

    // int test;
    // cin >> test;

    // while(test--)
    {
        int a[3];
        cin >> a[0] >> a[1] >> a[2

        cout <<"\nFirst\n" << flush;

        int x = max(a[0],a[1]);
        x = max(x,a[2]);

        int r = x-a[0]+x-a[1]+x-a[2];

        cout << r <<'\n';
        cout.flush();

        int inp;
        cin >> inp;

        if(a[inp-1]!=x)
        {
            int ans = 0;
            for(int i=0;i<3;i++)
            {
                if(i+1==inp)
                    continue;
                ans += x-a[i];
            }
            cout << ans << '\n' << flush;
        }
        else
        {
            a[inp-1] += r;

            r = x-a[0]+x-a[1]+x-a[2];

            cout << r <<'\n';
            cout.flush();

            inp;
            cin >> inp;

            int ans = 0;
            for(int i=0;i<3;i++)
            {
                if(i+1==inp)
                    continue;
                ans += x-a[i];
            }
            cout << ans << '\n' << flush;
        }

        // cout <<'\n';
  }

  return 0;
}


// Codeforces contest template
#include <bits/stdc++.h>
using namespace std;
#define File(s) freopen(s".in", "r", stdin), freopen(s".out", "w", stdout)

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define mkp make_pair
#define pb push_back
#define SP putchar(' ')
#define EL putchar('\n')

mt19937 rnd(chrono :: steady_clock :: now().time_since_epoch().count());
mt19937_64 rnd64(chrono :: steady_clock :: now().time_since_epoch().count()) ;

template<class T> inline void gi(T &x){
	char ch; x = 0;int f = 1;
	while(isspace(ch = getchar()));
	if(ch == '-') ch = getchar(), f = -1;
	do x = x * 10 + ch - '0'; while(isdigit(ch = getchar()));
	x *= f;
}
template<class T> inline void wi(T x){
	static char stk[128]; int top = 0;
	if(x == 0) putchar('0');
	if(x < 0) putchar('-'), x = -x;
	while(x) stk[++top] = x % 10, x /= 10;
	while(top) putchar(stk[top--] + '0');
}
template<class T> void upmax(T &x, T y){x = x>y ? x : y;}
template<class T> void upmin(T &x, T y){x = x<y ? x : y;}

struct Val{
  ll v;
  int id;
  bool operator<(Val rhs) {return v < rhs.v;}
};

int main(){
  setbuf(stdout, NULL);
  Val a[3];
  for(int i=0; i<3; i++)
    scanf("%lld", &a[i].v), a[i].id = i + 1;
  puts("First");
  puts("1000000000");
  int id = 0;
  scanf("%d", &id);
  a[id - 1].v += 1000000000;
  sort(a, a + 3);
  printf("%lld\n", 1LL * 2 * a[2].v - a[0].v - a[1].v);
  scanf("%d", &id);
  if(id == 0) return 0;
  ll val = 1LL * 2 * a[2].v - a[0].v - a[1].v;
  for(int i=0; i<3; i++)
    if(a[i].id == id)
      a[i].v += val;
  sort(a, a + 3);
  printf("%lld\n", a[1].v - a[0].v);
  while(true);
	return 0;
}


// Codeforces contest template
#include <bits/stdc++.h>
using namespace std;
#define File(s) freopen(s".in", "r", stdin), freopen(s".out", "w", stdout)

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define mkp make_pair
#define pb push_back
#define SP putchar(' ')
#define EL putchar('\n')

mt19937 rnd(chrono :: steady_clock :: now().time_since_epoch().count());
mt19937_64 rnd64(chrono :: steady_clock :: now().time_since_epoch().count()) ;

template<class T> inline void gi(T &x){
	char ch; x = 0;int f = 1;
	while(isspace(ch = getchar()));
	if(ch == '-') ch = getchar(), f = -1;
	do x = x * 10 + ch - '0'; while(isdigit(ch = getchar()));
	x *= f;
}
template<class T> inline void wi(T x){
	static char stk[128]; int top = 0;
	if(x == 0) putchar('0');
	if(x < 0) putchar('-'), x = -x;
	while(x) stk[++top] = x % 10, x /= 10;
	while(top) putchar(stk[top--] + '0');
}
template<class T> void upmax(T &x, T y){x = x>y ? x : y;}
template<class T> void upmin(T &x, T y){x = x<y ? x : y;}

struct Val{
  ll v;
  int id;
  bool operator<(Val rhs) {return v < rhs.v;}
};

int main(){
  setbuf(stdout, NULL);
  Val a[3];
  for(int i=0; i<3; i++)
    scanf("%lld", &a[i].v), a[i].id = i + 1;
  puts("First");
  puts("1000000000");
  int id = 0;
  scanf("%d", &id);
  a[id - 1].v += 1000000000;
  sort(a, a + 3);
  printf("%lld\n", 1LL * 2 * a[2].v - a[0].v - a[1].v);
  scanf("%d", &id);
  if(id == 0) return 0;
  ll val = 1LL * 2 * a[2].v - a[0].v - a[1].v;
  for(int i=0; i<3; i++)
    if(a[i].id == id)
      a[i].v += val;
  sort(a, a + 3);
  printf("%lld\n", a[1].v - a[0].v);
	return 0;
}


// Codeforces contest template
#include <bits/stdc++.h>
using namespace std;
#define File(s) freopen(s".in", "r", stdin), freopen(s".out", "w", stdout)

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define mkp make_pair
#define pb push_back
#define SP putchar(' ')
#define EL putchar('\n')

mt19937 rnd(chrono :: steady_clock :: now().time_since_epoch().count());
mt19937_64 rnd64(chrono :: steady_clock :: now().time_since_epoch().count()) ;

template<class T> inline void gi(T &x){
	char ch; x = 0;int f = 1;
	while(isspace(ch = getchar()));
	if(ch == '-') ch = getchar(), f = -1;
	do x = x * 10 + ch - '0'; while(isdigit(ch = getchar()));
	x *= f;
}
template<class T> inline void wi(T x){
	static char stk[128]; int top = 0;
	if(x == 0) putchar('0');
	if(x < 0) putchar('-'), x = -x;
	while(x) stk[++top] = x % 10, x /= 10;
	while(top) putchar(stk[top--] + '0');
}
template<class T> void upmax(T &x, T y){x = x>y ? x : y;}
template<class T> void upmin(T &x, T y){x = x<y ? x : y;}

struct Val{
  ll v;
  int id;
  bool operator<(Val rhs) {return v < rhs.v;}
};

int main(){
  setbuf(stdout, NULL);
  Val a[3];
  scanf("%lld%lld%lld", &a[0].v, &a[1].v, &a[2].v);
  puts("First");
  puts("1000000000");
  int id = 0;
  scanf("%d", &id);
  a[id].v += 1000000000;
  sort(a, a + 3);
  printf("%lld\n", 1LL * 2 * a[2].v - a[0].v - a[1].v);
  scanf("%d", &id);
  if(id == 0) return 0;
  for(int i=0; i<3; i++)
    if(a[i].id == id)
      a[id].v += 1LL * 2 * a[2].v - a[0].v - a[1].v;
  sort(a, a + 3);
  printf("%lld\n", a[1].v - a[0].v);
	return 0;
}


// Codeforces contest template
#include <bits/stdc++.h>
using namespace std;
#define File(s) freopen(s".in", "r", stdin), freopen(s".out", "w", stdout)

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define mkp make_pair
#define pb push_back
#define SP putchar(' ')
#define EL putchar('\n')

mt19937 rnd(chrono :: steady_clock :: now().time_since_epoch().count());
mt19937_64 rnd64(chrono :: steady_clock :: now().time_since_epoch().count()) ;

template<class T> inline void gi(T &x){
	char ch; x = 0;int f = 1;
	while(isspace(ch = getchar()));
	if(ch == '-') ch = getchar(), f = -1;
	do x = x * 10 + ch - '0'; while(isdigit(ch = getchar()));
	x *= f;
}
template<class T> inline void wi(T x){
	static char stk[128]; int top = 0;
	if(x == 0) putchar('0');
	if(x < 0) putchar('-'), x = -x;
	while(x) stk[++top] = x % 10, x /= 10;
	while(top) putchar(stk[top--] + '0');
}
template<class T> void upmax(T &x, T y){x = x>y ? x : y;}
template<class T> void upmin(T &x, T y){x = x<y ? x : y;}

struct Val{
  ll v;
  int id;
  bool operator<(Val rhs) {return v < rhs.v;}
};

int main(){
  setbuf(stdout, NULL);
  Val a[3];
  for(int i=0; i<3; i++)
    scanf("%lld", &a[i].v), a[i].id = i + 1;
  puts("First");
  puts("1000000000");
  int id = 0;
  scanf("%d", &id);
  a[id].v += 1000000000;
  sort(a, a + 3);
  printf("%lld\n", 1LL * 2 * a[2].v - a[0].v - a[1].v);
  scanf("%d", &id);
  if(id == 0) return 0;
  for(int i=0; i<3; i++)
    if(a[i].id == id)
      a[id].v += 1LL * 2 * a[2].v - a[0].v - a[1].v;
  sort(a, a + 3);
  printf("%lld\n", a[1].v - a[0].v);
	return 0;
}


// Codeforces contest template
#include <bits/stdc++.h>
using namespace std;
#define File(s) freopen(s".in", "r", stdin), freopen(s".out", "w", stdout)

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define mkp make_pair
#define pb push_back
#define SP putchar(' ')
#define EL putchar('\n')

mt19937 rnd(chrono :: steady_clock :: now().time_since_epoch().count());
mt19937_64 rnd64(chrono :: steady_clock :: now().time_since_epoch().count()) ;

template<class T> inline void gi(T &x){
	char ch; x = 0;int f = 1;
	while(isspace(ch = getchar()));
	if(ch == '-') ch = getchar(), f = -1;
	do x = x * 10 + ch - '0'; while(isdigit(ch = getchar()));
	x *= f;
}
template<class T> inline void wi(T x){
	static char stk[128]; int top = 0;
	if(x == 0) putchar('0');
	if(x < 0) putchar('-'), x = -x;
	while(x) stk[++top] = x % 10, x /= 10;
	while(top) putchar(stk[top--] + '0');
}
template<class T> void upmax(T &x, T y){x = x>y ? x : y;}
template<class T> void upmin(T &x, T y){x = x<y ? x : y;}

struct Val{
  ll v;
  int id;
  bool operator<(Val r) {return v < r.v;}
}v[3];

bool judge(int id){
  if(v[0].v == v[1].v || v[0].v == v[2].v || v[1].v == v[2].v) return false;
  int s[2], sc = 0;
  for(int i=0; i<3; i++){
    if(i == id) continue;
    s[sc++] = v[id].v - v[i].v;
  }
  if(s[0] > 0 && s[1] > 0 && (s[0] == 2 * s[1] || s[1] == 2 * s[0])) return false;
  return true;
}

int main(){
	// File("f");
  for(int i=0; i<3; i++) gi(v[i].v), v[i].id = i + 1;
  sort(v + 1, v + 3);
  puts("Second"); fflush(stdout);
  int last = -1;
  while(true){
    sort(v, v + 3);
    ll x; gi(x);
    if(x == -1) exit(0);
    bool flag = false;
    for(int i=2; i>=0; i--){
      if(last == v[i].id) continue;
      v[i].v += x;
      if(!judge(i)) v[i].v -= x;
      else{
        printf("%d\n", v[i].id); fflush(stdout);
        last = v[i].id;
        flag = true;
        break;
      }
    }
    if(!flag) exit(0);
  }
	return 0;
}


// Codeforces contest template
#include <bits/stdc++.h>
using namespace std;
#define File(s) freopen(s".in", "r", stdin), freopen(s".out", "w", stdout)

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define mkp make_pair
#define pb push_back
#define SP putchar(' ')
#define EL putchar('\n')

mt19937 rnd(chrono :: steady_clock :: now().time_since_epoch().count());
mt19937_64 rnd64(chrono :: steady_clock :: now().time_since_epoch().count()) ;

template<class T> inline void gi(T &x){
	char ch; x = 0;int f = 1;
	while(isspace(ch = getchar()));
	if(ch == '-') ch = getchar(), f = -1;
	do x = x * 10 + ch - '0'; while(isdigit(ch = getchar()));
	x *= f;
}
template<class T> inline void wi(T x){
	static char stk[128]; int top = 0;
	if(x == 0) putchar('0');
	if(x < 0) putchar('-'), x = -x;
	while(x) stk[++top] = x % 10, x /= 10;
	while(top) putchar(stk[top--] + '0');
}
template<class T> void upmax(T &x, T y){x = x>y ? x : y;}
template<class T> void upmin(T &x, T y){x = x<y ? x : y;}

struct Val{
  ll v;
  int id;
  bool operator<(Val rhs) {return v < rhs.v;}
};

int main(){
  setbuf(stdout, NULL);
  Val a[3];
  for(int i=0; i<3; i++)
    scanf("%lld", &a[i].v), a[i].id = i + 1;
  puts("First");
  puts("1000000000");
  int id = 0;
  scanf("%d", &id);
  a[id - 1].v += 1000000000;
  sort(a, a + 3);
  printf("%lld\n", 1LL * 2 * a[2].v - a[0].v - a[1].v);
  scanf("%d", &id);
  if(id == 0) return 0;
  int val = 1LL * 2 * a[2].v - a[0].v - a[1].v;
  for(int i=0; i<3; i++)
    if(a[i].id == id)
      a[i].v += val;
  sort(a, a + 3);
  printf("%lld\n", a[1].v - a[0].v);
  while(true) ;
	return 0;
}


// Codeforces contest template
#include <bits/stdc++.h>
using namespace std;
#define File(s) freopen(s".in", "r", stdin), freopen(s".out", "w", stdout)

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define mkp make_pair
#define pb push_back
#define SP putchar(' ')
#define EL putchar('\n')

mt19937 rnd(chrono :: steady_clock :: now().time_since_epoch().count());
mt19937_64 rnd64(chrono :: steady_clock :: now().time_since_epoch().count()) ;

template<class T> inline void gi(T &x){
	char ch; x = 0;int f = 1;
	while(isspace(ch = getchar()));
	if(ch == '-') ch = getchar(), f = -1;
	do x = x * 10 + ch - '0'; while(isdigit(ch = getchar()));
	x *= f;
}
template<class T> inline void wi(T x){
	static char stk[128]; int top = 0;
	if(x == 0) putchar('0');
	if(x < 0) putchar('-'), x = -x;
	while(x) stk[++top] = x % 10, x /= 10;
	while(top) putchar(stk[top--] + '0');
}
template<class T> void upmax(T &x, T y){x = x>y ? x : y;}
template<class T> void upmin(T &x, T y){x = x<y ? x : y;}

struct Val{
  ll v;
  int id;
  bool operator<(Val rhs) {return v < rhs.v;}
};

int main(){
  setbuf(stdout, NULL);
  Val a[3];
  for(int i=0; i<3; i++)
    scanf("%lld", &a[i]), a[i].id = i + 1;
  puts("First");
  puts("1000000000");
  int id = 0;
  scanf("%d", &id);
  a[id].v += 1000000000;
  sort(a, a + 3);
  printf("%lld\n", 1LL * 2 * a[2].v - a[0].v - a[1].v);
  scanf("%d", &id);
  if(id == 0) return 0;
  for(int i=0; i<3; i++)
    if(a[i].id == id)
      a[id].v += 1LL * 2 * a[2].v - a[0].v - a[1].v;
  sort(a, a + 3);
  printf("%lld\n", a[1].v - a[0].v);
	return 0;
}


// Codeforces contest template
#include <bits/stdc++.h>
using namespace std;
#define File(s) freopen(s".in", "r", stdin), freopen(s".out", "w", stdout)

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define mkp make_pair
#define pb push_back
#define SP putchar(' ')
#define EL putchar('\n')

mt19937 rnd(chrono :: steady_clock :: now().time_since_epoch().count());
mt19937_64 rnd64(chrono :: steady_clock :: now().time_since_epoch().count()) ;

template<class T> inline void gi(T &x){
	char ch; x = 0;int f = 1;
	while(isspace(ch = getchar()));
	if(ch == '-') ch = getchar(), f = -1;
	do x = x * 10 + ch - '0'; while(isdigit(ch = getchar()));
	x *= f;
}
template<class T> inline void wi(T x){
	static char stk[128]; int top = 0;
	if(x == 0) putchar('0');
	if(x < 0) putchar('-'), x = -x;
	while(x) stk[++top] = x % 10, x /= 10;
	while(top) putchar(stk[top--] + '0');
}
template<class T> void upmax(T &x, T y){x = x>y ? x : y;}
template<class T> void upmin(T &x, T y){x = x<y ? x : y;}

struct Val{
  ll v;
  int id;
  bool operator<(Val r) {return v < r.v;}
}v[3];

bool judge(int id){
  if(v[0].v == v[1].v || v[0].v == v[2].v || v[1].v == v[2].v) return false;
  int s[2], sc = 0;
  for(int i=0; i<3; i++){
    if(i == id) continue;
    s[sc++] = v[id].v - v[i].v;
  }
  if(s[0] > 0 && s[1] > 0 && (s[0] == 2 * s[1] || s[1] == 2 * s[0])) return false;
  return true;
}

int main(){
	// File("f");
  for(int i=0; i<3; i++) gi(v[i].v), v[i].id = i + 1;
  sort(v + 1, v + 3);
  puts("Second"); fflush(stdout);
  int last = -1;
  while(true){
    sort(v, v + 3);
    ll x; gi(x);
    if(x == -1 || x == 0) exit(0);
    bool flag = false;
    for(int i=2; i>=0; i--){
      if(last == v[i].id) continue;
      v[i].v += x;
      if(!judge(i)) v[i].v -= x;
      else{
        printf("%d\n", v[i].id); fflush(stdout);
        last = v[i].id;
        flag = true;
        break;
      }
    }
    if(!flag) exit(0);
  }
	return 0;
}


// Codeforces contest template
#include <bits/stdc++.h>
using namespace std;
#define File(s) freopen(s".in", "r", stdin), freopen(s".out", "w", stdout)

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define mkp make_pair
#define pb push_back
#define SP putchar(' ')
#define EL putchar('\n')

mt19937 rnd(chrono :: steady_clock :: now().time_since_epoch().count());
mt19937_64 rnd64(chrono :: steady_clock :: now().time_since_epoch().count()) ;

template<class T> inline void gi(T &x){
	char ch; x = 0;int f = 1;
	while(isspace(ch = getchar()));
	if(ch == '-') ch = getchar(), f = -1;
	do x = x * 10 + ch - '0'; while(isdigit(ch = getchar()));
	x *= f;
}
template<class T> inline void wi(T x){
	static char stk[128]; int top = 0;
	if(x == 0) putchar('0');
	if(x < 0) putchar('-'), x = -x;
	while(x) stk[++top] = x % 10, x /= 10;
	while(top) putchar(stk[top--] + '0');
}
template<class T> void upmax(T &x, T y){x = x>y ? x : y;}
template<class T> void upmin(T &x, T y){x = x<y ? x : y;}

struct Val{
  ll v;
  int id;
  bool operator<(Val rhs) {return v < rhs.v;}
};

int main(){
  setbuf(stdout, NULL);
  Val a[3];
  for(int i=0; i<3; i++)
    scanf("%lld", &a[i].v), a[i].id = i + 1;
  puts("First");
  puts("1000000000");
  int id = 0;
  scanf("%d", &id);
  a[id - 1].v += 1000000000;
  sort(a, a + 3);
  printf("%lld\n", 1LL * 2 * a[2].v - a[0].v - a[1].v);
  scanf("%d", &id);
  if(id == 0) return 0;
  int val = 1LL * 2 * a[2].v - a[0].v - a[1].v;
  for(int i=0; i<3; i++)
    if(a[i].id == id)
      a[i].v += val;
  sort(a, a + 3);
  printf("%lld\n", a[1].v - a[0].v);
	return 0;
}


/*/ Author: kal013 /*/
// #pragma GCC optimize ("O3")
#include "bits/stdc++.h"
#include "ext/pb_ds/assoc_container.hpp"
#include "ext/pb_ds/tree_policy.hpp"
using namespace std;
using namespace __gnu_pbds;

template<class T>
using ordered_set = tree<T, null_type,less<T>, rb_tree_tag,tree_order_statistics_node_update> ;

template<class key, class value, class cmp = std::less<key>>
using ordered_map = tree<key, value, cmp, rb_tree_tag, tree_order_statistics_node_update>;
// find_by_order(k)  returns iterator to kth element starting from 0;
// order_of_key(k) returns count of elements strictly smaller than k;

struct custom_hash { // Credits: https://codeforces.com/blog/entry/62393
    static uint64_t splitmix64(uint64_t x) {
        // http://xorshift.di.unimi.it/splitmix64.c
        x += 0x9e3779b97f4a7c15;
        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
        return x ^ (x >> 31);
    }

    size_t operator()(uint64_t x) const {
        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
        return splitmix64(x + FIXED_RANDOM);
    }
    size_t operator()(pair<int64_t,int64_t> Y) const{
        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
        return splitmix64(Y.first * 31 + Y.second + FIXED_RANDOM);
    }
};

template<class T> ostream& operator<<(ostream &os, vector<T> V) {
    os << "[ ";
    for(auto v : V) os << v << " ";
    return os << "]";
}
template<class T> ostream& operator<<(ostream &os, set<T> S){
    os << "{ ";
    for(auto s:S) os<<s<<" ";
    return os<<"}";
}
template<class T> ostream& operator<<(ostream &os, unordered_set<T> S){
    os << "{ ";
    for(auto s:S) os<<s<<" ";
    return os<<"}";
}
template<class T> ostream& operator << (ostream& os, multiset<T> S){
    os << "{ ";
    for(auto s:S) os<<s<<" ";
    return os<<"}";
}
template<class T> ostream& operator<<(ostream &os, ordered_set<T> S){
    os << "{ ";
    for(auto s:S) os<<s<<" ";
    return os<<"}";
}
template<class L, class R> ostream& operator<<(ostream &os, pair<L,R> P) {
    return os << "(" << P.first << "," << P.second << ")";
}
template<class L, class R> ostream& operator<<(ostream &os, map<L,R> M) {
    os << "{ ";
    for(auto m:M) os<<"("<<m.first<<":"<<m.second<<") ";
    return os<<"}";
}
template<class L, class R, class chash = std::hash<R>> ostream& operator<<(ostream &os, unordered_map<L,R,chash> M) {
    os << "{ ";
    for(auto m:M) os<<"("<<m.first<<":"<<m.second<<") ";
    return os<<"}";
}
template<class L, class R, class chash = std::hash<R> > ostream& operator<<(ostream &os, gp_hash_table<L,R,chash> M) {
    os << "{ ";
    for(auto m:M) os<<"("<<m.first<<":"<<m.second<<") ";
    return os<<"}";
}

#define TRACE
#ifdef TRACE
    #define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
    template <typename Arg1>
    void __f(const char* name, Arg1&& arg1){
        cerr << name << " : " << arg1 << endl;
    }
    template <typename Arg1, typename... Args>
    void __f(const char* names, Arg1&& arg1, Args&&... args){
        const char* comma = strchr(names + 1, ',');
        cerr.write(names, comma - names) << " : " << arg1<<" | ";
        __f(comma+1, args...);
    }
#else
    #define trace(...) 1
#endif

mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());

inline int64_t random_long(long long l,long long r){
    uniform_int_distribution<int64_t> generator(l,r);
    return generator(rng);
}
inline int64_t random_long(){
    uniform_int_distribution<int64_t> generator(LLONG_MIN,LLONG_MAX);
    return generator(rng);
}

/*/---------------------------Defines----------------------/*/
typedef vector<int> vi;
typedef pair<int,int> pii;

#define ll long long
#define F first
#define S second
#define pb push_back
#define all(v) (v).begin(),(v).end()
/*/-----------------------Modular Arithmetic---------------/*/

const int mod=1e9+7;
inline int add(int x,int y){
    x+=y;
    if (x>=mod) return x-mod;
    return x;
}
inline int sub(int x,int y){
    x-=y;
    if (x<0) return x+mod;
    return x;
}
inline int mul(int x,int y){
    return (x*1ll*y)%mod;
}
inline int power(int x,int y){
    int ans=1;
    while(y){
        if (y&1) ans=mul(ans,x);
        x=mul(x,x);
        y>>=1;
    }
    return ans;
}
inline int inv(int x){
    return power(x,mod-2);
}
/*/-----------------------------Code begins----------------------------------/*/

vector<pair<ll,ll> > A;

bool done(){
	if (A[0].first == A[1].first) exit(0);
	if (A[1].first == A[2].first) exit(0);
	if (A[2].first == A[0].first) exit(0);
	return false;
	// return ((A[0].first == A[1].first)  || (A[1].first == A[2].first));
}
bool is_ap(vector<pair<ll,ll> > & A){
	sort(all(A));

	return (A[1].first - A[0].first == A[2].first - A[1].first);
}

int last_output;

void query(ll x){
	done();
	if (last_output == 0){
		exit(0);
		return;
	}

	cout << x << endl;

	cin >> last_output;

	if (last_output == -1){
		exit(0);
	}
	if (last_output == 0) {
		exit(0);
		return;
	}
	for(int i = 0 ; i < 3; ++i){
		if (A[i].second == last_output ){
			A[i].first += x;
		}
	}

	sort(all(A));

	// trace(A);
}
void do_ap(vector<pair<ll,ll> > & A){
	if (last_output == 0){
		return;
	}
	// assert(is_ap(A));
	sort(all(A));
	ll d= A[1].first - A[0].first;

	// assert( d > 0);
	query(d);
	query(3*d);
	query(d);
	query(d);
	query(2*d);
	done();
	exit(0);
	// assert(done() || last_output == 0);
}

int get_pos(){
	sort(all(A));
	for(int i = 0 ; i < 3; ++i){
		if (A[i].second == last_output){
			return i;
		}
	}
	done();
	// assert(false);
}
const ll INF = 3e9;
void solve(){
    last_output = 4;
    A.resize(3);
    for(int i = 0 ; i < 3; ++i){
    	cin >> A[i].first;
    	A[i].second = i + 1;
    }
    sort(all(A));
    cout << "First" << endl;

    if (is_ap(A)){
    	do_ap(A);
    	return;
    }

    query(INF);
    if (is_ap(A)){
    	do_ap(A);
    	return;
    }

    int id = get_pos();
    while (id != 1){
    	if (id == 0){
    		query(A[2].first - A[1].first);
    		query(A[1].first - A[0].first);
    	}
    	else{

    		query(A[1].first - A[0].first);
    	}
    	id = get_pos();

    }
    done();

    assert(id == 1 || done());

    ll x = A[1].first - A[0].first, y = A[2].first - A[1].first;

    while( !is_ap(A) && last_output != 0 && x < y && !done()){
    	id = get_pos();
    	done();
    	// assert(id == 1 || done());
    	query(x);
    	done();
    	id = get_pos();
    	// assert(id == 2);
    	query(x);

    	x *= 2;
    	// assert( x == A[1].first - A[0].first);
    }
	if (x > y){
    	query(x - y);

    }
    // assert(is_ap(A));
    do_ap(A);
}
int main(){
    // Use "set_name".max_load_factor(0.25);"set_name".reserve(512); with unordered set
    // Or use gp_hash_table<X,null_type>
    ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
    cout<<fixed<<setprecision(25);
    cerr<<fixed<<setprecision(10);
    auto start = std::chrono::high_resolution_clock::now();
    int t=1;
    // cin>>t;
    while(t--) {
        solve();
    }
    auto stop = std::chrono::high_resolution_clock::now();
    auto duration = std::chrono::duration_cast<std::chrono::nanoseconds>(stop - start);

    // cerr << "Time taken : " << ((long double)duration.count())/((long double) 1e9) <<"s "<< endl;
}


/*/ Author: kal013 /*/
// #pragma GCC optimize ("O3")
#include "bits/stdc++.h"
#include "ext/pb_ds/assoc_container.hpp"
#include "ext/pb_ds/tree_policy.hpp"
using namespace std;
using namespace __gnu_pbds;

template<class T>
using ordered_set = tree<T, null_type,less<T>, rb_tree_tag,tree_order_statistics_node_update> ;

template<class key, class value, class cmp = std::less<key>>
using ordered_map = tree<key, value, cmp, rb_tree_tag, tree_order_statistics_node_update>;
// find_by_order(k)  returns iterator to kth element starting from 0;
// order_of_key(k) returns count of elements strictly smaller than k;

struct custom_hash { // Credits: https://codeforces.com/blog/entry/62393
    static uint64_t splitmix64(uint64_t x) {
        // http://xorshift.di.unimi.it/splitmix64.c
        x += 0x9e3779b97f4a7c15;
        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
        return x ^ (x >> 31);
    }

    size_t operator()(uint64_t x) const {
        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
        return splitmix64(x + FIXED_RANDOM);
    }
    size_t operator()(pair<int64_t,int64_t> Y) const{
        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
        return splitmix64(Y.first * 31 + Y.second + FIXED_RANDOM);
    }
};

template<class T> ostream& operator<<(ostream &os, vector<T> V) {
    os << "[ ";
    for(auto v : V) os << v << " ";
    return os << "]";
}
template<class T> ostream& operator<<(ostream &os, set<T> S){
    os << "{ ";
    for(auto s:S) os<<s<<" ";
    return os<<"}";
}
template<class T> ostream& operator<<(ostream &os, unordered_set<T> S){
    os << "{ ";
    for(auto s:S) os<<s<<" ";
    return os<<"}";
}
template<class T> ostream& operator << (ostream& os, multiset<T> S){
    os << "{ ";
    for(auto s:S) os<<s<<" ";
    return os<<"}";
}
template<class T> ostream& operator<<(ostream &os, ordered_set<T> S){
    os << "{ ";
    for(auto s:S) os<<s<<" ";
    return os<<"}";
}
template<class L, class R> ostream& operator<<(ostream &os, pair<L,R> P) {
    return os << "(" << P.first << "," << P.second << ")";
}
template<class L, class R> ostream& operator<<(ostream &os, map<L,R> M) {
    os << "{ ";
    for(auto m:M) os<<"("<<m.first<<":"<<m.second<<") ";
    return os<<"}";
}
template<class L, class R, class chash = std::hash<R>> ostream& operator<<(ostream &os, unordered_map<L,R,chash> M) {
    os << "{ ";
    for(auto m:M) os<<"("<<m.first<<":"<<m.second<<") ";
    return os<<"}";
}
template<class L, class R, class chash = std::hash<R> > ostream& operator<<(ostream &os, gp_hash_table<L,R,chash> M) {
    os << "{ ";
    for(auto m:M) os<<"("<<m.first<<":"<<m.second<<") ";
    return os<<"}";
}

#define TRACE
#ifdef TRACE
    #define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
    template <typename Arg1>
    void __f(const char* name, Arg1&& arg1){
        cerr << name << " : " << arg1 << endl;
    }
    template <typename Arg1, typename... Args>
    void __f(const char* names, Arg1&& arg1, Args&&... args){
        const char* comma = strchr(names + 1, ',');
        cerr.write(names, comma - names) << " : " << arg1<<" | ";
        __f(comma+1, args...);
    }
#else
    #define trace(...) 1
#endif

mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());

inline int64_t random_long(long long l,long long r){
    uniform_int_distribution<int64_t> generator(l,r);
    return generator(rng);
}
inline int64_t random_long(){
    uniform_int_distribution<int64_t> generator(LLONG_MIN,LLONG_MAX);
    return generator(rng);
}

/*/---------------------------Defines----------------------/*/
typedef vector<int> vi;
typedef pair<int,int> pii;

#define ll long long
#define F first
#define S second
#define pb push_back
#define all(v) (v).begin(),(v).end()
/*/-----------------------Modular Arithmetic---------------/*/

const int mod=1e9+7;
inline int add(int x,int y){
    x+=y;
    if (x>=mod) return x-mod;
    return x;
}
inline int sub(int x,int y){
    x-=y;
    if (x<0) return x+mod;
    return x;
}
inline int mul(int x,int y){
    return (x*1ll*y)%mod;
}
inline int power(int x,int y){
    int ans=1;
    while(y){
        if (y&1) ans=mul(ans,x);
        x=mul(x,x);
        y>>=1;
    }
    return ans;
}
inline int inv(int x){
    return power(x,mod-2);
}
/*/-----------------------------Code begins----------------------------------/*/

vector<pair<ll,ll> > A;

bool done(){
	if (A[0].first == A[1].first) exit(0);
	if (A[1].first == A[2].first) exit(0);
	if (A[2].first == A[0].first) exit(0);
	return false;
	// return ((A[0].first == A[1].first)  || (A[1].first == A[2].first));
}
bool is_ap(vector<pair<ll,ll> > & A){
	sort(all(A));

	return (A[1].first - A[0].first == A[2].first - A[1].first);
}

int last_output;

void query(ll x){
	done();
	if (last_output == 0){
		exit(0);
		return;
	}

	cout << x << endl;

	cin >> last_output;

	if (last_output == -1){
		exit(0);
	}
	if (last_output == 0) {
		exit(0);
		return;
	}
	for(int i = 0 ; i < 3; ++i){
		if (A[i].second == last_output ){
			A[i].first += x;
		}
	}

	sort(all(A));

	// trace(A);
}
void do_ap(vector<pair<ll,ll> > & A){
	if (last_output == 0){
		return;
	}
	// assert(is_ap(A));
	sort(all(A));
	ll d= A[1].first - A[0].first;

	// assert( d > 0);
	query(d);
	query(3*d);
	query(d);
	query(d);
	query(2*d);
	done();
	exit(0);
	// assert(done() || last_output == 0);
}

int get_pos(){
	sort(all(A));
	for(int i = 0 ; i < 3; ++i){
		if (A[i].second == last_output){
			return i;
		}
	}
	done();
	// assert(false);
}
void solve(){
    last_output = 4;
    A.resize(3);
    for(int i = 0 ; i < 3; ++i){
    	cin >> A[i].first;
    	A[i].second = i + 1;
    }
    sort(all(A));
    cout << "First" << endl;

    if (is_ap(A)){
    	do_ap(A);
    	return;
    }

    query(1);
    if (is_ap(A)){
    	do_ap(A);
    	return;
    }

    int id = get_pos();
    if (id != 1){
    	if (id == 0){
    		query(A[2].first - A[1].first);
    		query(A[1].first - A[0].first);
    	}
    	else{
    		query(A[1].first - A[0].first);
    	}
    	id = get_pos();

    }
    done();
    assert(id == 1 || done());

    ll x = A[1].first - A[0].first, y = A[2].first - A[1].first;

    while( !is_ap(A) && last_output != 0 && x < y && !done()){
    	id = get_pos();
    	done();
    	// assert(id == 1 || done());
    	query(x);
    	done();
    	id = get_pos();
    	// assert(id == 2);
    	query(x);

    	x *= 2;
    	// assert( x == A[1].first - A[0].first);
    }
	if (x > y){
    	query(x - y);

    }
    // assert(is_ap(A));
    do_ap(A);
}
int main(){
    // Use "set_name".max_load_factor(0.25);"set_name".reserve(512); with unordered set
    // Or use gp_hash_table<X,null_type>
    ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
    cout<<fixed<<setprecision(25);
    cerr<<fixed<<setprecision(10);
    auto start = std::chrono::high_resolution_clock::now();
    int t=1;
    // cin>>t;
    while(t--) {
        solve();
    }
    auto stop = std::chrono::high_resolution_clock::now();
    auto duration = std::chrono::duration_cast<std::chrono::nanoseconds>(stop - start);

    // cerr << "Time taken : " << ((long double)duration.count())/((long double) 1e9) <<"s "<< endl;
}


/*/ Author: kal013 /*/
// #pragma GCC optimize ("O3")
#include "bits/stdc++.h"
#include "ext/pb_ds/assoc_container.hpp"
#include "ext/pb_ds/tree_policy.hpp"
using namespace std;
using namespace __gnu_pbds;

template<class T>
using ordered_set = tree<T, null_type,less<T>, rb_tree_tag,tree_order_statistics_node_update> ;

template<class key, class value, class cmp = std::less<key>>
using ordered_map = tree<key, value, cmp, rb_tree_tag, tree_order_statistics_node_update>;
// find_by_order(k)  returns iterator to kth element starting from 0;
// order_of_key(k) returns count of elements strictly smaller than k;

struct custom_hash { // Credits: https://codeforces.com/blog/entry/62393
    static uint64_t splitmix64(uint64_t x) {
        // http://xorshift.di.unimi.it/splitmix64.c
        x += 0x9e3779b97f4a7c15;
        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
        return x ^ (x >> 31);
    }

    size_t operator()(uint64_t x) const {
        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
        return splitmix64(x + FIXED_RANDOM);
    }
    size_t operator()(pair<int64_t,int64_t> Y) const{
        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
        return splitmix64(Y.first * 31 + Y.second + FIXED_RANDOM);
    }
};

template<class T> ostream& operator<<(ostream &os, vector<T> V) {
    os << "[ ";
    for(auto v : V) os << v << " ";
    return os << "]";
}
template<class T> ostream& operator<<(ostream &os, set<T> S){
    os << "{ ";
    for(auto s:S) os<<s<<" ";
    return os<<"}";
}
template<class T> ostream& operator<<(ostream &os, unordered_set<T> S){
    os << "{ ";
    for(auto s:S) os<<s<<" ";
    return os<<"}";
}
template<class T> ostream& operator << (ostream& os, multiset<T> S){
    os << "{ ";
    for(auto s:S) os<<s<<" ";
    return os<<"}";
}
template<class T> ostream& operator<<(ostream &os, ordered_set<T> S){
    os << "{ ";
    for(auto s:S) os<<s<<" ";
    return os<<"}";
}
template<class L, class R> ostream& operator<<(ostream &os, pair<L,R> P) {
    return os << "(" << P.first << "," << P.second << ")";
}
template<class L, class R> ostream& operator<<(ostream &os, map<L,R> M) {
    os << "{ ";
    for(auto m:M) os<<"("<<m.first<<":"<<m.second<<") ";
    return os<<"}";
}
template<class L, class R, class chash = std::hash<R>> ostream& operator<<(ostream &os, unordered_map<L,R,chash> M) {
    os << "{ ";
    for(auto m:M) os<<"("<<m.first<<":"<<m.second<<") ";
    return os<<"}";
}
template<class L, class R, class chash = std::hash<R> > ostream& operator<<(ostream &os, gp_hash_table<L,R,chash> M) {
    os << "{ ";
    for(auto m:M) os<<"("<<m.first<<":"<<m.second<<") ";
    return os<<"}";
}

#define TRACE
#ifdef TRACE
    #define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
    template <typename Arg1>
    void __f(const char* name, Arg1&& arg1){
        cerr << name << " : " << arg1 << endl;
    }
    template <typename Arg1, typename... Args>
    void __f(const char* names, Arg1&& arg1, Args&&... args){
        const char* comma = strchr(names + 1, ',');
        cerr.write(names, comma - names) << " : " << arg1<<" | ";
        __f(comma+1, args...);
    }
#else
    #define trace(...) 1
#endif

mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());

inline int64_t random_long(long long l,long long r){
    uniform_int_distribution<int64_t> generator(l,r);
    return generator(rng);
}
inline int64_t random_long(){
    uniform_int_distribution<int64_t> generator(LLONG_MIN,LLONG_MAX);
    return generator(rng);
}

/*/---------------------------Defines----------------------/*/
typedef vector<int> vi;
typedef pair<int,int> pii;

#define ll long long
#define F first
#define S second
#define pb push_back
#define all(v) (v).begin(),(v).end()
/*/-----------------------Modular Arithmetic---------------/*/

const int mod=1e9+7;
inline int add(int x,int y){
    x+=y;
    if (x>=mod) return x-mod;
    return x;
}
inline int sub(int x,int y){
    x-=y;
    if (x<0) return x+mod;
    return x;
}
inline int mul(int x,int y){
    return (x*1ll*y)%mod;
}
inline int power(int x,int y){
    int ans=1;
    while(y){
        if (y&1) ans=mul(ans,x);
        x=mul(x,x);
        y>>=1;
    }
    return ans;
}
inline int inv(int x){
    return power(x,mod-2);
}
/*/-----------------------------Code begins----------------------------------/*/

vector<pair<ll,ll> > A;

bool done(){
	sort(all(A));
	return ((A[0].first == A[1].first)  || (A[1].first == A[2].first));
}
bool is_ap(vector<pair<ll,ll> > & A){
	sort(all(A));

	return (A[1].first - A[0].first == A[2].first - A[1].first);
}

int last_output;

void query(ll x){

	if (last_output == 0){
		exit(0);
		return;
	}

	assert(!done());

	cout << x << endl;

	cin >> last_output;

	assert(last_output != -1);
	if (last_output == 0) {
		exit(0);
		return;
	}
	for(int i = 0 ; i < 3; ++i){
		if (A[i].second == last_output ){
			A[i].first += x;
		}
	}

	sort(all(A));

}
void do_ap(vector<pair<ll,ll> > & A){
	if (last_output == 0){
		return;
	}
	assert(is_ap(A));
	ll d= A[1].first - A[0].first;

	assert( d > 0);
	query(d);
	query(3*d);
	query(d);
	query(d);
	query(2*d);

	assert(last_output == 0);
}

int get_pos(){
	sort(all(A));
	for(int i = 0 ; i < 3; ++i){
		if (A[i].second == last_output){
			return i;
		}
	}
	assert(false);
}
void solve(){
    last_output = 4;
    A.resize(3);
    for(int i = 0 ; i < 3; ++i){
    	cin >> A[i].first;
    	A[i].second = i + 1;
    }
    cout << "First" << endl;
    if (is_ap(A)){
    	do_ap(A);
    	return;
    }

    query(1);
    if (is_ap(A)){
    	do_ap(A);
    	return;
    }

    int id = get_pos();
    if (id != 1){
    	if (id == 0){
    		query(A[2].first - A[1].first);
    		query(A[1].first - A[0].first);
    	}
    	else{
    		query(A[1].first - A[0].first);
    	}
    	id = get_pos();

    }

    assert(id == 1);

    ll x = A[1].first - A[0].first, y = A[2].first - A[1].first;

    while( !is_ap(A) && last_output != 0 && x < y){
    	id = get_pos();
    	assert(id == 1);
    	query(x);
    	assert(id == 2);
    	query(x);

    	x *= 2;
    	assert( x == A[1].first - A[0].first);
    }

    query(x - y);
    assert(is_ap(A));
    do_ap(A);
}
int main(){
    // Use "set_name".max_load_factor(0.25);"set_name".reserve(512); with unordered set
    // Or use gp_hash_table<X,null_type>
    ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
    cout<<fixed<<setprecision(25);
    cerr<<fixed<<setprecision(10);
    auto start = std::chrono::high_resolution_clock::now();
    int t=1;
    // cin>>t;
    while(t--) {
        solve();
    }
    auto stop = std::chrono::high_resolution_clock::now();
    auto duration = std::chrono::duration_cast<std::chrono::nanoseconds>(stop - start);

    // cerr << "Time taken : " << ((long double)duration.count())/((long double) 1e9) <<"s "<< endl;
}


/*/ Author: kal013 /*/
// #pragma GCC optimize ("O3")
#include "bits/stdc++.h"
#include "ext/pb_ds/assoc_container.hpp"
#include "ext/pb_ds/tree_policy.hpp"
using namespace std;
using namespace __gnu_pbds;

template<class T>
using ordered_set = tree<T, null_type,less<T>, rb_tree_tag,tree_order_statistics_node_update> ;

template<class key, class value, class cmp = std::less<key>>
using ordered_map = tree<key, value, cmp, rb_tree_tag, tree_order_statistics_node_update>;
// find_by_order(k)  returns iterator to kth element starting from 0;
// order_of_key(k) returns count of elements strictly smaller than k;

struct custom_hash { // Credits: https://codeforces.com/blog/entry/62393
    static uint64_t splitmix64(uint64_t x) {
        // http://xorshift.di.unimi.it/splitmix64.c
        x += 0x9e3779b97f4a7c15;
        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
        return x ^ (x >> 31);
    }

    size_t operator()(uint64_t x) const {
        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
        return splitmix64(x + FIXED_RANDOM);
    }
    size_t operator()(pair<int64_t,int64_t> Y) const{
        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
        return splitmix64(Y.first * 31 + Y.second + FIXED_RANDOM);
    }
};

template<class T> ostream& operator<<(ostream &os, vector<T> V) {
    os << "[ ";
    for(auto v : V) os << v << " ";
    return os << "]";
}
template<class T> ostream& operator<<(ostream &os, set<T> S){
    os << "{ ";
    for(auto s:S) os<<s<<" ";
    return os<<"}";
}
template<class T> ostream& operator<<(ostream &os, unordered_set<T> S){
    os << "{ ";
    for(auto s:S) os<<s<<" ";
    return os<<"}";
}
template<class T> ostream& operator << (ostream& os, multiset<T> S){
    os << "{ ";
    for(auto s:S) os<<s<<" ";
    return os<<"}";
}
template<class T> ostream& operator<<(ostream &os, ordered_set<T> S){
    os << "{ ";
    for(auto s:S) os<<s<<" ";
    return os<<"}";
}
template<class L, class R> ostream& operator<<(ostream &os, pair<L,R> P) {
    return os << "(" << P.first << "," << P.second << ")";
}
template<class L, class R> ostream& operator<<(ostream &os, map<L,R> M) {
    os << "{ ";
    for(auto m:M) os<<"("<<m.first<<":"<<m.second<<") ";
    return os<<"}";
}
template<class L, class R, class chash = std::hash<R>> ostream& operator<<(ostream &os, unordered_map<L,R,chash> M) {
    os << "{ ";
    for(auto m:M) os<<"("<<m.first<<":"<<m.second<<") ";
    return os<<"}";
}
template<class L, class R, class chash = std::hash<R> > ostream& operator<<(ostream &os, gp_hash_table<L,R,chash> M) {
    os << "{ ";
    for(auto m:M) os<<"("<<m.first<<":"<<m.second<<") ";
    return os<<"}";
}

#define TRACE
#ifdef TRACE
    #define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
    template <typename Arg1>
    void __f(const char* name, Arg1&& arg1){
        cerr << name << " : " << arg1 << endl;
    }
    template <typename Arg1, typename... Args>
    void __f(const char* names, Arg1&& arg1, Args&&... args){
        const char* comma = strchr(names + 1, ',');
        cerr.write(names, comma - names) << " : " << arg1<<" | ";
        __f(comma+1, args...);
    }
#else
    #define trace(...) 1
#endif

mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());

inline int64_t random_long(long long l,long long r){
    uniform_int_distribution<int64_t> generator(l,r);
    return generator(rng);
}
inline int64_t random_long(){
    uniform_int_distribution<int64_t> generator(LLONG_MIN,LLONG_MAX);
    return generator(rng);
}

/*/---------------------------Defines----------------------/*/
typedef vector<int> vi;
typedef pair<int,int> pii;

#define ll long long
#define F first
#define S second
#define pb push_back
#define all(v) (v).begin(),(v).end()
/*/-----------------------Modular Arithmetic---------------/*/

const int mod=1e9+7;
inline int add(int x,int y){
    x+=y;
    if (x>=mod) return x-mod;
    return x;
}
inline int sub(int x,int y){
    x-=y;
    if (x<0) return x+mod;
    return x;
}
inline int mul(int x,int y){
    return (x*1ll*y)%mod;
}
inline int power(int x,int y){
    int ans=1;
    while(y){
        if (y&1) ans=mul(ans,x);
        x=mul(x,x);
        y>>=1;
    }
    return ans;
}
inline int inv(int x){
    return power(x,mod-2);
}
/*/-----------------------------Code begins----------------------------------/*/

vector<pair<ll,ll> > A;

bool done(){
	if (A[0].first == A[1].first) exit(0);
	if (A[1].first == A[2].first) exit(0);
	if (A[2].first == A[0].first) exit(0);
	return false;
	// return ((A[0].first == A[1].first)  || (A[1].first == A[2].first));
}
bool is_ap(vector<pair<ll,ll> > & A){
	sort(all(A));

	return (A[1].first - A[0].first == A[2].first - A[1].first);
}

int last_output;

void query(ll x){

	if (last_output == 0){
		exit(0);
		return;
	}

	assert(!done());

	cout << x << endl;

	cin >> last_output;

	if (last_output == -1){
		exit(0);
	}
	if (last_output == 0) {
		exit(0);
		return;
	}
	for(int i = 0 ; i < 3; ++i){
		if (A[i].second == last_output ){
			A[i].first += x;
		}
	}

	sort(all(A));

	// trace(A);
}
void do_ap(vector<pair<ll,ll> > & A){
	if (last_output == 0){
		return;
	}
	assert(is_ap(A));
	ll d= A[1].first - A[0].first;

	assert( d > 0);
	query(d);
	query(3*d);
	query(d);
	query(d);
	query(2*d);

	assert(done() || last_output == 0);
}

int get_pos(){
	sort(all(A));
	for(int i = 0 ; i < 3; ++i){
		if (A[i].second == last_output){
			return i;
		}
	}
	assert(false);
}
void solve(){
    last_output = 4;
    A.resize(3);
    for(int i = 0 ; i < 3; ++i){
    	cin >> A[i].first;
    	A[i].second = i + 1;
    }
    sort(all(A));
    cout << "First" << endl;

    if (is_ap(A)){
    	do_ap(A);
    	return;
    }

    query(1);
    if (is_ap(A)){
    	do_ap(A);
    	return;
    }

    int id = get_pos();
    if (id != 1){
    	if (id == 0){
    		query(A[2].first - A[1].first);
    		query(A[1].first - A[0].first);
    	}
    	else{
    		query(A[1].first - A[0].first);
    	}
    	id = get_pos();

    }

    assert(id == 1 || done());

    ll x = A[1].first - A[0].first, y = A[2].first - A[1].first;

    while( !is_ap(A) && last_output != 0 && x < y && !done()){
    	id = get_pos();
    	assert(id == 1 || done());
    	query(x);
    	done();
    	id = get_pos();
    	assert(id == 2);
    	query(x);

    	x *= 2;
    	assert( x == A[1].first - A[0].first);
    }
	if (x > y){
    	query(x - y);

    }
    assert(is_ap(A));
    do_ap(A);
}
int main(){
    // Use "set_name".max_load_factor(0.25);"set_name".reserve(512); with unordered set
    // Or use gp_hash_table<X,null_type>
    ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
    cout<<fixed<<setprecision(25);
    cerr<<fixed<<setprecision(10);
    auto start = std::chrono::high_resolution_clock::now();
    int t=1;
    // cin>>t;
    while(t--) {
        solve();
    }
    auto stop = std::chrono::high_resolution_clock::now();
    auto duration = std::chrono::duration_cast<std::chrono::nanoseconds>(stop - start);

    // cerr << "Time taken : " << ((long double)duration.count())/((long double) 1e9) <<"s "<< endl;
}


/*/ Author: kal013 /*/
// #pragma GCC optimize ("O3")
#include "bits/stdc++.h"
#include "ext/pb_ds/assoc_container.hpp"
#include "ext/pb_ds/tree_policy.hpp"
using namespace std;
using namespace __gnu_pbds;

template<class T>
using ordered_set = tree<T, null_type,less<T>, rb_tree_tag,tree_order_statistics_node_update> ;

template<class key, class value, class cmp = std::less<key>>
using ordered_map = tree<key, value, cmp, rb_tree_tag, tree_order_statistics_node_update>;
// find_by_order(k)  returns iterator to kth element starting from 0;
// order_of_key(k) returns count of elements strictly smaller than k;

struct custom_hash { // Credits: https://codeforces.com/blog/entry/62393
    static uint64_t splitmix64(uint64_t x) {
        // http://xorshift.di.unimi.it/splitmix64.c
        x += 0x9e3779b97f4a7c15;
        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
        return x ^ (x >> 31);
    }

    size_t operator()(uint64_t x) const {
        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
        return splitmix64(x + FIXED_RANDOM);
    }
    size_t operator()(pair<int64_t,int64_t> Y) const{
        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
        return splitmix64(Y.first * 31 + Y.second + FIXED_RANDOM);
    }
};

template<class T> ostream& operator<<(ostream &os, vector<T> V) {
    os << "[ ";
    for(auto v : V) os << v << " ";
    return os << "]";
}
template<class T> ostream& operator<<(ostream &os, set<T> S){
    os << "{ ";
    for(auto s:S) os<<s<<" ";
    return os<<"}";
}
template<class T> ostream& operator<<(ostream &os, unordered_set<T> S){
    os << "{ ";
    for(auto s:S) os<<s<<" ";
    return os<<"}";
}
template<class T> ostream& operator << (ostream& os, multiset<T> S){
    os << "{ ";
    for(auto s:S) os<<s<<" ";
    return os<<"}";
}
template<class T> ostream& operator<<(ostream &os, ordered_set<T> S){
    os << "{ ";
    for(auto s:S) os<<s<<" ";
    return os<<"}";
}
template<class L, class R> ostream& operator<<(ostream &os, pair<L,R> P) {
    return os << "(" << P.first << "," << P.second << ")";
}
template<class L, class R> ostream& operator<<(ostream &os, map<L,R> M) {
    os << "{ ";
    for(auto m:M) os<<"("<<m.first<<":"<<m.second<<") ";
    return os<<"}";
}
template<class L, class R, class chash = std::hash<R>> ostream& operator<<(ostream &os, unordered_map<L,R,chash> M) {
    os << "{ ";
    for(auto m:M) os<<"("<<m.first<<":"<<m.second<<") ";
    return os<<"}";
}
template<class L, class R, class chash = std::hash<R> > ostream& operator<<(ostream &os, gp_hash_table<L,R,chash> M) {
    os << "{ ";
    for(auto m:M) os<<"("<<m.first<<":"<<m.second<<") ";
    return os<<"}";
}

#define TRACE
#ifdef TRACE
    #define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
    template <typename Arg1>
    void __f(const char* name, Arg1&& arg1){
        cerr << name << " : " << arg1 << endl;
    }
    template <typename Arg1, typename... Args>
    void __f(const char* names, Arg1&& arg1, Args&&... args){
        const char* comma = strchr(names + 1, ',');
        cerr.write(names, comma - names) << " : " << arg1<<" | ";
        __f(comma+1, args...);
    }
#else
    #define trace(...) 1
#endif

mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());

inline int64_t random_long(long long l,long long r){
    uniform_int_distribution<int64_t> generator(l,r);
    return generator(rng);
}
inline int64_t random_long(){
    uniform_int_distribution<int64_t> generator(LLONG_MIN,LLONG_MAX);
    return generator(rng);
}

/*/---------------------------Defines----------------------/*/
typedef vector<int> vi;
typedef pair<int,int> pii;

#define ll long long
#define F first
#define S second
#define pb push_back
#define all(v) (v).begin(),(v).end()
/*/-----------------------Modular Arithmetic---------------/*/

const int mod=1e9+7;
inline int add(int x,int y){
    x+=y;
    if (x>=mod) return x-mod;
    return x;
}
inline int sub(int x,int y){
    x-=y;
    if (x<0) return x+mod;
    return x;
}
inline int mul(int x,int y){
    return (x*1ll*y)%mod;
}
inline int power(int x,int y){
    int ans=1;
    while(y){
        if (y&1) ans=mul(ans,x);
        x=mul(x,x);
        y>>=1;
    }
    return ans;
}
inline int inv(int x){
    return power(x,mod-2);
}
/*/-----------------------------Code begins----------------------------------/*/

vector<pair<ll,ll> > A;

bool done(){
	if (A[0].first == A[1].first) exit(0);
	if (A[1].first == A[2].first) exit(0);
	if (A[2].first == A[0].first) exit(0);
	return false;
	// return ((A[0].first == A[1].first)  || (A[1].first == A[2].first));
}
bool is_ap(vector<pair<ll,ll> > & A){
	sort(all(A));

	return (A[1].first - A[0].first == A[2].first - A[1].first);
}

int last_output;

void query(ll x){
	done();
	if (last_output == 0){
		exit(0);
		return;
	}

	cout << x << endl;

	cin >> last_output;

	if (last_output == -1){
		exit(0);
	}
	if (last_output == 0) {
		exit(0);
		return;
	}
	for(int i = 0 ; i < 3; ++i){
		if (A[i].second == last_output ){
			A[i].first += x;
		}
	}

	sort(all(A));

	// trace(A);
}
void do_ap(vector<pair<ll,ll> > & A){
	if (last_output == 0){
		return;
	}
	// assert(is_ap(A));
	sort(all(A));
	ll d= A[1].first - A[0].first;

	// assert( d > 0);
	query(d);
	query(3*d);
	query(d);
	query(d);
	query(2*d);
	done();
	exit(0);
	// assert(done() || last_output == 0);
}

int get_pos(){
	sort(all(A));
	for(int i = 0 ; i < 3; ++i){
		if (A[i].second == last_output){
			return i;
		}
	}
	done();
	// assert(false);
}
void solve(){
    last_output = 4;
    A.resize(3);
    for(int i = 0 ; i < 3; ++i){
    	cin >> A[i].first;
    	A[i].second = i + 1;
    }
    sort(all(A));
    cout << "First" << endl;

    if (is_ap(A)){
    	do_ap(A);
    	return;
    }

    query(1);
    if (is_ap(A)){
    	do_ap(A);
    	return;
    }

    int id = get_pos();
    while (id != 1){
    	if (id == 0){
    		query(A[2].first - A[1].first);
    		query(A[1].first - A[0].first);
    	}
    	else{

    		query(A[1].first - A[0].first);
    	}
    	id = get_pos();

    }
    done();
    assert(id == 1 || done());

    ll x = A[1].first - A[0].first, y = A[2].first - A[1].first;

    while( !is_ap(A) && last_output != 0 && x < y && !done()){
    	id = get_pos();
    	done();
    	// assert(id == 1 || done());
    	query(x);
    	done();
    	id = get_pos();
    	// assert(id == 2);
    	query(x);

    	x *= 2;
    	// assert( x == A[1].first - A[0].first);
    }
	if (x > y){
    	query(x - y);

    }
    // assert(is_ap(A));
    do_ap(A);
}
int main(){
    // Use "set_name".max_load_factor(0.25);"set_name".reserve(512); with unordered set
    // Or use gp_hash_table<X,null_type>
    ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
    cout<<fixed<<setprecision(25);
    cerr<<fixed<<setprecision(10);
    auto start = std::chrono::high_resolution_clock::now();
    int t=1;
    // cin>>t;
    while(t--) {
        solve();
    }
    auto stop = std::chrono::high_resolution_clock::now();
    auto duration = std::chrono::duration_cast<std::chrono::nanoseconds>(stop - start);

    // cerr << "Time taken : " << ((long double)duration.count())/((long double) 1e9) <<"s "<< endl;
}


/*/ Author: kal013 /*/
// #pragma GCC optimize ("O3")
#include "bits/stdc++.h"
#include "ext/pb_ds/assoc_container.hpp"
#include "ext/pb_ds/tree_policy.hpp"
using namespace std;
using namespace __gnu_pbds;

template<class T>
using ordered_set = tree<T, null_type,less<T>, rb_tree_tag,tree_order_statistics_node_update> ;

template<class key, class value, class cmp = std::less<key>>
using ordered_map = tree<key, value, cmp, rb_tree_tag, tree_order_statistics_node_update>;
// find_by_order(k)  returns iterator to kth element starting from 0;
// order_of_key(k) returns count of elements strictly smaller than k;

struct custom_hash { // Credits: https://codeforces.com/blog/entry/62393
    static uint64_t splitmix64(uint64_t x) {
        // http://xorshift.di.unimi.it/splitmix64.c
        x += 0x9e3779b97f4a7c15;
        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
        return x ^ (x >> 31);
    }

    size_t operator()(uint64_t x) const {
        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
        return splitmix64(x + FIXED_RANDOM);
    }
    size_t operator()(pair<int64_t,int64_t> Y) const{
        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
        return splitmix64(Y.first * 31 + Y.second + FIXED_RANDOM);
    }
};

template<class T> ostream& operator<<(ostream &os, vector<T> V) {
    os << "[ ";
    for(auto v : V) os << v << " ";
    return os << "]";
}
template<class T> ostream& operator<<(ostream &os, set<T> S){
    os << "{ ";
    for(auto s:S) os<<s<<" ";
    return os<<"}";
}
template<class T> ostream& operator<<(ostream &os, unordered_set<T> S){
    os << "{ ";
    for(auto s:S) os<<s<<" ";
    return os<<"}";
}
template<class T> ostream& operator << (ostream& os, multiset<T> S){
    os << "{ ";
    for(auto s:S) os<<s<<" ";
    return os<<"}";
}
template<class T> ostream& operator<<(ostream &os, ordered_set<T> S){
    os << "{ ";
    for(auto s:S) os<<s<<" ";
    return os<<"}";
}
template<class L, class R> ostream& operator<<(ostream &os, pair<L,R> P) {
    return os << "(" << P.first << "," << P.second << ")";
}
template<class L, class R> ostream& operator<<(ostream &os, map<L,R> M) {
    os << "{ ";
    for(auto m:M) os<<"("<<m.first<<":"<<m.second<<") ";
    return os<<"}";
}
template<class L, class R, class chash = std::hash<R>> ostream& operator<<(ostream &os, unordered_map<L,R,chash> M) {
    os << "{ ";
    for(auto m:M) os<<"("<<m.first<<":"<<m.second<<") ";
    return os<<"}";
}
template<class L, class R, class chash = std::hash<R> > ostream& operator<<(ostream &os, gp_hash_table<L,R,chash> M) {
    os << "{ ";
    for(auto m:M) os<<"("<<m.first<<":"<<m.second<<") ";
    return os<<"}";
}

#define TRACE
#ifdef TRACE
    #define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
    template <typename Arg1>
    void __f(const char* name, Arg1&& arg1){
        cerr << name << " : " << arg1 << endl;
    }
    template <typename Arg1, typename... Args>
    void __f(const char* names, Arg1&& arg1, Args&&... args){
        const char* comma = strchr(names + 1, ',');
        cerr.write(names, comma - names) << " : " << arg1<<" | ";
        __f(comma+1, args...);
    }
#else
    #define trace(...) 1
#endif

mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());

inline int64_t random_long(long long l,long long r){
    uniform_int_distribution<int64_t> generator(l,r);
    return generator(rng);
}
inline int64_t random_long(){
    uniform_int_distribution<int64_t> generator(LLONG_MIN,LLONG_MAX);
    return generator(rng);
}

/*/---------------------------Defines----------------------/*/
typedef vector<int> vi;
typedef pair<int,int> pii;

#define ll long long
#define F first
#define S second
#define pb push_back
#define all(v) (v).begin(),(v).end()
/*/-----------------------Modular Arithmetic---------------/*/

const int mod=1e9+7;
inline int add(int x,int y){
    x+=y;
    if (x>=mod) return x-mod;
    return x;
}
inline int sub(int x,int y){
    x-=y;
    if (x<0) return x+mod;
    return x;
}
inline int mul(int x,int y){
    return (x*1ll*y)%mod;
}
inline int power(int x,int y){
    int ans=1;
    while(y){
        if (y&1) ans=mul(ans,x);
        x=mul(x,x);
        y>>=1;
    }
    return ans;
}
inline int inv(int x){
    return power(x,mod-2);
}
/*/-----------------------------Code begins----------------------------------/*/

vector<pair<ll,ll> > A;

bool done(){
	sort(all(A));
	return ((A[0].first == A[1].first)  || (A[1].first == A[2].first));
}
bool is_ap(vector<pair<ll,ll> > & A){
	sort(all(A));

	return (A[1].first - A[0].first == A[2].first - A[1].first);
}

int last_output;

void query(ll x){

	if (last_output == 0){
		exit(0);
		return;
	}

	assert(!done());

	cout << x << endl;

	cin >> last_output;

	if (last_output == -1){
		exit(0);
	}
	if (last_output == 0) {
		exit(0);
		return;
	}
	for(int i = 0 ; i < 3; ++i){
		if (A[i].second == last_output ){
			A[i].first += x;
		}
	}

	sort(all(A));

}
void do_ap(vector<pair<ll,ll> > & A){
	if (last_output == 0){
		return;
	}
	assert(is_ap(A));
	ll d= A[1].first - A[0].first;

	assert( d > 0);
	query(d);
	query(3*d);
	query(d);
	query(d);
	query(2*d);

	assert(last_output == 0);
}

int get_pos(){
	sort(all(A));
	for(int i = 0 ; i < 3; ++i){
		if (A[i].second == last_output){
			return i;
		}
	}
	assert(false);
}
void solve(){
    last_output = 4;
    A.resize(3);
    for(int i = 0 ; i < 3; ++i){
    	cin >> A[i].first;
    	A[i].second = i + 1;
    }
    cout << "First" << endl;
    if (is_ap(A)){
    	do_ap(A);
    	return;
    }

    query(1);
    if (is_ap(A)){
    	do_ap(A);
    	return;
    }

    int id = get_pos();
    if (id != 1){
    	if (id == 0){
    		query(A[2].first - A[1].first);
    		query(A[1].first - A[0].first);
    	}
    	else{
    		query(A[1].first - A[0].first);
    	}
    	id = get_pos();

    }

    assert(id == 1 || done());

    ll x = A[1].first - A[0].first, y = A[2].first - A[1].first;

    while( !is_ap(A) && last_output != 0 && x < y && !done()){
    	id = get_pos();
    	assert(id == 1);
    	query(x);
    	id = get_pos();
    	assert(id == 2);
    	query(x);

    	x *= 2;
    	assert( x == A[1].first - A[0].first);
    }

    query(x - y);
    assert(is_ap(A));
    do_ap(A);
}
int main(){
    // Use "set_name".max_load_factor(0.25);"set_name".reserve(512); with unordered set
    // Or use gp_hash_table<X,null_type>
    ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
    cout<<fixed<<setprecision(25);
    cerr<<fixed<<setprecision(10);
    auto start = std::chrono::high_resolution_clock::now();
    int t=1;
    // cin>>t;
    while(t--) {
        solve();
    }
    auto stop = std::chrono::high_resolution_clock::now();
    auto duration = std::chrono::duration_cast<std::chrono::nanoseconds>(stop - start);

    // cerr << "Time taken : " << ((long double)duration.count())/((long double) 1e9) <<"s "<< endl;
}


/*/ Author: kal013 /*/
// #pragma GCC optimize ("O3")
#include "bits/stdc++.h"
#include "ext/pb_ds/assoc_container.hpp"
#include "ext/pb_ds/tree_policy.hpp"
using namespace std;
using namespace __gnu_pbds;

template<class T>
using ordered_set = tree<T, null_type,less<T>, rb_tree_tag,tree_order_statistics_node_update> ;

template<class key, class value, class cmp = std::less<key>>
using ordered_map = tree<key, value, cmp, rb_tree_tag, tree_order_statistics_node_update>;
// find_by_order(k)  returns iterator to kth element starting from 0;
// order_of_key(k) returns count of elements strictly smaller than k;

struct custom_hash { // Credits: https://codeforces.com/blog/entry/62393
    static uint64_t splitmix64(uint64_t x) {
        // http://xorshift.di.unimi.it/splitmix64.c
        x += 0x9e3779b97f4a7c15;
        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
        return x ^ (x >> 31);
    }

    size_t operator()(uint64_t x) const {
        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
        return splitmix64(x + FIXED_RANDOM);
    }
    size_t operator()(pair<int64_t,int64_t> Y) const{
        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
        return splitmix64(Y.first * 31 + Y.second + FIXED_RANDOM);
    }
};

template<class T> ostream& operator<<(ostream &os, vector<T> V) {
    os << "[ ";
    for(auto v : V) os << v << " ";
    return os << "]";
}
template<class T> ostream& operator<<(ostream &os, set<T> S){
    os << "{ ";
    for(auto s:S) os<<s<<" ";
    return os<<"}";
}
template<class T> ostream& operator<<(ostream &os, unordered_set<T> S){
    os << "{ ";
    for(auto s:S) os<<s<<" ";
    return os<<"}";
}
template<class T> ostream& operator << (ostream& os, multiset<T> S){
    os << "{ ";
    for(auto s:S) os<<s<<" ";
    return os<<"}";
}
template<class T> ostream& operator<<(ostream &os, ordered_set<T> S){
    os << "{ ";
    for(auto s:S) os<<s<<" ";
    return os<<"}";
}
template<class L, class R> ostream& operator<<(ostream &os, pair<L,R> P) {
    return os << "(" << P.first << "," << P.second << ")";
}
template<class L, class R> ostream& operator<<(ostream &os, map<L,R> M) {
    os << "{ ";
    for(auto m:M) os<<"("<<m.first<<":"<<m.second<<") ";
    return os<<"}";
}
template<class L, class R, class chash = std::hash<R>> ostream& operator<<(ostream &os, unordered_map<L,R,chash> M) {
    os << "{ ";
    for(auto m:M) os<<"("<<m.first<<":"<<m.second<<") ";
    return os<<"}";
}
template<class L, class R, class chash = std::hash<R> > ostream& operator<<(ostream &os, gp_hash_table<L,R,chash> M) {
    os << "{ ";
    for(auto m:M) os<<"("<<m.first<<":"<<m.second<<") ";
    return os<<"}";
}

#define TRACE
#ifdef TRACE
    #define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
    template <typename Arg1>
    void __f(const char* name, Arg1&& arg1){
        cerr << name << " : " << arg1 << endl;
    }
    template <typename Arg1, typename... Args>
    void __f(const char* names, Arg1&& arg1, Args&&... args){
        const char* comma = strchr(names + 1, ',');
        cerr.write(names, comma - names) << " : " << arg1<<" | ";
        __f(comma+1, args...);
    }
#else
    #define trace(...) 1
#endif

mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());

inline int64_t random_long(long long l,long long r){
    uniform_int_distribution<int64_t> generator(l,r);
    return generator(rng);
}
inline int64_t random_long(){
    uniform_int_distribution<int64_t> generator(LLONG_MIN,LLONG_MAX);
    return generator(rng);
}

/*/---------------------------Defines----------------------/*/
typedef vector<int> vi;
typedef pair<int,int> pii;

#define ll long long
#define F first
#define S second
#define pb push_back
#define all(v) (v).begin(),(v).end()
/*/-----------------------Modular Arithmetic---------------/*/

const int mod=1e9+7;
inline int add(int x,int y){
    x+=y;
    if (x>=mod) return x-mod;
    return x;
}
inline int sub(int x,int y){
    x-=y;
    if (x<0) return x+mod;
    return x;
}
inline int mul(int x,int y){
    return (x*1ll*y)%mod;
}
inline int power(int x,int y){
    int ans=1;
    while(y){
        if (y&1) ans=mul(ans,x);
        x=mul(x,x);
        y>>=1;
    }
    return ans;
}
inline int inv(int x){
    return power(x,mod-2);
}
/*/-----------------------------Code begins----------------------------------/*/

vector<pair<ll,ll> > A;

bool done(){
	if (A[0].first == A[1].first) exit(0);
	if (A[1].first == A[2].first) exit(0);
	if (A[2].first == A[0].first) exit(0);
	return false;
	// return ((A[0].first == A[1].first)  || (A[1].first == A[2].first));
}
bool is_ap(vector<pair<ll,ll> > & A){
	sort(all(A));

	return (A[1].first - A[0].first == A[2].first - A[1].first);
}

int last_output;

void query(ll x){
	done();
	if (last_output == 0){
		exit(0);
		return;
	}

	cout << x << endl;

	cin >> last_output;

	if (last_output == -1){
		exit(0);
	}
	if (last_output == 0) {
		exit(0);
		return;
	}
	for(int i = 0 ; i < 3; ++i){
		if (A[i].second == last_output ){
			A[i].first += x;
		}
	}

	sort(all(A));

	// trace(A);
}
void do_ap(vector<pair<ll,ll> > & A){
	if (last_output == 0){
		return;
	}
	// assert(is_ap(A));
	sort(all(A));
	ll d= A[1].first - A[0].first;

	// assert( d > 0);
	query(d);
	query(3*d);
	query(d);
	query(d);
	query(2*d);
	done();
	exit(0);
	// assert(done() || last_output == 0);
}

int get_pos(){
	sort(all(A));
	for(int i = 0 ; i < 3; ++i){
		if (A[i].second == last_output){
			return i;
		}
	}
	done();
	// assert(false);
}
void solve(){
    last_output = 4;
    A.resize(3);
    for(int i = 0 ; i < 3; ++i){
    	cin >> A[i].first;
    	A[i].second = i + 1;
    }
    sort(all(A));
    cout << "First" << endl;

    if (is_ap(A)){
    	do_ap(A);
    	return;
    }

    query(1);
    if (is_ap(A)){
    	do_ap(A);
    	return;
    }

    int id = get_pos();
    if (id != 1){
    	if (id == 0){
    		query(A[2].first - A[1].first);
    		query(A[1].first - A[0].first);
    	}
    	else{
    		query(A[1].first - A[0].first);
    	}
    	id = get_pos();

    }
    done();
    // assert(id == 1 || done());

    ll x = A[1].first - A[0].first, y = A[2].first - A[1].first;

    while( !is_ap(A) && last_output != 0 && x < y && !done()){
    	id = get_pos();
    	done();
    	// assert(id == 1 || done());
    	query(x);
    	done();
    	id = get_pos();
    	// assert(id == 2);
    	query(x);

    	x *= 2;
    	// assert( x == A[1].first - A[0].first);
    }
	if (x > y){
    	query(x - y);

    }
    // assert(is_ap(A));
    do_ap(A);
}
int main(){
    // Use "set_name".max_load_factor(0.25);"set_name".reserve(512); with unordered set
    // Or use gp_hash_table<X,null_type>
    ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
    cout<<fixed<<setprecision(25);
    cerr<<fixed<<setprecision(10);
    auto start = std::chrono::high_resolution_clock::now();
    int t=1;
    // cin>>t;
    while(t--) {
        solve();
    }
    auto stop = std::chrono::high_resolution_clock::now();
    auto duration = std::chrono::duration_cast<std::chrono::nanoseconds>(stop - start);

    // cerr << "Time taken : " << ((long double)duration.count())/((long double) 1e9) <<"s "<< endl;
}


/*/ Author: kal013 /*/
// #pragma GCC optimize ("O3")
#include "bits/stdc++.h"
#include "ext/pb_ds/assoc_container.hpp"
#include "ext/pb_ds/tree_policy.hpp"
using namespace std;
using namespace __gnu_pbds;

template<class T>
using ordered_set = tree<T, null_type,less<T>, rb_tree_tag,tree_order_statistics_node_update> ;

template<class key, class value, class cmp = std::less<key>>
using ordered_map = tree<key, value, cmp, rb_tree_tag, tree_order_statistics_node_update>;
// find_by_order(k)  returns iterator to kth element starting from 0;
// order_of_key(k) returns count of elements strictly smaller than k;

struct custom_hash { // Credits: https://codeforces.com/blog/entry/62393
    static uint64_t splitmix64(uint64_t x) {
        // http://xorshift.di.unimi.it/splitmix64.c
        x += 0x9e3779b97f4a7c15;
        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
        return x ^ (x >> 31);
    }

    size_t operator()(uint64_t x) const {
        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
        return splitmix64(x + FIXED_RANDOM);
    }
    size_t operator()(pair<int64_t,int64_t> Y) const{
        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
        return splitmix64(Y.first * 31 + Y.second + FIXED_RANDOM);
    }
};

template<class T> ostream& operator<<(ostream &os, vector<T> V) {
    os << "[ ";
    for(auto v : V) os << v << " ";
    return os << "]";
}
template<class T> ostream& operator<<(ostream &os, set<T> S){
    os << "{ ";
    for(auto s:S) os<<s<<" ";
    return os<<"}";
}
template<class T> ostream& operator<<(ostream &os, unordered_set<T> S){
    os << "{ ";
    for(auto s:S) os<<s<<" ";
    return os<<"}";
}
template<class T> ostream& operator << (ostream& os, multiset<T> S){
    os << "{ ";
    for(auto s:S) os<<s<<" ";
    return os<<"}";
}
template<class T> ostream& operator<<(ostream &os, ordered_set<T> S){
    os << "{ ";
    for(auto s:S) os<<s<<" ";
    return os<<"}";
}
template<class L, class R> ostream& operator<<(ostream &os, pair<L,R> P) {
    return os << "(" << P.first << "," << P.second << ")";
}
template<class L, class R> ostream& operator<<(ostream &os, map<L,R> M) {
    os << "{ ";
    for(auto m:M) os<<"("<<m.first<<":"<<m.second<<") ";
    return os<<"}";
}
template<class L, class R, class chash = std::hash<R>> ostream& operator<<(ostream &os, unordered_map<L,R,chash> M) {
    os << "{ ";
    for(auto m:M) os<<"("<<m.first<<":"<<m.second<<") ";
    return os<<"}";
}
template<class L, class R, class chash = std::hash<R> > ostream& operator<<(ostream &os, gp_hash_table<L,R,chash> M) {
    os << "{ ";
    for(auto m:M) os<<"("<<m.first<<":"<<m.second<<") ";
    return os<<"}";
}

#define TRACE
#ifdef TRACE
    #define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
    template <typename Arg1>
    void __f(const char* name, Arg1&& arg1){
        cerr << name << " : " << arg1 << endl;
    }
    template <typename Arg1, typename... Args>
    void __f(const char* names, Arg1&& arg1, Args&&... args){
        const char* comma = strchr(names + 1, ',');
        cerr.write(names, comma - names) << " : " << arg1<<" | ";
        __f(comma+1, args...);
    }
#else
    #define trace(...) 1
#endif

mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());

inline int64_t random_long(long long l,long long r){
    uniform_int_distribution<int64_t> generator(l,r);
    return generator(rng);
}
inline int64_t random_long(){
    uniform_int_distribution<int64_t> generator(LLONG_MIN,LLONG_MAX);
    return generator(rng);
}

/*/---------------------------Defines----------------------/*/
typedef vector<int> vi;
typedef pair<int,int> pii;

#define ll long long
#define F first
#define S second
#define pb push_back
#define all(v) (v).begin(),(v).end()
/*/-----------------------Modular Arithmetic---------------/*/

const int mod=1e9+7;
inline int add(int x,int y){
    x+=y;
    if (x>=mod) return x-mod;
    return x;
}
inline int sub(int x,int y){
    x-=y;
    if (x<0) return x+mod;
    return x;
}
inline int mul(int x,int y){
    return (x*1ll*y)%mod;
}
inline int power(int x,int y){
    int ans=1;
    while(y){
        if (y&1) ans=mul(ans,x);
        x=mul(x,x);
        y>>=1;
    }
    return ans;
}
inline int inv(int x){
    return power(x,mod-2);
}
/*/-----------------------------Code begins----------------------------------/*/

vector<pair<ll,ll> > A;

bool done(){
	if (A[0].first == A[1].first) exit(0);
	if (A[1].first == A[2].first) exit(0);
	if (A[2].first == A[0].first) exit(0);
	return false;
	// return ((A[0].first == A[1].first)  || (A[1].first == A[2].first));
}
bool is_ap(vector<pair<ll,ll> > & A){
	sort(all(A));

	return (A[1].first - A[0].first == A[2].first - A[1].first);
}

int last_output;

void query(ll x){
	done();
	if (last_output == 0){
		exit(0);
		return;
	}

	cout << x << endl;

	cin >> last_output;

	if (last_output == -1){
		exit(0);
	}
	if (last_output == 0) {
		exit(0);
		return;
	}
	for(int i = 0 ; i < 3; ++i){
		if (A[i].second == last_output ){
			A[i].first += x;
		}
	}

	sort(all(A));

	// trace(A);
}
void do_ap(vector<pair<ll,ll> > & A){
	if (last_output == 0){
		return;
	}
	// assert(is_ap(A));
	sort(all(A));
	ll d= A[1].first - A[0].first;

	// assert( d > 0);
	query(d);
	query(3*d);
	query(d);
	query(d);
	query(2*d);
	done();
	exit(0);
	// assert(done() || last_output == 0);
}

int get_pos(){
	sort(all(A));
	for(int i = 0 ; i < 3; ++i){
		if (A[i].second == last_output){
			return i;
		}
	}
	done();
	// assert(false);
}
void solve(){
    last_output = 4;
    A.resize(3);
    for(int i = 0 ; i < 3; ++i){
    	cin >> A[i].first;
    	A[i].second = i + 1;
    }
    sort(all(A));
    cout << "First" << endl;

    if (is_ap(A)){
    	do_ap(A);
    	return;
    }

    query(1);
    if (is_ap(A)){
    	do_ap(A);
    	return;
    }

    int id = get_pos();
    if (id != 1){
    	if (id == 0){
    		query(A[2].first - A[1].first);
    		query(A[1].first - A[0].first);
    	}
    	else{
    		query(A[1].first - A[0].first);
    	}
    	id = get_pos();

    }
    done();
    assert(id == 1 || done());

    ll x = A[1].first - A[0].first, y = A[2].first - A[1].first;

    while( !is_ap(A) && last_output != 0 && x < y && !done()){
    	id = get_pos();
    	done();
    	assert(id == 1 || done());
    	query(x);
    	done();
    	id = get_pos();
    	assert(id == 2);
    	query(x);

    	x *= 2;
    	// assert( x == A[1].first - A[0].first);
    }
	if (x > y){
    	query(x - y);

    }
    // assert(is_ap(A));
    do_ap(A);
}
int main(){
    // Use "set_name".max_load_factor(0.25);"set_name".reserve(512); with unordered set
    // Or use gp_hash_table<X,null_type>
    ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
    cout<<fixed<<setprecision(25);
    cerr<<fixed<<setprecision(10);
    auto start = std::chrono::high_resolution_clock::now();
    int t=1;
    // cin>>t;
    while(t--) {
        solve();
    }
    auto stop = std::chrono::high_resolution_clock::now();
    auto duration = std::chrono::duration_cast<std::chrono::nanoseconds>(stop - start);

    // cerr << "Time taken : " << ((long double)duration.count())/((long double) 1e9) <<"s "<< endl;
}


// b and c, unless it will result in a equal diff. then swap a
// bcac or babc

/*
Author : Xinyuan
*/
#include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < n; i++)
#define all(x) (x).begin(), (x).end()
typedef pair<int, int> PII;
typedef vector<int> VI;
typedef vector<string> VS;
typedef vector<PII> VII;
typedef vector<VI> VVI;
typedef long long int ll;
const int INF = 1e9 + 7;
const int mod = 1e9 + 7;
ll powmod(ll a, ll b) {
    ll res = 1;
    a %= mod;
    assert(b >= 0);
    for (; b; b >>= 1) {
        if (b & 1) res = res * a % mod;
        a = a * a % mod;
    }
    return res;
}
int nxt() {
    int x;
    scanf("%d", &x);
    return x;
}

ll diff(ll a, ll b) {
    return abs(a - b);
}

int main() {
    ll a, b, c;
    scanf("%lld%lld%lld", &a, &b, &c);
    printf("Second\n\n");
    fflush(stdout);
    ll input;
    int prev = -1;
    while (scanf("%lld", &input)) {
        if (input == -1 || input == 0) break;
        int option = (prev + 1) % 3;
        int ta = a;
        int tb = b;
        int tc = c;
        if (option == 0) ta += input;
        if (option == 1) tb += input;
        if (option == 2) tc += input;
        if (ta == tb || ta == tc || tb == tc || diff(ta, tb) == diff(tb, tc) || diff(ta, tc) == diff(tb, tc) || diff(ta, tb) == diff(ta, tc)) option = (option + 1) % 3;
        if (option == 0) a += input;
        if (option == 1) b += input;
        if (option == 2) c += input;
        printf("%d\n\n", option + 1);
        // printf("%lld %lld %lld\n", a, b, c);
        fflush(stdout);
        prev = option;
    }
    return 0;
}


// b and c, unless it will result in a equal diff. then swap a
// bcac or babc

/*
Author : Xinyuan
*/
#include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < n; i++)
#define all(x) (x).begin(), (x).end()
typedef pair<int, int> PII;
typedef vector<int> VI;
typedef vector<string> VS;
typedef vector<PII> VII;
typedef vector<VI> VVI;
typedef long long int ll;
const int INF = 1e9 + 7;
const int mod = 1e9 + 7;
ll powmod(ll a, ll b) {
    ll res = 1;
    a %= mod;
    assert(b >= 0);
    for (; b; b >>= 1) {
        if (b & 1) res = res * a % mod;
        a = a * a % mod;
    }
    return res;
}
int nxt() {
    int x;
    scanf("%d", &x);
    return x;
}

ll diff(ll a, ll b) {
    return abs(a - b);
}

bool maybe(ll a, ll b, ll c) {
    ll d[3] = {a, b, c};
    sort(d, d + 3);
    if (d[1] - d[0] == 2 * (d[2] - d[1]) || 2 * (d[1] - d[0]) == d[2] - d[1]) return true;
    return false;
}

int main() {
    ll a, b, c;
    scanf("%lld%lld%lld", &a, &b, &c);
    printf("Second\n\n");
    fflush(stdout);
    ll input;
    int prev = -5;
    REP(_, 1005) {
        scanf("%lld", &input);
        if (input == -1 || input == 0) break;
        int option = (prev + 1) % 3;
        ll ta = a;
        ll tb = b;
        ll tc = c;
        if (prev == -5) {
            if (a > b && a > c)
                option = 0;
            else if (b > a && b > c)
                option = 1;
            else
                option = 2;
        }
        if (option == 0) ta += input;
        if (option == 1) tb += input;
        if (option == 2) tc += input;
        if (ta == tb || ta == tc || tb == tc || diff(ta, tb) == diff(tb, tc) || diff(ta, tc) == diff(tb, tc) || diff(ta, tb) == diff(ta, tc) || maybe(ta, tb, tc)) option = (option + 1) % 3;
        // printf("%lld %lld %lld\n", ta, tb, tc);
        if (option == 0) a += input;
        if (option == 1) b += input;
        if (option == 2) c += input;
        printf("%d\n\n", option + 1);
        // printf("%lld %lld %lld\n", a, b, c);
        fflush(stdout);
        prev = option;
    }
    return 0;
}