import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Stack;
import java.util.Vector;

/**
 * @author mostafaizz
 *
 */
public class Main{

    /**
     * @param args
     */
    public static void main(String[] args) {
        try {
               java.io.BufferedReader stdin = new java.io.BufferedReader(new java.io.InputStreamReader(System.in));
    String []res = {"First","Second"};
               String []s = stdin.readLine().trim().split("[ ]+");
            // get the rest of inputs
               int a = Integer.parseInt(s[0]);
               int b = Integer.parseInt(s[1]);
               int r = Integer.parseInt(s[2]);
               if(2*r <= a && 2*r <= b)
               {
                   System.out.println(res[0]);
               }
               else
               {
                   System.out.println(res[1]);
               }
        }
          catch (java.io.IOException e) { System.out.println(e);}
          catch (NumberFormatException e) { System.out.println(e);}
    }
}

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

public class Main197A
{
  static PrintWriter out=new PrintWriter(System.out);

  public static void main(String[] args) throws IOException
  {
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int r=sc.nextInt();
    if(2*r>a||2*r>b) out.println("Second");
    else
    {
      out.println("First");
    }
    out.flush();

  }
  static class Scanner
  {
    BufferedReader br;
    StringTokenizer tk=new StringTokenizer("");
    public Scanner(InputStream is)
        {
      br=new BufferedReader(new InputStreamReader(is));
    }
        public int nextInt() throws IOException
        {
          if(tk.hasMoreTokens())
                return Integer.parseInt(tk.nextToken());
          tk=new StringTokenizer(br.readLine());
          return nextInt();
        }
        public long nextLong() throws IOException
        {
            if(tk.hasMoreTokens())
              return Long.parseLong(tk.nextToken());
            tk=new StringTokenizer(br.readLine());
            return nextLong();
        }
        public String next() throws IOException
        {
          if(tk.hasMoreTokens())
            return (tk.nextToken());
            tk=new StringTokenizer(br.readLine());
            return next();
        }
        public String nextLine() throws IOException
        {
          tk=new StringTokenizer("");
          return br.readLine();
        }
        public double nextDouble() throws IOException
        {
            if(tk.hasMoreTokens())
              return Double.parseDouble(tk.nextToken());
            tk=new StringTokenizer(br.readLine());
            return nextDouble();
        }
        public char nextChar() throws IOException
        {
            if(tk.hasMoreTokens())
              return (tk.nextToken().charAt(0));
            tk=new StringTokenizer(br.readLine());
            return nextChar();
        }
        public int[] nextIntArray(int n) throws IOException
        {
            int a[]=new int[n];
            for(int i=0;i<n;i++)
              a[i]=nextInt();
            return a;
        }
        public long[] nextLongArray(int n) throws IOException
        {
          long a[]=new long[n];
            for(int i=0;i<n;i++)
              a[i]=nextLong();
            return a;
        }
        public int[] nextIntArrayOneBased(int n) throws IOException
        {
          int a[]=new int[n+1];
            for(int i=1;i<=n;i++)
              a[i]=nextInt();
            return a;
        }
        public long[] nextLongArrayOneBased(int n) throws IOException
        {
          long a[]=new long[n+1];
          for(int i=1;i<=n;i++)
                a[i]=nextLong();
          return a;
        }
  }
}

import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.io.UnsupportedEncodingException;
import java.util.*;

/**
 * Created by tdph5945 on 2016-07-24.
 */
public class Main {
    public static void main(String... args) throws Exception {
        Scanner scanner = new Scanner(System.in);
        int a = scanner.nextInt();
        int b = scanner.nextInt();
        int r = scanner.nextInt();

        if(2 * r > Math.min(a, b)){
            System.out.println("Second");
        }
        else{
            System.out.println("First");
        }
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Scanner;

public class Worms_Evolution {

	public static void main(String[] args) throws NumberFormatException, IOException {
		// TODO Auto-generated method stub
		Scanner scn = new Scanner(System.in);
		int l=scn.nextInt();
		int b=scn.nextInt();
		int r=scn.nextInt();

		if(2*r<=l && 2*r<=b){
			System.out.println("First");
		}
		else{
			System.out.println("Second");
		}
	}
}

import java.io.*;
import static java.lang.Math.*;
import java.util.*;
import java.util.function.*;
import java.lang.*;

public class Main {
    final static boolean debug = false;
    final static String fileName = "";
    final static boolean useFiles = false;

    public static void main(String[] args) throws FileNotFoundException {
        long start;
        if (debug)
            start = System.nanoTime();
        InputStream inputStream;
        OutputStream outputStream;
        if (useFiles) {
            inputStream = new FileInputStream(fileName + ".in");
            outputStream = new FileOutputStream(fileName + ".out");
        } else {
            inputStream = System.in;
            outputStream = System.out;
        }
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        Task solver = new Task(in, out);
        solver.solve();
        if(debug)
            out.println((System.nanoTime() - start) / 1e+9);
        out.close();
    }
}

class InputReader {
    public BufferedReader reader;
    public StringTokenizer tokenizer;

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

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

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

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

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

    public byte nextByte(){
        return Byte.parseByte(next());
    }
}

class Task {
    public void solve() {
        int a = in.nextInt();
        int b = in.nextInt();
        int r = in.nextInt();
        out.println(a >= 2 * r && b >= 2 * r ? "First" : "Second");
    }

    private InputReader in;
    private PrintWriter out;

    Task(InputReader in, PrintWriter out) {
        this.in = in;
        this.out = out;
    }
}

import java.util.*;
import java.lang.Math;
import java.util.Arrays;
import java.util.Scanner;
import java.util.stream.IntStream;
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
 /*
        ██╗███╗   ███╗███████╗██╗  ██╗██╗██╗   ██╗ █████╗ ███╗   ███╗██████╗ ██╗    ██╗██╗██╗   ██╗███████╗██████╗ ██╗
        ██║████╗ ████║██╔════╝██║  ██║██║██║   ██║██╔══██╗████╗ ████║██╔══██╗██║    ██║██║██║   ██║██╔════╝██╔══██╗██║
        ██║██╔████╔██║███████╗███████║██║██║   ██║███████║██╔████╔██║██║  ██║██║ █╗ ██║██║██║   ██║█████╗  ██║  ██║██║
        ██║██║╚██╔╝██║╚════██║██╔══██║██║╚██╗ ██╔╝██╔══██║██║╚██╔╝██║██║  ██║██║███╗██║██║╚██╗ ██╔╝██╔══╝  ██║  ██║██║
        ██║██║ ╚═╝ ██║███████║██║  ██║██║ ╚████╔╝ ██║  ██║██║ ╚═╝ ██║██████╔╝╚███╔███╔╝██║ ╚████╔╝ ███████╗██████╔╝██║
        ╚═╝╚═╝     ╚═╝╚══════╝╚═╝  ╚═╝╚═╝  ╚═══╝  ╚═╝  ╚═╝╚═╝     ╚═╝╚═════╝  ╚══╝╚══╝ ╚═╝  ╚═══╝  ╚══════╝╚═════╝ ╚═╝
*/

public class Solution {
   	public static void main(String[] args) {
	   InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        Scanner in = new Scanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
	}

	static class TaskA {
        public void solve(int testNumber, Scanner in, PrintWriter out) {
          int a = in.nextInt();
          int b = in.nextInt();
          int r = in.nextInt();
          if(2*r>Math.min(a,b)){
              out.print("Second");}
          else{
               out.print("First");
          }
	   }
	}
}

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.util.HashMap;
import java.util.Arrays;
 public class Primes4{

    static class FastScanner{
        BufferedReader s;
        StringTokenizer st;

        public FastScanner(){
            st = new StringTokenizer("");
            s = new BufferedReader(new InputStreamReader(System.in));

        }

        public FastScanner(File f) throws FileNotFoundException{
            st = new StringTokenizer("");
            s = new BufferedReader (new FileReader(f));
        }

        public int nextInt() throws IOException{
            if(st.hasMoreTokens())
                return Integer.parseInt(st.nextToken());
            else{
                st = new StringTokenizer(s.readLine());
                return nextInt();
            }
        }

        public double nextDouble() throws IOException{
            if(st.hasMoreTokens())
                return Double.parseDouble(st.nextToken());
            else{
                st = new StringTokenizer(s.readLine());
                return nextDouble();
            }
        }

        public long nextLong() throws IOException{
            if(st.hasMoreTokens())
                return Long.parseLong(st.nextToken());
            else{
                st = new StringTokenizer(s.readLine());
                return nextLong();
            }
        }

        public String nextString() throws IOException{
            if(st.hasMoreTokens())
                return st.nextToken();
            else{
                st = new StringTokenizer(s.readLine());
                return nextString();
            }

        }

        public String readLine() throws IOException{
            return s.readLine();
        }

        public void close() throws IOException{
            s.close();
        }

    }      //Fastscanner class end

   static FastScanner in=new FastScanner();
   static PrintWriter ww=new PrintWriter(new OutputStreamWriter(System.out));
   public static void main(String args[])throws IOException
   {
   //Main ob=new Main();
   Primes4 ob=new Primes4();
   ob.solve();
   ww.close();
   }

   public void solve()throws IOException
   {
    int a= in.nextInt();
	int b = in.nextInt();
	int r = in.nextInt();
	int m1 = 2*r;
	int m2= Math.min(a,b);
	if(m1<=m2)
	     System.out.println("First");
	else
        System.out.println("Second");

   }
 }

import java.util.Scanner;

public class PlateGame {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int a = in.nextInt();
        int b = in.nextInt();
        int r = in.nextInt();
        if (Math.min(a, b) < 2 * r) {
            System.out.println("Second");
        } else {
            System.out.println("First");
        }
    }
}

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

public class Test {
	static BufferedReader reader;
	static StringTokenizer tokenizer;
	static PrintWriter writer;

	static int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	static long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}

	static double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}

	static String nextToken() throws IOException {
		while (tokenizer == null || !tokenizer.hasMoreTokens()) {
			tokenizer = new StringTokenizer(reader.readLine());
		}
		return tokenizer.nextToken();
	}
	static String nexts() throws IOException {
	  	  tokenizer = new StringTokenizer(reader.readLine());
	   	 String s="";
	   	 while (tokenizer.hasMoreTokens()) {
			s+=tokenizer.nextElement()+" ";
		}
		return s;
	}

	//String str=nextToken();
	//String[] s = str.split("\\s+");

	public static int gcd(int x, int y){
		if (y == 0) return x; else return gcd(y, x % y);
	}

	public static boolean isPrime(int n)
	    {
	        // Corner cases
	        if (n <= 1){
		 return false; }
	        if (n <= 3){
		 return true; }

	        // This is checked so that we can skip
	        // middle five numbers in below loop
	        if (n % 2 == 0 || n % 3 == 0){
		 return false; }

	        for (int i = 5; i * i <= n; i = i + 6) {    //Checking 6i+1 & 6i-1
	            if (n % i == 0 || n % (i + 2) == 0) {
	            	return false;  }
	            }
			//O(sqrt(n))
	        return true;
	    }

	 static class R implements Comparable<R>{
	        int x, y;
	        public  R(int x, int y) {
	            this.x = x;
	            this.y = y;
	        }
	        public int compareTo(R o) {
            		return x-o.x;     //Increasing order(Which is usually required)
        		}
	    }

	public static void main(String[] args) throws IOException {
		reader = new BufferedReader(new InputStreamReader(System.in));
		tokenizer = null;
		writer = new PrintWriter(System.out);
		solve();
		reader.close();
		writer.close();
	}

	private static void solve() throws IOException {
		int a = nextInt();
		int b = nextInt();
		int r = nextInt();
		r=2*r;
		if(r<=a&&r<=b){
		    writer.println("First");
		}
		else{
		    writer.println("Second");
		}

	}
}

import java.util.Scanner;

public class Plate_Game {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

	Scanner in=new Scanner(System.in);
	int a=in.nextInt();
	int b=in.nextInt();
	int r=in.nextInt();
	  System.out.println(2 * r <= a && 2 * r <= b ? "First" : "Second");
	}
}

import java.util.*;
import java.io.*;
import java.math.*;
public class Main
{
    static class Reader
    {
        private InputStream mIs;private byte[] buf = new byte[1024];private int curChar,numChars;public Reader() { this(System.in); }public Reader(InputStream is) { mIs = is;}
        public int read() {if (numChars == -1) throw new InputMismatchException();if (curChar >= numChars) {curChar = 0;try { numChars = mIs.read(buf);} catch (IOException e) { throw new InputMismatchException();}if (numChars <= 0) return -1; }return buf[curChar++];}
        public String nextLine(){int c = read();while (isSpaceChar(c)) c = read();StringBuilder res = new StringBuilder();do {res.appendCodePoint(c);c = read();}while (!isEndOfLine(c));return res.toString() ;}
        public String s(){int c = read();while (isSpaceChar(c)) c = read();StringBuilder res = new StringBuilder();do {res.appendCodePoint(c);c = read();}while (!isSpaceChar(c));return res.toString();}
        public long l(){int c = read();while (isSpaceChar(c)) c = read();int sgn = 1;if (c == '-') { sgn = -1 ; c = read() ; }long res = 0; do{ if (c < '0' || c > '9') throw new InputMismatchException();res *= 10 ; res += c - '0' ; c = read();}while(!isSpaceChar(c));return res * sgn;}
        public int i(){int c = read() ;while (isSpaceChar(c)) c = read();int sgn = 1;if (c == '-') { sgn = -1 ; c = read() ; }int res = 0;do{if (c < '0' || c > '9') throw new InputMismatchException();res *= 10 ; res += c - '0' ; c = read() ;}while(!isSpaceChar(c));return res * sgn;}
        public double d() throws IOException {return Double.parseDouble(s()) ;}
        public boolean isSpaceChar(int c) { return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1; }
        public boolean isEndOfLine(int c) { return c == '\n' || c == '\r' || c == -1; }
    }

    ///////////////////////////////////////////////////////////////////////////////////////////
    //    RRRRRRRRR            AAA             HHH     HHH     IIIIIIIIIIIII   LLL           //
    //    RR    RRR           AAAAA            HHH     HHH      IIIIIIIIIII    LLL           //
    //    RR   RRR           AAAAAAA           HHH     HHH          III        LLL           //
    //    RR  RRR           AAA   AAA          HHHHHHHHHHH          III        LLL           //
    //    RRRRRR           AAA     AAA         HHHHHHHHHHH          III        LLL           //
    //    RR  RRR         AAAAAAAAAAAAA        HHH     HHH          III        LLL           //
    //    RR    RRR      AAA         AAA       HHH     HHH      IIIIIIIIIII    LLLLLLLLLLLL  //
    //    RR     RRR    AAA           AAA      HHH     HHH     IIIIIIIIIIIII   LLLLLLLLLLLL  //
    ///////////////////////////////////////////////////////////////////////////////////////////

    public static void main(String[] args)throws IOException
    {
        PrintWriter out= new PrintWriter(System.out);
        Reader sc=new Reader();
        int n=sc.i();
        int m=sc.i();
        int r=sc.i();
        if(2*r>Math.min(n,m))
        out.println("Second");
        else
        out.println("First");
        out.flush();
    }
}

//package que_a;

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

public class utkarsh {

    InputStream is;
    PrintWriter out;

    long mod = (long) (1e9 + 7), inf = (long) (3e18);

    void solve() {
        out.println( Math.min(ni(), ni()) >= 2 * ni() ? "First" : "Second" );
    }

    long mp(long b, long e) {
        long r = 1;
        while(e > 0) {
            if((e&1) == 1)  r = (r * b) % mod;
            b = (b * b) % mod;
            e >>= 1;
        }
        return r;
    }

    //---------- I/O Template ----------

    public static void main(String[] args) { new utkarsh().run(); }
    void run() {
        is = System.in;
        out = new PrintWriter(System.out);
        solve();
        out.flush();
    }

    byte input[] = new byte[1024];
    int len = 0, ptr = 0;

    int readByte() {
        if(ptr >= len) { ptr = 0;
            try { len = is.read(input); }
            catch(IOException e) { throw new InputMismatchException(); }
            if(len <= 0) { return -1; }
        } return input[ptr++];
    }
    boolean isSpaceChar(int c) { return !( c >= 33 && c <= 126 ); }
    int skip() {
        int b = readByte();
        while(b != -1 && isSpaceChar(b)) { b = readByte(); }
        return b;
    }

    char nc() { return (char)skip(); }
    String ns() {
        int b = skip();
        StringBuilder sb = new StringBuilder();
        while(!isSpaceChar(b)) { sb.appendCodePoint(b); b = readByte(); }
        return sb.toString();
    }
    String nLine() {
        int b = skip();
        StringBuilder sb = new StringBuilder();
        while( !(isSpaceChar(b) && b != ' ') ) { sb.appendCodePoint(b); b = readByte(); }
        return sb.toString();
    }
    int ni() {
        int n = 0, b = readByte();
        boolean minus = false;
        while(b != -1 && !( (b >= '0' && b <= '9') || b == '-')) { b = readByte(); }
        if(b == '-') { minus = true; b = readByte(); }
        if(b == -1) { return -1; }  //no input
        while(b >= '0' && b <= '9') { n = n * 10 + (b - '0'); b = readByte(); }
        return minus ? -n : n;
    }
    long nl() {
        long n = 0L;    int b = readByte();
        boolean minus = false;
        while(b != -1 && !( (b >= '0' && b <= '9') || b == '-')) { b = readByte(); }
        if(b == '-') { minus = true; b = readByte(); }
        while(b >= '0' && b <= '9') { n = n * 10 + (b - '0'); b = readByte(); }
        return minus ? -n : n;
    }

    double nd() { return Double.parseDouble(ns()); }
    float nf() { return Float.parseFloat(ns()); }
    int[] na(int n) {
        int a[] = new int[n];
        for(int i = 0; i < n; i++) { a[i] = ni(); }
        return a;
    }
    char[] ns(int n) {
        char c[] = new char[n];
        int i, b = skip();
        for(i = 0; i < n; i++) {
            if(isSpaceChar(b)) { break; }
            c[i] = (char)b; b = readByte();
        } return i == n ? c : Arrays.copyOf(c,i);
    }
}

//package Omar;

import java.util.Scanner;

public class PlateGame {
    public static void main(String...args) {
        Scanner input = new Scanner(System.in);
        int width = input.nextInt(), height = input.nextInt(), radius = input.nextInt();
        if (radius * 2 <= width && radius * 2 <= height) {
            System.out.println("First");
        }else{
            System.out.println("Second");
        }
    }
}

import java.awt.Point;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.Queue;
import java.util.StringTokenizer;

public class A {

	public static void main(String[] args) throws IOException {
		Scanner sc = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);

		int a = sc.nextInt();
		int b = sc.nextInt();

		int r = sc.nextInt();

		if(2 * r <= a && 2 * r <= b)
			out.println("First");
		else
			out.println("Second");

		out.flush();
		out.close();
	}

	static class Scanner

	{
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s){	br = new BufferedReader(new InputStreamReader(s));}
		public Scanner(String file) throws FileNotFoundException{	br = new BufferedReader(new FileReader(file));}

		public String next() throws IOException
		{
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

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

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

		public String nextLine() throws IOException {return br.readLine();}

		public double nextDouble() throws IOException
		{
			String x = next();
			StringBuilder sb = new StringBuilder("0");
			double res = 0, f = 1;
			boolean dec = false, neg = false;
			int start = 0;
			if(x.charAt(0) == '-')
			{
				neg = true;
				start++;
			}
			for(int i = start; i < x.length(); i++)
				if(x.charAt(i) == '.')
				{
					res = Long.parseLong(sb.toString());
					sb = new StringBuilder("0");
					dec = true;
				}
				else
				{
					sb.append(x.charAt(i));
					if(dec)
						f *= 10;
				}
			res += Long.parseLong(sb.toString()) / f;
			return res * (neg?-1:1);
		}

		public boolean ready() throws IOException {return br.ready();}

	}

}

import java.util.Scanner;

public class plateGame {

	public static void main(String args[]){
		Scanner sc=new Scanner(System.in);
		int a=sc.nextInt();
		int b=sc.nextInt();
		int r=sc.nextInt();
		int d=2*r;
		int cnt=0;
		while(d<=a && d<=b)
		{
			a=d-a;
			b=d-b;
			cnt++;
		}

		if(cnt!=0 && cnt%2!=0){
			System.out.println("First");
		}
		else{
			System.out.println("Second");
		}
	}
}

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

public class Solution {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        String str = br.readLine();
        StringTokenizer st = new StringTokenizer(str, " ");
        int a = Integer.parseInt(st.nextToken());
        int b = Integer.parseInt(st.nextToken());
        int r = Integer.parseInt(st.nextToken());
        if (2 * r <= Math.min(a, b)) {
            bw.write("First\n");
        } else {
            bw.write("Second\n");
        }
        bw.flush();
    }
}

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

public class Main {

	public static void main(String[] args) throws IOException {

		Scanner sc = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);

		int a = sc.nextInt(), b = sc.nextInt(), r = sc.nextInt() * 2;
		a /= r;
		b /= r;
		if(a > 0 && b > 0)
			out.println("First");
		else
			out.println("Second");
		out.close();
	}

	static class Scanner
	{
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s){	br = new BufferedReader(new InputStreamReader(s));}

		public Scanner(String s) throws FileNotFoundException {	br = new BufferedReader(new FileReader(s));}

		public String next() throws IOException
		{
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

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

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

		public String nextLine() throws IOException {return br.readLine();}

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

		public boolean ready() throws IOException {return br.ready();}
	}
}

import java.io.BufferedInputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

/**
 * User: khuongnd
 * Date: 6/12/12
 * Time: 9:46 CH
 */
public class A {
	private static int BUFFER_SIZE = 16 * 1024 * 1024;
	private static Long oo = Long.MAX_VALUE / 2;
	private int a, b, c;
	private String result;

	public void read(Scanner reader) {
		a = reader.nextInt();
		b = reader.nextInt();
		c = reader.nextInt();
	}

	public void process() {
		result = (a >= 2 * c && b >= 2 * c) ? "First" : "Second";
	}

	public void print() {
		System.out.println(result);
	}

	public static void main(String args[]) {
		try {
			Scanner reader = new Scanner(new BufferedInputStream(System.in, BUFFER_SIZE));
			A a = new A();
			a.read(reader);
			a.process();
			a.print();
			reader.close();
		} catch (Exception ex) {
			ex.printStackTrace();
		}
	}
}

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

/**
 *
 * @author Utsav
 */
import java.util.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class PlateGame {
    static class FastReader {

        BufferedReader br;
        StringTokenizer st;

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

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

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

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

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

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }
    public static void main(String[] args) {
        FastReader s = new FastReader();
        int a = s.nextInt();
        int b = s.nextInt();
        int r   = s.nextInt();

        int max;
        int wid;
        if(a>=b){
            max = a;
            wid = b;
        }else{
            max = b;
            wid = a;
        }

        int hor = max/(2*r);
        int ver = wid/(2*r);
        int time = hor*ver;
        if(time == 0){
            System.out.println("Second");
        }else
               System.out.println("First");
//
//        if(hor == 1 && ver == 1){
//            System.out.println("First");
//            System.exit(0);
//        }else if((hor == 1 && ver > 1) || (hor > 1 && ver == 1)){
//            System.out.println("dfs");
//            time = hor*ver -1;
//            System.out.println(time);
//            if(time % 2 == 0){
//                System.out.println("Second");
//            }else{
//                System.out.println("First");
//            }
//            System.exit(0);
//
//        }else if(hor > 1 && ver >1){
//            time = (hor-1)*(ver -1);
//            if(time % 2 == 0){
//                System.out.println("Second");
//            }else{
//                System.out.println("First");
//            }
//            System.exit(0);
//        }
//        //System.out.println(hor+" "+ver);
//
//        //System.out.println(time);
//        if(time == 0){
//
//            System.out.println("Second");
//        }
    }
}

import java.util.*;
import java.lang.*;

public class Main
{
    public static void main (String[] args) throws java.lang.Exception
    {
        Scanner in = new Scanner(System.in);

        int a = in.nextInt();
        int b = in.nextInt();
        int r = in.nextInt()*2;
        if(a<r || b<r) {
            System.out.println("Second");
        } else {
            System.out.println("First");
        }

    }
}

import java.io.*;
import java.math.*;
import java.security.*;
import java.text.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.regex.*;
import java.util.Arrays;
import java.util.ArrayList;
import java.lang.Math;

public class project
{
    static class FastReader
    {
        BufferedReader br;
        StringTokenizer st;

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

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

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

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

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

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

    static int binarySearch(int a[],int k,int l,int h){

        while(l<=h){
         int mid = (l+h)/2;
         if(a[mid]==k) return mid;
         else if(a[mid]>k) h=mid-1;
         else if(a[mid]<k) l =mid+1;
    }

        return -1;
    }

    static String reverse(String input)
    {
        char[] a = input.toCharArray();
        int l, r = 0;
        r = a.length - 1;

        for (l = 0; l < r; l++, r--)
        {
            // Swap values of l and r
            char temp = a[l];
            a[l] = a[r];
            a[r] = temp;
        }
        return String.valueOf(a);
    }

    static int gcd(int a, int b)
    {
        // Everything divides 0
        if (a == 0)
          return b;
        if (b == 0)
          return a;

        if (a == b)
            return a;

        if (a > b)
            return gcd(a-b, b);
        return gcd(a, b-a);
    }

        public static void main(String[] args) throws Exception
    {

        OutputStream outputStream = System.out;
        PrintWriter w = new PrintWriter(outputStream);
        FastReader sc = new FastReader();
        int i,k;

         int l  = sc.nextInt();
         int b  = sc.nextInt();
         int r  = sc.nextInt();

         if(2 * r > Math.min(l, b)){
           w.println("Second");

        }else{
            w.println("First");

        }

         w.close();
    }

}

// System.out.println();

import java.util.Scanner;
import java.io.OutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author Lokesh Khandelwal aka (codeKNIGHT | phantom11)
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		Scanner in = new Scanner(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskA solver = new TaskA();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskA {
	public void solve(int testNumber, Scanner in, PrintWriter out) {
        int a=in.nextInt(),b=in.nextInt(),c=2*in.nextInt();

        if(a<c||b<c)
            out.println("Second");
        else out.println("First");
	}
}

import java.io.InputStreamReader;
import java.io.IOException;
import java.math.BigDecimal;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.math.BigInteger;
import java.io.InputStream;

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

class TaskA {

	public void solve(int testNumber, FastScanner in, PrintWriter out) {
		int a = in.nextInt();
		int b = in.nextInt();
		int r = in.nextInt() << 1;
		if (r > a || r > b) {
			out.println("Second");
		} else {
			out.println("First");
		}
	}

}

class FastScanner {

	private BufferedReader reader;
	private StringTokenizer tokenizer;

	public FastScanner(InputStream stream) {
		reader = new BufferedReader(new InputStreamReader(stream));
		tokenizer = null;
	}

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

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

	}

//package com.example.hackerranksolutions;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Scanner;

public class CodeforcesProblems {

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String[] inputs = br.readLine().split(" ");
        int a = Integer.parseInt(inputs[0]);
        int b = Integer.parseInt(inputs[1]);
        int r = Integer.parseInt(inputs[2]);

        if(a>=2*r && b>=2*r) System.out.println("First");
        else System.out.println("Second");
    }
}

import java.util.Scanner;

public class PlateGame {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int a = sc.nextInt();
		int b = sc.nextInt();
		int r = sc.nextInt();
		if (2 * r > a || 2 * r > b) {
			System.out.println("Second");
		} else {
			System.out.println("First");
		}
	}

}

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

public class P197A {

  public PrintWriter run() {
    int a = sc.nextInt();
    int b = sc.nextInt();
    int r = sc.nextInt();

    if ((a < r * 2) || (b < r * 2)) {
      pw.println("Second");
    } else {
      pw.println(((((a / r) * (b / r)) % 2) == 0) ? "First" : "Second");
    }

    return pw;
  }

  private Scanner sc = new Scanner(new BufferedInputStream(System.in));
  private PrintWriter pw = new PrintWriter(new BufferedOutputStream(System.out));

  public static void main(String... args) throws Exception {
    new P197A().run().close();
  }
}

//package com.prituladima.codeforce.a2oj.div2A;

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

import static java.lang.Math.min;
import static java.util.stream.IntStream.range;

public class Pro92 {

    private void solve() {
        int a = nextInt(), b = nextInt(), r = nextInt();
        sout(2 * r <= min(a, b) ? "First" : "Second");
    }

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

    private BufferedReader reader;
    private StringTokenizer tokenizer;
    private PrintWriter writer;

    private void run() {
        try {
            reader = new BufferedReader(new InputStreamReader(System.in));
            tokenizer = null;
            writer = new PrintWriter(System.out);
            solve();
            reader.close();
            writer.close();
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(1);
        }
    }

    private int nextInt() {
        return Integer.parseInt(nextToken());
    }

    private long nextLong() {
        return Long.parseLong(nextToken());
    }

    private double nextDouble() {
        return Double.parseDouble(nextToken());
    }

    private int[] nextArr(int size) {
        return Arrays.stream(new int[size]).map(c -> nextInt()).toArray();
    }

    private long[] nextArrL(int size) {
        return Arrays.stream(new long[size]).map(c -> nextLong()).toArray();
    }

    private double[] nextArrD(int size) {
        return Arrays.stream(new double[size]).map(c -> nextDouble()).toArray();
    }

    private char[][] nextCharMatrix(int n) {
        return range(0, n).mapToObj(i -> nextToken().toCharArray()).toArray(char[][]::new);
    }

    private int[][] nextIntMatrix(int n, int m) {
        return range(0, n).mapToObj(i -> nextArr(m)).toArray(int[][]::new);
    }

    private double[][] nextDoubleMatrix(int n, int m) {
        return range(0, n).mapToObj(i -> nextArr(m)).toArray(double[][]::new);
    }

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

    private void soutn() {
        writer.println();
    }

    private void soutn(Object o) {
        writer.println(o);
    }

    private void sout(Object o) {
        writer.print(o);
    }

    private void souf(String format, Object... args) {
        writer.printf(format, args);
    }

    private <Param> void sout(Param[] arr) {
        writer.println(Arrays.toString(arr));
    }

}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.StringTokenizer;

public class Main {

	final static int mod = 1_000_000_007;

	public static void main(String[] args) throws Exception {

		STDIN scan = new STDIN();

		int a = scan.nextInt(), b = scan.nextInt(), r = scan.nextInt();
		if(2*r > a || 2*r > b) System.out.println("Second");
		else System.out.println("First");
	}

	static class STDIN {
		BufferedReader br;
		StringTokenizer st;

		public STDIN() {
			br = new BufferedReader(new InputStreamReader(System.in));
			st = null;
		}

		boolean hasNext() throws Exception {
			if (!st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.hasMoreTokens();
		}

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

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

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

		String next() throws Exception {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		String nextLine() throws Exception {
			return br.readLine();
		}
	}
}

import java.util.Scanner;

public class Plate_Game {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int i,j,k,n,a,b,r,l,a1,b1;
        int sum;
        while (input.hasNext()){
            a = input.nextInt(); b = input.nextInt(); r = input.nextInt(); sum = 0; l = r*2;

            if (r*2 <= a && r*2 <= b) System.out.println("First");
            else System.out.println("Second");
           // System.out.println(sum);
        }
    }
}

import java.util.*;
public class cf197a {
  public static void main(String[] args) {
    Scanner in = new Scanner(System.in);
    int w = Math.min(in.nextInt(),in.nextInt());
    int r = in.nextInt();
    System.out.println(2*r<=w?"First":"Second");
  }
}

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

public class A197 implements Runnable {

	public void solve() throws IOException {
		int x = nextInt();
                int y = nextInt();
                int diameter = 2 * nextInt();

                if(diameter <= x && diameter <= y){
                        System.out.println("First");
                }
                else{
                        System.out.println("Second");
                }
	}

	//-----------------------------------------------------------
	public static void main(String[] args) {
		new A197().run();
	}

	public void run() {
		try {
			in = new BufferedReader(new InputStreamReader(System.in));
			tok = null;
			solve();
			in.close();
		} catch (IOException e) {
			System.exit(0);
		}
	}

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

	public int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	public long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}

	public double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}

	BufferedReader in;
	StringTokenizer tok;
}

import java.lang.*;
import java.util.*;

public class PLate
{
    public static void main(String args[])
    {
        int a=0,b=0,r=0;
        Scanner in = new Scanner(System.in);

        a=in.nextInt();
        b=in.nextInt();
        r=in.nextInt();

        if(2*r>Math.min(a,b))
        System.out.println("Second");
        else
        System.out.println("First");

    }
}

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Scanner;

public class Task197A {

	public static void main(String... args) throws NumberFormatException,
			IOException {
		Solution.main(System.in, System.out);
	}

	static class Solution {

		public static void main(InputStream is, OutputStream os)
				throws NumberFormatException, IOException {
			PrintWriter pw = new PrintWriter(os);
			Scanner sc = new Scanner(is);

			int a = sc.nextInt();
			int b = sc.nextInt();
			int r = sc.nextInt();

			if(2*r <= a && 2*r <= b){
				pw.println("First");
			} else {
				pw.println("Second");
			}

			pw.flush();
			sc.close();
		}
	}

}

import java.io.*;
import java.util.*;
public class Main {
    public static void main(String args[]){
        System.out.println(run());
    }
    static String run(){
        Scanner in = new Scanner(new BufferedReader(new InputStreamReader(System.in)));
        int X = in.nextInt();
        int Y = in.nextInt();
        int d = 2*in.nextInt();
        return X >= d && Y >= d ? "First" : "Second" ;
    }
}

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

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

    static class TaskA {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int a = in.nextInt();
            int b = in.nextInt();
            int r = in.nextInt();
            if (a < 2 * r || b < 2 * r) out.println("Second");
            else out.println("First");
        }

    }

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

        public InputReader(InputStream inputStream) {
            reader = new BufferedReader(new InputStreamReader(inputStream));
        }

        private void fillTokenizer() {
            if (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            }
        }

        public String next() {
            fillTokenizer();
            return tokenizer.nextToken();
        }

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

    }
}

import java.util.*;
public class Platos {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Scanner in=new Scanner(System.in);
		int alto=in.nextInt();
		int ancho=in.nextInt();
		int radio=in.nextInt();
		radio*=2;

		if(radio <= alto && radio <= ancho){

				System.out.println("First");

		}else{

			System.out.println("Second");

		}

	}

}

/* package whatever; // don't place package name! */

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

/* Name of the class has to be "Main" only if the class is public. */
public class Ideone
{
	public static void main (String[] args) throws java.lang.Exception
	{
		// your code goes here
		Scanner sc=new Scanner(System.in);
		int a=sc.nextInt();
		int b=sc.nextInt();
		int r=sc.nextInt();
		int max=Math.min(a,b);
		if(max<2*r)
		System.out.println("Second");
		else
		System.out.println("First");

	}
}

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class Main {
	static int N = 100000;
	static Scanner in = new Scanner(System.in);
	static Map<Integer, Integer> mp = new HashMap<Integer, Integer>();
	static ArrayList<Integer> ar = new ArrayList<Integer>();
	static ArrayList<Integer> ans = new ArrayList<Integer>();
	static int cn[] = new int[5];

	public static void main(String[] args) {
		int a, b, r;
		a = in.nextInt();
		b = in.nextInt();
		r = in.nextInt();
		if (r * 2 <= a && r * 2 <= b) {
			System.out.println("First");
		} else {
			System.out.println("Second");
		}
	}

}

import java.util.*;
public class Problem0197a {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        int b = sc.nextInt();
        int r = sc.nextInt();

        if(2*r <= a && 2*r <= b){
            System.out.println("First");
        }
        else {
            System.out.println("Second");
        }
    }
}

import java.util.Scanner;
public class Solution {
    public static void main(String args[]) {
        Scanner s=new Scanner(System.in);
        int l=s.nextInt();
        int b=s.nextInt();
        int r=s.nextInt();
        int diameter=2*r;
        if(diameter>l || diameter>b)
        {
            System.out.println("Second");
        }
        else{
            System.out.println("First");
        }
    }

}

import java.io.IOException;
import java.util.Arrays;
import java.util.Scanner;

public class first {

    /**
     * @param args
     * @throws IOException
     */

    public static void main(String[] args) throws IOException {
           Scanner sc=new Scanner(System.in);
        int a=sc.nextInt();
        int b=sc.nextInt();
        int r=sc.nextInt();
        if (2*r>Math.min(a, b))
            System.out.print("Second");
        else
            System.out.print("First");
        System.out.flush();

    }
}

import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.BufferedWriter;
import java.util.InputMismatchException;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.NoSuchElementException;
import java.io.Writer;
import java.math.BigInteger;
import java.io.InputStream;

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

class TaskA {
    public void solve(int testNumber, InputReader in, OutputWriter out){
	    int a = in.ri(), b = in.ri(), r = in.ri() * 2, min = Math.min(a, b);
	    out.printLine(r <= min ? "First" : "Second");
    }
}

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

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

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

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

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

class OutputWriter {
	private final PrintWriter writer;

	public OutputWriter(OutputStream outputStream) {
		writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
	}
	public void print(Object...objects) {
		for (int i = 0; i < objects.length; i++) {
			if (i != 0)
				writer.print(' ');
			writer.print(objects[i]);
		}
	}
	public void printLine(Object...objects) {
		print(objects);
		writer.println();
	}
	public void close() {
		writer.close();
	}
}

import java.util.Scanner;

public class A197 {

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int a = in.nextInt();
		int b = in.nextInt();
		int r = in.nextInt();
		if (2 * r > a || 2 * r > b) {
			System.out.println("Second");
		} else {
			System.out.println("First");
		}

	}

}

import java.awt.Point;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.Map;
import java.util.StringTokenizer;

/**
6 4
engine
brakes
tires
ashtray
vinyl roof
trip computer
------------
Chevrolet
20000.00 3
engine
tires
brakes
----------------
Cadillac
70000.00 4
ashtray
vinyl roof
trip computer
engine
-----------------
Hyundai
10000.00 3
engine
tires
ashtray
-------------------
Lada
6000.00 1
tires

        1 2 3
      1 2 3
    1 2 3
  1 2 3
1 2 3
1 2 3 4 5 6 7 8 9

(1*k + 2*k + 3*k + ... + w*k)
(1 + 2 + 3 + 4)*k

1+2+3 = 6
 * */
public class Equality {
    public static void main(String[]arg) throws IOException
    {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(in.readLine());
        int a = Integer.parseInt(st.nextToken());
        int b = Integer.parseInt(st.nextToken());
        int r = Integer.parseInt(st.nextToken());
        if( r*2 <= a && r*2 <= b)
            System.out.println("First");
        else
            System.out.println("Second");

    }
}

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

public class A {

    int gcd(int a, int b){
        return (b!=0)? gcd(b, a%b): a;
    }
    private void solve() throws IOException {
        int a, b, r;
        a=nextInt();
        b=nextInt();
        r=nextInt();
        if (a<2*r || b<2*r){
            print("Second");
        }
        else{
            print("First");
        }
    }

    private String nextToken() throws IOException {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            tokenizer = new StringTokenizer(reader.readLine());
        }
        return tokenizer.nextToken();
    }

    private int nextInt() throws NumberFormatException, IOException {
        return Integer.parseInt(nextToken());
    }

    private double nextDouble() throws NumberFormatException, IOException {
        return Double.parseDouble(nextToken());
    }

    private long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }

    private void print(Object o) {
        writer.print(o);
    }

    private void println(Object o) {
        writer.println(o);
    }

    private void printf(String format, Object... o) {
        writer.printf(format, o);
    }

    public static void main(String[] args) {
        long time = System.currentTimeMillis();
        Locale.setDefault(Locale.US);
        new A().run();
        System.err.printf("%.3f\n", 1e-3 * (System.currentTimeMillis() - time));
    }

    BufferedReader reader;
    StringTokenizer tokenizer;
    PrintWriter writer;

    private void run() {
        try {
            reader = new BufferedReader(new InputStreamReader(System.in));
            writer = new PrintWriter(System.out);
            solve();
            reader.close();
            writer.close();
        } catch (IOException e) {
            e.printStackTrace();
            System.exit(13);
        }
    }
}

import java.util.Scanner;

public class PlateGame {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        int b = sc.nextInt();
        int r = sc.nextInt();
        if (2 * r > Math.min(a, b)) {
            System.out.println("Second");
        } else {
            System.out.println("First");
        }
    }
}

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.InputMismatchException;

public class Main1 {
	public static void main(String[] args) {
		FastScanner sc = new FastScanner(System.in);

		int A = sc.nextInt();
		int B = sc.nextInt();
		int R = sc.nextInt();
		int D = 2 * R;
		if(D > A || D > B) System.out.println("Second");
		else System.out.println("First");
	}
}

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

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

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

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

	public String next() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = read();
		} while (!isSpaceChar(c));
		return res.toString();
	}

	public String nextLine() {
		int c = read();
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = read();
		} while (!isLineEndChar(c));
		return res.toString();
	}

	public double nextDouble() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		double res = 0;
		while (!isSpaceChar(c) && c != '.') {
			if (c == 'e' || c == 'E')
				return res * Math.pow(10, nextInt());
			if (c < '0' || c > '9')
				throw new InputMismatchException();
			res *= 10;
			res += c - '0';
			c = read();
		}
		if (c == '.') {
			c = read();
			double m = 1;
			while (!isSpaceChar(c)) {
				if (c == 'e' || c == 'E')
					return res * Math.pow(10, nextInt());
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				m /= 10;
				res += (c - '0') * m;
				c = read();
			}
		}
		return res * sgn;
	}

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

	public boolean isSpaceChar(int c) {
		if (filter != null)
			return filter.isSpaceChar(c);
		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	}

	public boolean isLineEndChar(int c) {
		if (filter != null)
			return filter.isSpaceChar(c);
		return c == '\n' || c == '\r' || c == -1;
	}

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

import java.util.*;
public class A {
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int a = sc.nextInt();
    int b = sc.nextInt();
    int r = sc.nextInt();
    if (a >= 2*r && b >= 2*r) {
      System.out.println("First");
    } else {
      System.out.println("Second");
    }
  }
}

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

public class PlateGame {
    public static void main(String args [] ) throws IOException
    {
        BufferedReader br= new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st=new StringTokenizer(br.readLine()," ");
        int a=Integer.parseInt(st.nextToken());
        int b=Integer.parseInt(st.nextToken());
        int r=Integer.parseInt(st.nextToken());
        if(r*2>a||r*2>b)System.out.print("Second");
        else System.out.print("First");
    }
}

import java.util.Scanner;
public class PlateGame {

    public static void main(String[] args) {
        Scanner t = new Scanner(System.in);
        int l1 = t.nextInt();
        int l2 = t.nextInt();
        int r = t.nextInt();

        int d = r*2;

        if(l1>=d && l2>=d){
            System.out.println("First");
        }else{
            System.out.println("Second");
        }
    }

}

import java.util.Scanner;

public class main{
    public static void main( String[] args ){
        Scanner s = new Scanner ( System.in );
        int a = s.nextInt ( ), b = s.nextInt( ), c = s.nextInt( );
        if ( a < 2 * c || b < 2 * c){
            System.out.println ("Second");
        }
        else
            System.out.println ("First");
    }
}

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

//package acm.prepare;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Scanner;

/**
 *
 * @author Rock
 */
public class Tables {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
       int n = sc.nextInt();
       int m = sc.nextInt();
       int r = sc.nextInt();

     if((2*r)<=n && (2*r)<=m)
       System.out.println("First");
     else
          System.out.println("Second");

    }
}

import java.util.Scanner;

public class ProblemA {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        int b = sc.nextInt();
        int r = sc.nextInt();
        if (a >= 2*r && b >= 2*r)
            System.out.println("First");
        else
            System.out.println("Second");
    }

}

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

import static java.lang.Math.max;
import static java.lang.Math.min;

public class Code implements Runnable {

    String in = "", out = "";
    BufferedReader reader;
    PrintWriter writer;
    StringTokenizer st;

    public static void main(String[] args) throws IOException {
        new Thread(new Code()).start();
    }

    void solve() throws IOException {
        if(min(nextInt(), nextInt()) < nextInt() << 1)  writer.println("Second");
        else    writer.println("First");
    }

    public void run() {
        try {
            if(in.equals(""))   reader = new BufferedReader(new InputStreamReader(System.in));
            else    reader = new BufferedReader(new FileReader(in));

            if(out.equals(""))  writer = new PrintWriter(new OutputStreamWriter(System.out));
            else    writer = new PrintWriter(new FileWriter(out));
            solve();
        } catch(IOException e) {
            e.printStackTrace();
        } finally {
            try {
                reader.close();
                writer.close();
            } catch(IOException e) {
                e.printStackTrace();
            }
        }
    }

    int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }

    long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }

    double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }

    String nextToken() throws IOException {
        while(st == null || !st.hasMoreTokens())    st = new StringTokenizer(reader.readLine());
        return st.nextToken();
    }
}

import java.util.Scanner;

public class PlateGame197A {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int a = in.nextInt();
		int b = in.nextInt();
		int r = in.nextInt();
		if (r * 2 > Math.min(a, b))
			System.out.println("Second");
		else
			System.out.println("First");
	}
}

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

public class A197 {

    public static void main(String[] args) throws IOException {
        BufferedReader std = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(System.out);
        String s = std.readLine();
        String[] ss = s.split(" ");
        int a = Integer.parseInt(ss[0]);
        int b = Integer.parseInt(ss[1]);
        int d = Integer.parseInt(ss[2]) * 2;
        if (Math.min(a, b) < d) {
            out.println("Second");
        } else {
            out.println("First");
        }
        out.flush();

    }
}

import java.util.Scanner;

public class P197A_PlateGame {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		int a = scanner.nextInt();
		int b = scanner.nextInt();
		int r = scanner.nextInt();
		scanner.close();

		if (r * 2 > (a >= b ? b : a)) {
			System.out.println("Second");
		} else {
			System.out.println("First");
		}
	}
}

import java.util.*;
public class template {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int a = sc.nextInt();
		int b = sc.nextInt();
		int r = sc.nextInt();
		if(2*r > Math.min(a, b))System.out.println("Second");
		else		System.out.println("First");

	}

}

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

public class Plates implements Runnable {

	final boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null;

	BufferedReader in;
	PrintWriter out;
	StringTokenizer tok;

	@Override
	public void run() {
		try {
			long startTime = System.currentTimeMillis();
			if (ONLINE_JUDGE) {
				in = new BufferedReader(new InputStreamReader(System.in));
				out = new PrintWriter(System.out);
			} else {
				in = new BufferedReader(new FileReader("input.txt"));
				out = new PrintWriter("output.txt");
			}
			tok = new StringTokenizer("");
			Locale.setDefault(Locale.US);
			solve();
			in.close();
			out.close();
			long endTime = System.currentTimeMillis();
			long totalMemory = Runtime.getRuntime().totalMemory();
			long freeMemory = Runtime.getRuntime().freeMemory();
			System.err.println("Time = " + (endTime - startTime) + " ms");
			System.err.println("Memory = " + ((totalMemory - freeMemory) / 1024) + " KB");
		} catch (Throwable e) {
			e.printStackTrace(System.err);
			System.exit(-1);
		}
	}

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

	int readInt() throws IOException {
		return Integer.parseInt(readString());
	}

	long readLong() throws IOException {
		return Long.parseLong(readString());
	}

	double readDouble() throws IOException {
		return Double.parseDouble(readString());
	}

	void debug(Object... o) {
		if (!ONLINE_JUDGE) {
			System.err.println(Arrays.deepToString(o));
		}
	}

	public static void main(String[] args) {
		new Thread(null, new Plates(), "", 256 * 1024 * 1024).start();
	}

//------------------------------------------------------------------------------

	void solve() throws IOException {
		int a = readInt();
		int b = readInt();
		int R = readInt();
		if (2*R > min(a,b)) {
			out.println("Second");
		} else {
			out.println("First");
		}
	}

}

import java.util.Scanner;

public class program{
	public static int min(int a,int b){
		return a < b ? a : b;
	}
	public static void main(String args[]){
		Scanner input = new Scanner(System.in);
		//System.out.println(input.nextLine());
		int a,b,r;

		a = input.nextInt();
		b = input.nextInt();
		r = input.nextInt();

		if(2*r > min(a,b)){
			System.out.println("Second");
		}
		else{
			System.out.println("First");
		}
	}
}

import java.util.*;
import java.io.*;
public class b {
public static void main(String[] args) throws IOException
{
    boolean[] sieve = new boolean[1000001];
    Arrays.fill(sieve, true);
    sieve[0]=sieve[1]=false;
    for(int i = 2; i<sieve.length; i++) if(sieve[i]) for(long j = (long)i*i; j<sieve.length; j+=i) sieve[(int)j] = false;

    //Scanner input = new Scanner(new File("input.txt"));
    //PrintWriter out = new PrintWriter(new File("output.txt"));
    PrintWriter out = new PrintWriter(System.out);
    input.init(System.in);
    int a = input.nextInt(), b =input.nextInt(),r=input.nextInt();
    int x = Math.min(a,b);
    if(x >= 2*r)
        out.println("First");
    else
        out.println("Second");
    out.close();
}
static class X implements Comparable<X>
{
    int a;
    double b;
    public X(int a, double b)
    {
        this.a = a; this.b = b;
    }
    @Override
    public int compareTo(X that) {
        // TODO Auto-generated method stub
        if(this.b == that.b) return this.a-that.a;
        return (int)Math.signum(that.b-this.b);
    }
}
public static long gcd(long a, long b)
{
if(b == 0) return a;
return gcd(b, a%b);
}
public static class input {
    static BufferedReader reader;
    static StringTokenizer tokenizer;

    /** call this method to initialize reader for InputStream */
    static void init(InputStream input) {
        reader = new BufferedReader(
                     new InputStreamReader(input) );
        tokenizer = new StringTokenizer("");
    }

    /** get next word */
    static String next() throws IOException {
        while ( ! tokenizer.hasMoreTokens() ) {
            //TODO add check for eof if necessary
            tokenizer = new StringTokenizer(
                   reader.readLine() );
        }
        return tokenizer.nextToken();
    }

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

    static double nextDouble() throws IOException {
        return Double.parseDouble( next() );
    }
    static long nextLong() throws IOException {
        return Long.parseLong( next() );
    }
}
static class IT
{
    int[] left,right, val, a, b;
    IT(int n)
    {
        left = new int[3*n];
        right = new int[3*n];
        val = new int[3*n];
        a = new int[3*n];
        b = new int[3*n];
        init(0,0, n);
    }
    int init(int at, int l, int r)
    {
        a[at] = l;
        b[at] = r;
        if(l==r)
            left[at] = right [at] = -1;
        else
        {
            int mid = (l+r)/2;
            left[at] = init(2*at+1,l,mid);
            right[at] = init(2*at+2,mid+1,r);
        }
        return at++;
    }
    //return the sum over [x,y]
    int get(int x, int y)
    {
        return go(x,y, 0);
    }
    int go(int x,int y, int at)
    {
        if(at==-1) return 0;
        if(x <= a[at] && y>= b[at]) return val[at];
        if(y<a[at] || x>b[at]) return 0;
        return go(x, y, left[at]) + go(x, y, right[at]);
    }
    //add v to elements x through y
    void add(int x, int y, int v)
    {
        go3(x, y, v, 0);
    }
    void go3(int x, int y, int v, int at)
    {
        if(at==-1) return;
        if(y < a[at] || x > b[at]) return;
        val[at] += (Math.min(b[at], y) - Math.max(a[at], x) + 1)*v;
        go3(x, y, v, left[at]);
        go3(x, y, v, right[at]);
    }
}
}

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

public class Test {
	static BufferedReader reader;
	static StringTokenizer tokenizer;
	static PrintWriter writer;

	static int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	static long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}

	static double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}

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

	public static void main(String[] args) throws IOException {
		reader = new BufferedReader(new InputStreamReader(System.in));
		tokenizer = null;
		writer = new PrintWriter(System.out);
		solve();
		reader.close();
		writer.close();
	}

	private static void solve() throws IOException {
		int a = nextInt();
		int b = nextInt();
		int r = nextInt();
		if(2*r>Math.min(a, b))
		{
			writer.println("Second");
		}
		else
		{
			writer.println("First");
		}
	}
}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.StringTokenizer;
public class Main
{
   public static void main(String[]arg) throws IOException {
       BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
       StringTokenizer tokens;
       String line = in.readLine();
       tokens = new StringTokenizer(line);
       int a = Integer.parseInt(tokens.nextToken());
       int b = Integer.parseInt(tokens.nextToken());
       int r = Integer.parseInt(tokens.nextToken());
       if(a <= b)
         if(a >= r*2)
            System.out.println("First");
         else
            System.out.println("Second");
       else
         if(b >= r*2)
            System.out.println("First");
         else
            System.out.println("Second");
    }
}

import java.util.Scanner;

/**
 *
 * @author Gitesh
 */
public class JavaApplication2 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        Scanner s=new Scanner(System.in);

                int a,b,r;
                a=s.nextInt();b=s.nextInt();r=s.nextInt();
                if(a>=2*r &&b>=2*r)
                    System.out.println("First");
                else
                    System.out.println("Second");

}
}

import java.util.Scanner;

public class Prob197A {
	public static void main(String[] Args) {
		Scanner in = new Scanner(System.in);
		int a = in.nextInt();
		int b = in.nextInt();
		int r = in.nextInt();
		if (r * 2 > a || r * 2 > b)
			System.out.println("Second");
		else
			System.out.println("First");
	}
}

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

public class TaskA {
    BufferedReader in;
    PrintWriter out;
    StringTokenizer tokenizer;
    Integer a, b, r, i;
    double  s1, s2, summa;

    public TaskA() {
        in = new BufferedReader(new InputStreamReader(System.in));
        out = new PrintWriter(System.out);
    }

    public void solve() throws IOException {
        a = nextInt();
        b = nextInt();
        r = nextInt();

        s1 = a*b;

        if(a >= 2*r && b>=2*r){
            out.println("First");
        } else {
             out.println("Second");
        }

        out.flush();
    }

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

    private int nextInt() throws NumberFormatException, IOException {
        return Integer.parseInt(nextToken());
    }

    public static void main(String[] args) throws IOException {
        long startTime = System.currentTimeMillis();
        TaskA ob = new TaskA();
        ob.solve();
        System.err.printf("%.3f\n", 1e-3 * (System.currentTimeMillis() - startTime));
    }
}

import java.util.Scanner;

public class a197 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner in = new Scanner(System.in);
		int a = in.nextInt(); int b = in.nextInt(); int r = in.nextInt();
		if ((2*r > a) || (2*r > b)) System.out.println("Second"); else System.out.println("First");
	}

}

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

public class A {

	public void solve() throws Exception {

		int a = nextInt(), b = nextInt(), r = nextInt();
		if (2*r>a || 2*r>b) println("Second");
		else println("First");

	}

	////////////////////////////////////////////////////////////////////////////

	boolean showDebug = true;
	static boolean useFiles = false;
	static String inFile = "input.txt";
	static String outFile = "output.txt";

	double EPS = 1e-7;
	int INF = Integer.MAX_VALUE;
	long INFL = Long.MAX_VALUE;
	double INFD = Double.MAX_VALUE;

	int absPos(int num) {
		return num<0 ? 0:num;
	}
	long absPos(long num) {
		return num<0 ? 0:num;
	}
	double absPos(double num) {
		return num<0 ? 0:num;
	}

	int min(int... nums) {
		int r = nums[0];
		for (int i=1; i<nums.length; ++i)
			if (nums[i]<r) r=nums[i];
		return r;
	}
	int max(int... nums) {
		int r = nums[0];
		for (int i=1; i<nums.length; ++i)
			if (nums[i]>r) r=nums[i];
		return r;
	}
	long minL(long... nums) {
		long r = nums[0];
		for (int i=1; i<nums.length; ++i)
			if (nums[i]<r) r=nums[i];
		return r;
	}
	long maxL(long... nums) {
		long r = nums[0];
		for (int i=1; i<nums.length; ++i)
			if (nums[i]>r) r=nums[i];
		return r;
	}
	double minD(double... nums) {
		double r = nums[0];
		for (int i=1; i<nums.length; ++i)
			if (nums[i]<r) r=nums[i];
		return r;
	}
	double maxD(double... nums) {
		double r = nums[0];
		for (int i=1; i<nums.length; ++i)
			if (nums[i]>r) r=nums[i];
		return r;
	}

	long sumArr(int[] arr) {
		long res = 0;
		for (int i=0; i<arr.length; ++i)
			res+=arr[i];
		return res;
	}
	long sumArr(long[] arr) {
		long res = 0;
		for (int i=0; i<arr.length; ++i)
			res+=arr[i];
		return res;
	}
	double sumArr(double[] arr) {
		double res = 0;
		for (int i=0; i<arr.length; ++i)
			res+=arr[i];
		return res;
	}

	long partsFitCnt(long partSize, long wholeSize) {
		return (partSize+wholeSize-1)/partSize;
	}

	boolean odd(long num) {
		return (num&1)==1;
	}

	boolean hasBit(int num, int pos) {
		return (num&(1<<pos))>0;
	}

	boolean isLetter(char c) {
		return (c>='a' && c<='z') || (c>='A' && c<='Z');
	}
	boolean isLowercase(char c) {
		return (c>='a' && c<='z');
	}
	boolean isUppercase(char c) {
		return (c>='A' && c<='Z');
	}
	boolean isDigit(char c) {
		return (c>='0' && c<='9');
	}

	boolean charIn(String chars, String s) {
		if (s==null) return false;
		if (chars==null || chars.equals("")) return true;
		for (int i=0; i<s.length(); ++i)
			for (int j=0; j<chars.length(); ++j)
				if (chars.charAt(j)==s.charAt(i)) return true;
		return false;
	}

	String stringn(String s, int n) {
		if (n<1 || s==null) return "";
		StringBuilder sb = new StringBuilder(s.length()*n);
		for (int i=0; i<n; ++i) sb.append(s);
		return sb.toString();
	}
	String str(Object o) {
		if (o==null) return "";
		return o.toString();
	}

	long timer = System.currentTimeMillis();
	void startTimer() {
		timer = System.currentTimeMillis();
	}
	void stopTimer() {
		System.err.println("time: "+(System.currentTimeMillis()-timer)/1000.0);
	}

	static class InputReader {
		private byte[] buf;
		private int bufPos = 0, bufLim = -1;
		private InputStream stream;
		public InputReader(InputStream stream, int size) {
			buf = new byte[size];
			this.stream = stream;
		}
		private void fillBuf() throws IOException {
			bufLim = stream.read(buf);
			bufPos = 0;
		}
		char read() throws IOException {
			if (bufPos>=bufLim) fillBuf();
			return (char)buf[bufPos++];
		}
		boolean hasInput() throws IOException {
			if (bufPos>=bufLim) fillBuf();
			return bufPos<bufLim;
		}
	}

	static InputReader inputReader;
	static BufferedWriter outputWriter;

	char nextChar() throws IOException {
		return inputReader.read();
	}
	char nextNonWhitespaceChar() throws IOException {
		char c = inputReader.read();
		while (c<=' ') c=inputReader.read();
		return c;
	}
	String nextWord() throws IOException {
		StringBuilder sb = new StringBuilder();
		char c = inputReader.read();
		while (c<=' ') c=inputReader.read();
		while (c>' ') {
			sb.append(c);
			c = inputReader.read();
		}
		return new String(sb);
	}
	String nextLine() throws IOException {
		StringBuilder sb = new StringBuilder();
		char c = inputReader.read();
		while (c<=' ') c=inputReader.read();
		while (c!='\n' && c!='\r') {
			sb.append(c);
			c = inputReader.read();
		}
		return new String(sb);
	}
	int nextInt() throws IOException {
		int r = 0;
		char c = nextNonWhitespaceChar();
		boolean neg = false;
		if (c=='-') neg=true;
		else r=c-48;
		c = nextChar();
		while (c>='0' && c<='9') {
			r*=10;
			r+=c-48;
			c=nextChar();
		}
		return neg ? -r:r;
	}
	long nextLong() throws IOException {
		long r = 0;
		char c = nextNonWhitespaceChar();
		boolean neg = false;
		if (c=='-') neg=true;
		else r = c-48;
		c = nextChar();
		while (c>='0' && c<='9') {
			r*=10L;
			r+=c-48L;
			c=nextChar();
		}
		return neg ? -r:r;
	}
	double nextDouble() throws NumberFormatException, IOException {
		return Double.parseDouble(nextWord());
	}
	int[] nextArr(int size) throws NumberFormatException, IOException {
		int[] arr = new int[size];
		for (int i=0; i<size; ++i)
			arr[i] = nextInt();
		return arr;
	}
	long[] nextArrL(int size) throws NumberFormatException, IOException {
		long[] arr = new long[size];
		for (int i=0; i<size; ++i)
			arr[i] = nextLong();
		return arr;
	}
	double[] nextArrD(int size) throws NumberFormatException, IOException {
		double[] arr = new double[size];
		for (int i=0; i<size; ++i)
			arr[i] = nextDouble();
		return arr;
	}
	String[] nextArrS(int size) throws NumberFormatException, IOException {
		String[] arr = new String[size];
		for (int i=0; i<size; ++i)
			arr[i] = nextWord();
		return arr;
	}
	char[] nextArrCh(int size) throws IOException {
		char[] arr = new char[size];
		for (int i=0; i<size; ++i)
			arr[i] = nextNonWhitespaceChar();
		return arr;
	}
	char[][] nextArrCh(int rows, int columns) throws IOException {
		char[][] arr = new char[rows][columns];
		for (int i=0; i<rows; ++i)
			for (int j=0; j<columns; ++j)
				arr[i][j] = nextNonWhitespaceChar();
		return arr;
	}
	char[][] nextArrChBorders(int rows, int columns, char border) throws IOException {
		char[][] arr = new char[rows+2][columns+2];
		for (int i=1; i<=rows; ++i)
			for (int j=1; j<=columns; ++j)
				arr[i][j] = nextNonWhitespaceChar();
		for (int i=0; i<columns+2; ++i) {
			arr[0][i] = border;
			arr[rows+1][i] = border;
		}
		for (int i=0; i<rows+2; ++i) {
			arr[i][0] = border;
			arr[i][columns+1] = border;
		}
		return arr;
	}

	void printf(String format, Object... args) throws IOException {
		outputWriter.write(String.format(format, args));
	}
	void print(Object o) throws IOException {
		outputWriter.write(o.toString());
	}
	void println(Object o) throws IOException {
		outputWriter.write(o.toString());
		outputWriter.newLine();
	}
	void print(Object... o) throws IOException {
		for (int i=0; i<o.length; ++i) {
			if (i!=0) outputWriter.write(' ');
			outputWriter.write(o[i].toString());
		}
	}
	void println(Object... o) throws IOException {
		print(o);
		outputWriter.newLine();
	}
	void printn(Object o, int n) throws IOException {
		String s = o.toString();
		for (int i=0; i<n; ++i) {
			outputWriter.write(s);
			if (i!=n-1) outputWriter.write(' ');
		}
	}
	void printnln(Object o, int n) throws IOException {
		printn(o, n);
		outputWriter.newLine();
	}
	void printArr(int[] arr) throws IOException {
		for (int i=0; i<arr.length; ++i) {
			if (i!=0) outputWriter.write(' ');
			outputWriter.write(Integer.toString(arr[i]));
		}
	}
	void printArr(long[] arr) throws IOException {
		for (int i=0; i<arr.length; ++i) {
			if (i!=0) outputWriter.write(' ');
			outputWriter.write(Long.toString(arr[i]));
		}
	}
	void printArr(double[] arr) throws IOException {
		for (int i=0; i<arr.length; ++i) {
			if (i!=0) outputWriter.write(' ');
			outputWriter.write(Double.toString(arr[i]));
		}
	}
	void printArr(String[] arr) throws IOException {
		for (int i=0; i<arr.length; ++i) {
			if (i!=0) outputWriter.write(' ');
			outputWriter.write(arr[i]);
		}
	}
	void printlnArr(int[] arr) throws IOException {
		printArr(arr);
		outputWriter.newLine();
	}
	void printlnArr(long[] arr) throws IOException {
		printArr(arr);
		outputWriter.newLine();
	}
	void printlnArr(double[] arr) throws IOException {
		printArr(arr);
		outputWriter.newLine();
	}
	void printlnArr(String[] arr) throws IOException {
		printArr(arr);
		outputWriter.newLine();
	}
	void halt(Object... o) throws IOException {
		if (o.length!=0) println(o);
		outputWriter.flush(); outputWriter.close();
		System.exit(0);
	}

	void debug(Object... o) {
		if (showDebug) System.err.println(Arrays.deepToString(o));
	}

	public static void main(String[] args) throws Exception {
		Locale.setDefault(Locale.US);
		if (!useFiles) {
			inputReader = new InputReader(System.in, 1<<16);
			outputWriter = new BufferedWriter(new OutputStreamWriter(System.out), 1<<16);
		} else {
			inputReader = new InputReader(new FileInputStream(new File(inFile)), 1<<16);
			outputWriter = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(new File(outFile))), 1<<16);
		}
		new A().solve();
		outputWriter.flush(); outputWriter.close();
	}
}

import java.util.Scanner;

public class A{
   public static void main (String [] args ) {
        Scanner cin = new Scanner(System.in);
        while ( cin.hasNext()){
            int a = cin.nextInt();
            int b = cin.nextInt();
            int r = cin.nextInt();
            if( a >= 2*r && b >= 2*r ) System.out.println("First");
            else System.out.println("Second");
        }
        cin.close();
   }
}

//package contest_124_div2;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Reader;
import java.io.StreamTokenizer;
import java.io.Writer;
/**
 * Date     : 12 ����. 2012
 * Time     : 15:33:21
 * Email    : denys.astanin@gmail.com
 */

public class A {
	public static void main(String[] args) throws IOException {
		new A().run();
	}

	int nextInt() throws IOException {
		in.nextToken();
		return (int) in.nval;
	}

	String nextString() throws IOException {
		in.nextToken();
		return (String) in.sval;
	}

	StreamTokenizer in;
	Writer writer;
	Reader reader;

	void run() throws IOException {
		boolean oj = System.getProperty("ONLINE_JUDGE") != null;
		reader = oj ? new InputStreamReader(System.in, "ISO-8859-1")
				: new FileReader("src/contest_124_div2/A.txt");
		writer = new OutputStreamWriter(System.out, "ISO-8859-1");
		in = new StreamTokenizer(new BufferedReader(reader));
		PrintWriter out = new PrintWriter(writer);
		int a = nextInt();
		int b = nextInt();
		int r = nextInt();
		int size = r *2;
		if (size > a || size > b) {
			out.println("Second");
		} else {
				out.println("First");
		}
		out.flush();
		out.close();
	}
}

import java.util.*;

public class Plate{
	public static void solve(int a, int b, int r){
		if( a < 2*r || b < 2*r ){
			System.out.println("Second");
		} else {
			System.out.println("First");
		}
	}

	public static void main(String[] args){
		Scanner stdIn = new Scanner(System.in);
		int a = stdIn.nextInt(), b = stdIn.nextInt(), r = stdIn.nextInt();

		solve(a, b, r);
	}
}

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

public class A
{
	String line;
	StringTokenizer inputParser;
	BufferedReader is;
	FileInputStream fstream;
	DataInputStream in;
	String FInput="";

	void openInput(String file)
	{

		if(file==null)is = new BufferedReader(new InputStreamReader(System.in));//stdin
		else
		{
			try{

			fstream = new FileInputStream(file);
			in = new DataInputStream(fstream);
			is = new BufferedReader(new InputStreamReader(in));
			}catch(Exception e)
			{
				System.err.println(e);
			}
		}

	}

	void readNextLine()
	{
		try {
			line = is.readLine();
			inputParser = new StringTokenizer(line, " ");
			//System.err.println("Input: " + line);
		} catch (IOException e) {
			System.err.println("Unexpected IO ERROR: " + e);
		}
		catch (NullPointerException e)
		{
			line=null;

		}

	}

	int NextInt()
	{
		String n = inputParser.nextToken();
		int val = Integer.parseInt(n);

		//System.out.println("I read this number: " + val);
		return val;
	}

	long NextLong()
	{
		String n = inputParser.nextToken();
		long val = Long.parseLong(n);

		//System.out.println("I read this number: " + val);
		return val;
	}

	String NextString()
	{
		String n = inputParser.nextToken();
		return n;
	}

	void closeInput()
	{
		try {
			is.close();
		} catch (IOException e) {
			System.err.println("Unexpected IO ERROR: " + e);
		}

	}

	public static void main(String [] argv)
	{
		String filePath=null;
		if(argv.length>0)filePath=argv[0];
		new A(filePath);
	}

	public void readFInput()
	{
		for(;;)
		{
			try
			{
				readNextLine();
				FInput+=line+" ";
			}
			catch(Exception e)
			{
				break;
			}
		}
		inputParser = new StringTokenizer(FInput, " ");
	}

	public A(String inputFile)
	{
		openInput(inputFile);
		readNextLine();
		int a,b,r;
		a=NextInt();
		b=NextInt();
		r=NextInt();
		r*=2;
		a/=r;
		b/=r;
		int t=a*b;

		System.out.println((t==0)?"Second":"First");

        closeInput();
	}

}

import java.util.Scanner;

public class A {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int a = sc.nextInt();
		int b = sc.nextInt();
		int r = sc.nextInt();
		if (Math.min(a, b)>=2*r){
			System.out.println("First");
		}else System.out.println("Second");

	}

}

import java.util.*;

/**
 * Created by IntelliJ IDEA.
 * User: piyushd
 * Date: 3/26/11
 * Time: 10:53 PM
 * To change this template use File | Settings | File Templates.
 */
public class TaskA {

    void run() {
        int a = nextInt(), b = nextInt(), r = nextInt();

        if (a < 2 * r || b < 2 * r) {
            System.out.println("Second");
            return;
        }

        System.out.println("First");
    }

    int nextInt(){
        try{
            int c = System.in.read();
            if(c == -1) return c;
            while(c != '-' && (c < '0' || '9' < c)){
                c = System.in.read();
                if(c == -1) return c;
            }
            if(c == '-') return -nextInt();
            int res = 0;
            do{
                res *= 10;
                res += c - '0';
                c = System.in.read();
            }while('0' <= c && c <= '9');
            return res;
        }catch(Exception e){
            return -1;
        }
    }

    long nextLong(){
        try{
            int c = System.in.read();
            if(c == -1) return -1;
            while(c != '-' && (c < '0' || '9' < c)){
                c = System.in.read();
                if(c == -1) return -1;
            }
            if(c == '-') return -nextLong();
            long res = 0;
            do{
                res *= 10;
                res += c-'0';
                c = System.in.read();
            }while('0' <= c && c <= '9');
            return res;
        }catch(Exception e){
            return -1;
        }
    }

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

    String next(){
        try{
            StringBuilder res = new StringBuilder("");
            int c = System.in.read();
            while(Character.isWhitespace(c))
                c = System.in.read();
            do{
                res.append((char)c);
            }while(!Character.isWhitespace(c=System.in.read()));
            return res.toString();
        }catch(Exception e){
            return null;
        }
    }

    String nextLine(){
        try{
            StringBuilder res = new StringBuilder("");
            int c = System.in.read();
            while(c == '\r' || c == '\n')
                c = System.in.read();
            do{
                res.append((char)c);
                c = System.in.read();
            }while(c != '\r' && c != '\n');
            return res.toString();
        }catch(Exception e){
            return null;
        }
    }

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

import java.util.Arrays;
import java.util.List;
import java.util.Scanner;

public class Main {
    public static void main(String[] Args) {
        int a=si(),b=si(),r=si();
        if ( 2*r > Math.min(a, b)) System.out.println("Second");
        else System.out.println("First");

    }

    static Scanner scan = new Scanner(System.in);
    static int INF = 2147483647;

    static List<String> toList(String[] a) {
        return Arrays.asList(a);
    }

    static String[] toArray(List<String> a) {
        String[] o = new String[a.size()];
        a.toArray(o);
        return o;
    }

    static int si() {
        return scan.nextInt();
    }

    static String ss() {
        return scan.nextLine();
    }

    static int[] sai(int n) {
        int[] a = new int[n];
        for (int i = 0; i < a.length; i++)
            a[i] = si();

        return a;
    }

    static String[] sas(int n) {
        String[] a = new String[n];
        for (int i = 0; i < a.length; i++)
            a[i] = ss();
        return a;
    }

    static Object[][] _sm1(int r, int c) {
        Object[][] a = new Object[r][c];
        for (int i = 0; i < r; i++)
            for (int j = 0; j < c; j++)
                a[i][j] = scan.next();
        return a;
    }

    static Object[][] _sm2(int r) {
        Object[][] a = new Object[r][3];
        for (int i = 0; i < r; i++)
            a[i] = new Object[] { ss(), ss(), ss() };
        return a;
    }
}

import java.util.Scanner;

public class A {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        int b = sc.nextInt();
        int r = sc.nextInt();
        if (2*r>Math.min(a, b)) System.out.println("Second");
        else System.out.println("First");
    }

}

import java.util.Scanner;

public class program{
	public static int min(int a,int b){
		return a < b ? a : b;
	}
	public static void main(String args[]){
		Scanner input = new Scanner(System.in);
		//System.out.println(input.nextLine());
		int a,b,r;

		a = input.nextInt();
		b = input.nextInt();
		r = input.nextInt();

		if(2*r > min(a,b)){
			System.out.println("Second");
		}
		else{
			System.out.println("First");
		}
	}
}

import java.util.Scanner;

public class C_124A {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int a = sc.nextInt();
		int b = sc.nextInt();
		int r = sc.nextInt();
		if(2*r>Math.min(a, b))System.out.println("Second");else System.out.println("First");
	}
}

import java.util.Scanner;
public class P1{

    public static void main(String[] args) {
        Scanner t = new Scanner(System.in);
        int l1 = t.nextInt();
        int l2 = t.nextInt();
        int r = t.nextInt();

        int d = r*2;

        if(l1>=d && l2>=d){
            System.out.println("First");
        }else{
            System.out.println("Second");
        }
    }

}

import java.util.*;
public class Platos {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Scanner in=new Scanner(System.in);
		int alto=in.nextInt();
		int ancho=in.nextInt();
		int radio=in.nextInt();
		int total=(alto*ancho)/radio;

		if(total%2==0){

			System.out.println("First");

		}else{

			System.out.println("Second");

		}

	}

}

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

public class Main {

    public static void main(String[] args) throws Exception{
        PrintWriter out = new PrintWriter(System.out,true);
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(in.readLine());
        int a = Integer.parseInt(st.nextToken());
        int b = Integer.parseInt(st.nextToken());
        int r = Integer.parseInt(st.nextToken());
        int c = (a/(2*r))*(b/(2*r));
        if(a < 2*r && b < 2*r) {
            out.println("Second");
            return;
        }
        if(c % 2 == 1) {
            out.println("First");
        }else{
            out.println("Second");
        }

    }
}

import java.util.*;
import java.lang.*;

public class PlateGame{

	public static void main(String[] args) {

		Scanner in = new Scanner(System.in);
		int a = in.nextInt();
		int b = in.nextInt();
		int r = in.nextInt();

		if((a/(2*r) * b/(2*r)) % 2 == 0)
			System.out.println("Second");
		else
			System.out.println("First");

		}

}

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

/**
 *
12345
FSFSF
SFSFS
 * */
public class A_Div2_124 {
    public static void main(String[]arg) throws IOException
    {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        int a,b,r,m,n;
        StringTokenizer st = new StringTokenizer(in.readLine());
        a = Integer.parseInt(st.nextToken());
        b = Integer.parseInt(st.nextToken());
        r = Integer.parseInt(st.nextToken())*2;
        if(r > a || r > b)
            System.out.println("Second");
        else
        {
            n = Math.max(a, b);
            m = Math.min(a, b);
            n /= r; m /= r;
            if(n%2 == 0)
            {
                if(m%2 == 0)
                    System.out.println("First");
                else
                    System.out.println("Second");
            }
            else
            {
                if(m%2 == 0)
                    System.out.println("Second");
                else
                    System.out.println("First");
            }
        }
    }
}

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

public class Main {
    public static void main(String[] args) {
        InputReader in = new InputReader(System.in);
        PrintWriter out = new PrintWriter(System.out);
        int a = in.nextInt(), b = in.nextInt(), r = in.nextInt();
        if (b < 2 * r || a < 2 * r)
            out.println("Second");
        else
            out.println("First");
    }
}

class InputReader {
    private BufferedReader reader;
    private StringTokenizer tokenizer;

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

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

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

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

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

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

import java.util.*;
import java.io.*;
public class rc {
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		int a=sc.nextInt();
		int b=sc.nextInt();
		int r=sc.nextInt();
		int flag=0;
		int m=Math.max(a,b);
		//System.out.println("m"+ m);
		if ((2*r)>m) {
			flag=1; //System.out.println("hey0");
		}

		int l=m/(2*r);
		//System.out.println("l"+ l);
		if(l==0) {
			flag=1;//System.out.println("hey");
		}
		else if (l%2==0) {
			flag=0;//System.out.println("hey2");
		}

		else
		{	flag=0;//System.out.println("hey3");
		}

		//System.out.println(flag);
		if (flag==1)
			System.out.println("Second");
		else
			System.out.println("First");
	}
}

	import java.io.BufferedWriter;
		import java.io.IOException;
		import java.io.OutputStreamWriter;
		import java.io.ObjectInputStream.GetField;
		import java.math.BigInteger;
		import java.util.ArrayList;
		import java.util.Arrays;
		import java.util.Collections;
		import java.util.HashMap;
		import java.util.HashSet;
		import java.util.InputMismatchException;
		import java.util.LinkedList;
	import java.util.PriorityQueue;
	import java.util.Queue;
		import java.util.Stack;
		import java.util.TreeMap;
		import java.util.TreeSet;
public	class Q2 {
			static int MOD = 1000000007;
			static boolean b[];
			static boolean boo[][];
			static ArrayList<Integer>[] amp, amp2;
			static HashMap<ArrayList<Integer>,Integer> ts1 = new HashMap<>();
			static int sum[],dist[],array[];
			static long ans = 0;
			static int p = 0;
			static int color[][],brr[][];
			static HashSet<Integer>[][] hrr;
			static FasterScanner sc = new FasterScanner();
			static Queue<Integer> q = new LinkedList<>();
			static Queue<Pair> qu = new LinkedList<>();
			static ArrayList<Pair>[][] arr;
			static ArrayList<Graph>[] amp1;
			static ArrayList<Integer> parent = new ArrayList<>();
			static BufferedWriter log;
			static TreeMap<Integer,LinkedList<Pair>> tm;
			static HashSet<Integer> hs;
			static Stack<Integer> s = new Stack<>();
			static Pair prr[];
			static char ch[][];
			static int prime[];
			static long d,x,y;
			static int n,k,m;
			public static void main(String[] args) throws IOException {
				log = new BufferedWriter(new OutputStreamWriter(System.out));
				int a = sc.nextInt(), b = sc.nextInt(), r = sc.nextInt();
				for(int i= 0;i<10;i++){
					double pow = Math.pow(2, i);
					if(r>(a/pow) || r>(b/pow)){
						if(i%2==1){
							System.out.println("Second");
							break;
						}
						else{
							System.out.println("First");
							break;
						}
					}
				}
				log.close();
			}
			public static void print2DArray(int arr[][],int row, int column){
				for(int i = 0;i<row;i++){
					for(int j = 0;j<column;j++){
						System.out.print(arr[i][j]+" ");
					}
					System.out.println();
				}
			}
			public static void dfs(int x){
				b[x] = true;
				for(int i =0 ;i<amp[x].size();i++){
					if(!b[amp[x].get(i)]){
						dfs(amp[x].get(i));
					}
				}
			}
			public static void bfs2D(int x,int y){
				tm = new TreeMap<>();
				LinkedList<Pair> hs1 = new LinkedList<>();
				hs  = new HashSet<>();
				hs1.add(new Pair(x,y));
				boo[x][y] = true;
				hrr[x][y].add(brr[x][y]);
				tm.put(hrr[x][y].size(),hs1);
				while(!tm.isEmpty()){
					hs1 = tm.get(tm.firstKey());
					//System.out.println(tm);
					Pair p = hs1.pollFirst();
					//System.out.println(p);
					hs.add(brr[p.u][p.v]);
					if(hs1.isEmpty()) tm.remove(tm.firstKey());
					for(Pair temp:arr[p.u][p.v]) {
						if(!boo[temp.u][temp.v]){
							if(!hs.contains(brr[temp.u][temp.v])){
								color[temp.u][temp.v] = color[p.u][p.v]+1;
							}
							else color[temp.u][temp.v] = color[p.u][p.v];
							if(tm.containsKey(color[temp.u][temp.v])){
								if(hs.contains(brr[temp.u][temp.v]))
								tm.get(color[temp.u][temp.v]).addLast(new Pair(temp.u,temp.v));
								else{
									tm.get(color[temp.u][temp.v]).addFirst(new Pair(temp.u,temp.v));
								}
							}
							else{
								LinkedList<Pair> temp1 = new LinkedList<>();
								temp1.add(new Pair(temp.u,temp.v));
								tm.put(color[temp.u][temp.v], temp1);
							}
							boo[temp.u][temp.v] = true;
						}
					}
				}
			}
			public static void bfs(int x,int val){
				b[x] = true;
				q.add(x);
				sum[x] = val;
				while(!q.isEmpty()){
					int y = q.poll();
				//	System.out.println(y+"*"+sum[y]);
					for(int i = 0;i<amp[y].size();i++) {
						if(!b[amp[y].get(i)]){
							q.add(amp[y].get(i));
							b[amp[y].get(i)] = true;
							sum[amp[y].get(i)] = sum[y]*(-1);
						}
					}
				}
			}
			public static void toThread(String[] args) throws Exception {
		    	new Thread(null, new Runnable() {
					public void run() {
						try {
							//InputReader(System.in);
					       // pw = new PrintWriter(System.out);
					        //soln();
					        //pw.close();
							//soln();
						} catch (Exception e) {
							e.printStackTrace();
						}
					}
				}, "1", 1 << 26).start();
		    }
			public static long mod(int x, int y){
				long ans = 1;
				while(y>0){
					if(y%2==1){
						ans = ((ans%MOD)*(x%MOD))%MOD;
						y-=1;
					}
					else{
						x = (int) (((x%MOD)*(x%MOD))%MOD);
						y = y/2;
					}
				}
				return ans;
			}
			static void findFactors(ArrayList<Integer> primeDivisors, ArrayList<Integer> multiplicity, int currentDivisor, long currentResult) {
			    if (currentDivisor == primeDivisors.size()) {
			      //  ts.add(currentResult);
			        return;
			    }
			    for (int i = 0; i <= multiplicity.get(currentDivisor); ++i) {
			        findFactors(primeDivisors, multiplicity, currentDivisor + 1, currentResult);
			        currentResult *= primeDivisors.get(currentDivisor);
			    }
			}
			public static void seive(long n){
				b = new boolean[(int) (n+1)];
				Arrays.fill(b, true);
				b[0] =false;
				b[1] = true;
				for(int i = 2;i*i<=n;i++){
					if(b[i]){
						for(int p = 2*i;p<=n;p+=i){
							b[p] = false;
						}
					}
				}
				for(int i = 0;i<n;i++) if(b[i]) parent.add(i);
			}
			public static void factors(int n){
				b = new boolean[n+1];
				prime = new int[n+1];
				Arrays.fill(b, true);
				b[0] =false;
				b[1] = false;
				for(int i = 2;i*i<=n;i++){
					if(b[i]){
						prime[i] = i;
						for(int p = 2*i;p<=n;p+=i){
							if(b[p]){
							b[p] = false;
							prime[p] = i;
							}
						}
					}
				}
				for(int i = 2;i<=n;i++){
					if(b[i]) prime[i] = i;
				}
			}
			public static void buildWeightedGraph(int m){
				for(int i = 0; i<m;i++){
					int x = sc.nextInt(), y = sc.nextInt(), w = sc.nextInt();
					amp1[--x].add(new Graph(--y,w));
					amp1[y].add(new Graph(x,w));
				}
			}
			public static void extendedEuclidian(long a, long b){
				if(b == 0) {
			        d = a;
			        x = 1;
			        y = 0;
			    }
			    else {
			        extendedEuclidian(b, a%b);
			        int temp = (int) x;
			        x = y;
			        y = temp - (a/b)*y;
			    }
			}
			private static void permutation(String prefix, String str) {
			    int n = str.length();
			   // if (n == 0) ts.add(prefix);
			  //  else {
			        for (int i = 0; i < n; i++)
			            permutation(prefix + str.charAt(i), str.substring(0, i) + str.substring(i+1, n));
			   //}
			}
			public static char give(char c1,char c2){
				if(c1!='a' && c2!='a') return 'a';
				if(c1!='b' && c2!='b') return 'b';
				return 'c';
			}
			static class Graph{
				int vertex;
				long weight;
				Graph(int v,int w){
					vertex = v;
					weight = w;
				}
			}
			public static void buildTree(int n){
				int arr[] = sc.nextIntArray(n);
				for(int i = 0;i<n;i++){
					int x = arr[i]-1;
					amp[i+1].add(x);
					amp[x].add(i+1);
				}
			}

			public static void buildGraph(int n){

				for(int i =0;i<n;i++){
					int x = sc.nextInt(), y = sc.nextInt();
					amp[--x].add(--y);
					//amp[y].add(x);
				}
			}

			static class Pair implements Comparable<Pair> {
				int u;
				int v;
				int z;
				public Pair(){

				}
				public Pair(int u, int v) {
					this.u = u;
					this.v = v;
				}

				public int hashCode() {
					int hu = (int) (u ^ (u >>> 32));
					int hv = (int) (v ^ (v >>> 32));
					return 31*hu + hv;
				}

				public boolean equals(Object o) {
					Pair other = (Pair) o;
					return (u == other.u && v == other.v);
				}

				public int compareTo(Pair other) {
					return Integer.compare(other.u, u) != 0 ? (Integer.compare(other.u, u)) : (Integer.compare(v, other.v));
				}

				public String toString() {
					return "[u=" + u + ", v=" + v + "]";
				}
			}
			static class SegmentTree{
				long st[];
				char ch[];
				boolean lazy[];
				SegmentTree(int n){
					int size = 4*n;
					//ch = str.toCharArray();
					st = new long[size];
					lazy = new boolean[size];
					build(ch,0,n-1,0);
				}
				long build(char str[], int ss, int se, int si){
					if(ss==se){
						return 0;
					}
					int mid = (ss+se)/2;
					 st[si] = build(str,ss,mid,si*2+1) + build(str,mid+1,se,si*2+2);

					return st[si];
				}
				/*void updateRange(int node, int start, int end, int l, int r, boolean val)
				{
				//	System.out.println(lazy[node]+" "+node);
				    if(lazy[node])
				    {
				        // This node needs to be updated
				    	long temp = st[node][0];
				    	st[node][0] = st[node][1];
				    	st[node][1] = temp; // Update it
				        if(start != end)
				        {
				            lazy[node*2+1] = lazy[node];                  // Mark child as lazy
				            lazy[node*2+2] = lazy[node];                // Mark child as lazy
				        }
				        lazy[node] = false;                                  // Reset it
				    }
				    if(start > end || start > r || end < l)              // Current segment is not within range [l, r]
				        return;
				    if(start >= l && end <= r)
				    {
				        // Segment is fully within range
				    	if(val){
				    	long temp = st[node][0];
				    	st[node][0] = st[node][1];
				    	st[node][1] = temp;
				        if(start != end)
				        {
				            // Not leaf node
				        	lazy[node*2+1] = val;                  // Mark child as lazy
				            lazy[node*2+2] = val;
				        }
				    	}
				        return;
				    }
				    int mid = (start + end) / 2;
				    updateRange(node*2+1, start, mid, l, r, val);        // Updating left child
				    updateRange(node*2 + 2, mid + 1, end, l, r, val);   // Updating right child
				    st[node][0] = st[node*2+1][0] + st[node*2+2][0];
				    st[node][1] = st[node*2+1][1] + st[node*2+2][1];// Updating root with max value
				}
				long[] queryRange(int node, int start, int end, int l, int r)
				{
				    if(start > end || start > r || end < l)
				        return new long[]{0,0};         // Out of range
				    if(lazy[node])
				    {
				    	long temp = st[node][0];
				    	st[node][0] = st[node][1];
				    	st[node][1] = temp; // Update it
				        if(start != end)
				        {
				            lazy[node*2+1] = lazy[node];                  // Mark child as lazy
				            lazy[node*2+2] = lazy[node];                // Mark child as lazy
				        }
				        lazy[node] = false;                  // Reset it
				    }
				    if(start >= l && end <= r)             // Current segment is totally within range [l, r]
				        return st[node];
				    int mid = (start + end) / 2;
				    long p1[] = queryRange(node*2+1, start, mid, l, r);         // Query left child
				    long p2[] = queryRange(node*2 + 2, mid + 1, end, l, r); // Query right child
				    p1[0]+=p2[0];
				    p1[1]+=p2[1];
				    return p1;
				}*/

				long get(int qs, int qe, int ss, int se, int si){
					if(qe<ss || qs>se){
						return 0;
					}
					if(qs<=ss && qe>=se) return st[si];
					int mid = (ss+se)/2;
		            return (get(qs,qe,ss,mid,2*si+1)+get(qs,qe, mid+1, se, 2*si+2));
				}
				void update(int ss,int se,int si,int idx){
					if(ss==se){
						st[si]++;
						//str[idx] = 1;
					}
					else{
						int mid = (ss+se)/2;
						if(ss<=idx && idx<=mid) update(ss,mid,2*si+1,idx);
						else update(mid+1,se,2*si+2,idx);
						st[si] = (st[2*si+1]+st[2*si+2]);
					}
				}
				void print(){
					for(int i = 0;i<st.length;i++){
						System.out.print(st[i]+" ");
					}
					System.out.println();
				}
			}
			static int convert(int x){
				int cnt = 0;
				String str = Integer.toBinaryString(x);
				//System.out.println(str);
				for(int i = 0;i<str.length();i++){
					if(str.charAt(i)=='1'){
						cnt++;
					}
				}
				int ans = (int) Math.pow(3, 6-cnt);
				return ans;
			}
			static class Node2{
				Node2 left = null;
				Node2 right = null;
				Node2 parent = null;
				int data;
			}
			static class Node{
				int data;
				Node arr[] = new Node[2];
				Node(){
					data = 0;
					arr[0] = null;
					arr[1] = null;
				}
			}
			static class Trie{
				 Node root = new Node();
				public  void insert(int y){
					int qrr[] = new int[30];
					Node temp = root;
					int x = y;
					for(int i =0 ; i<= 29;i++){
						qrr[i] = x%2;
						x/=2;
					}
					for(int i = 29;i>=0;i--){
						if(temp.arr[qrr[i]] != null){
							temp = temp.arr[qrr[i]];
						}
						else{
							temp.arr[qrr[i]] = new Node();
							temp = temp.arr[qrr[i]];
						}
					}
					temp.data = y;
				}
				public  int query(int y){
					int qrr[] = new int[30];
					Node temp = root;
					int x = y;
					for(int i =0 ; i< 30;i++){
						qrr[i] = x%2;
						x/=2;
					}
					for(int i = 29;i>=0;i--){
						if(temp.arr[1-qrr[i]] != null){
							temp = temp.arr[1-qrr[i]];
						}
						else {//if(temp.arr[qrr[i]] != null){
							temp = temp.arr[qrr[i]];
						}
					}
					return temp.data^y;
				}
			}
			static class BinarySearchTree{
				Node2 root = null;
				int height = 0;
				int max = 0;
				int cnt = 1;
				ArrayList<Integer> parent = new ArrayList<>();
				HashMap<Integer, Integer> hm = new HashMap<>();
				public void insert(int x){
					Node2 n = new Node2();
					n.data = x;
					if(root==null){
						root = n;
					}
					else{
						Node2 temp = root,temp2 = null;
						while(temp!=null){
							temp2 = temp;
							if(x>temp.data) temp = temp.right;
							else temp = temp.left;
						}
						if(x>temp2.data) temp2.right = n;
						else temp2.left = n;
						n.parent = temp2;
						parent.add(temp2.data);
					}
				}
				public Node2 getSomething(int x, int y, Node2 n){
					if(n.data==x || n.data==y) return n;
					else if(n.data>x && n.data<y) return n;
					else if(n.data<x && n.data<y) return getSomething(x,y,n.right);
					else return getSomething(x,y,n.left);
				}
				public Node2 search(int x,Node2 n){
					if(x==n.data){
						max = Math.max(max, n.data);
						return n;
					}
					if(x>n.data){
						max = Math.max(max, n.data);
						return search(x,n.right);
					}
					else{
						max = Math.max(max, n.data);
						return search(x,n.left);
					}
				}
				public int getHeight(Node2 n){
					if(n==null) return 0;
					height = 1+ Math.max(getHeight(n.left), getHeight(n.right));
					return height;
				}
			}
			static long findDiff(long[] arr, long[] brr, int m){
				int i = 0, j = 0;
				long fa = 1000000000000L;
				while(i<m && j<m){
					long x = arr[i]-brr[j];
					if(x>=0){
						if(x<fa) fa = x;
						j++;
					}
					else{
						if((-x)<fa) fa = -x;
						i++;
					}
				}
				return fa;
			}
			public static long max(long x, long y, long z){
				if(x>=y && x>=z) return x;
				if(y>=x && y>=z) return y;
				return z;
			}

			static long modInverse(long a, long mOD2){
			            return  power(a, mOD2-2, mOD2);
			}
			static long power(long x, long y, long m)
			{
			    if (y == 0)
			        return 1;
			    long p = power(x, y/2, m) % m;
			    p = (p * p) % m;

			    return (y%2 == 0)? p : (x * p) % m;
			}
			static long power2(long x,BigInteger y,long m){
				long ans = 1;
				BigInteger two = new BigInteger("2");
				while(y.compareTo(BigInteger.ZERO)>0){
					if(y.getLowestSetBit()==y.bitCount()){
						x = (x*x)%MOD;
						y = y.divide(two);
					}
					else{
						ans = (ans*x)%MOD;
						y = y.subtract(BigInteger.ONE);
					}
				}
				return ans;
			}
			static BigInteger power2(BigInteger x, BigInteger y, BigInteger m){
				BigInteger ans = new BigInteger("1");
				BigInteger one  = new BigInteger("1");
				BigInteger two  = new BigInteger("2");
				BigInteger zero  = new BigInteger("0");
				while(y.compareTo(zero)>0){
					//System.out.println(y);
					if(y.mod(two).equals(one)){
						ans = ans.multiply(x).mod(m);
						y = y.subtract(one);
					}
					else{
						x = x.multiply(x).mod(m);
						y = y.divide(two);
					}
				}
				return ans;
			}
			static BigInteger power(BigInteger x, BigInteger y, BigInteger m)
			{
			    if (y.equals(0))
			        return (new BigInteger("1"));
			    BigInteger p = power(x, y.divide(new BigInteger("2")), m).mod(m);
			    p = (p.multiply(p)).mod(m);

			    return (y.mod(new BigInteger("2")).equals(0))? p : (p.multiply(x)).mod(m);
			}

			public static long gcd(long n, long m){
				if(m!=0) return gcd(m,n%m);
				else return n;
			}

			public static class FasterScanner {
				private byte[] buf = new byte[1024];
				private int curChar;
				private int numChars;

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

				public String nextLine() {
					int c = read();
					while (isSpaceChar(c))
						c = read();
					StringBuilder res = new StringBuilder();
					do {
						res.appendCodePoint(c);
						c = read();
					} while (!isEndOfLine(c));
					return res.toString();
				}

				public String nextString() {
					int c = read();
					while (isSpaceChar(c))
						c = read();
					StringBuilder res = new StringBuilder();
					do {
						res.appendCodePoint(c);
						c = read();
					} while (!isSpaceChar(c));
					return res.toString();
				}

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

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

			    public int[] nextIntArray(int n) {
			        return nextIntArray(n, 0);
			    }

			    public int[] nextIntArray(int n, int off) {
			    	int[] arr = new int[n + off];
			    	for (int i = 0; i < n; i++) {
			    		arr[i + off] = nextInt();
			    	}
			    	return arr;
			    }

			    public long[] nextLongArray(int n) {
			    	return nextLongArray(n, 0);
			    }

				public long[] nextLongArray(int n, int off) {
				    long[] arr = new long[n + off];
				    for (int i = 0; i < n; i++) {
				        arr[i + off] = nextLong();
				    }
				    return arr;
				}

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

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

import java.util.*;
public class Main {

    public static void main(String[] args) {
        Scanner s=new Scanner(System.in);
        int fila=s.nextInt();
        int columnas=s.nextInt();

        int total=fila*columnas;
        int radio=s.nextInt();

        if(radio>total){
            System.out.println("Second");
        }else if(radio == total){
            System.out.println("First");
        }else{
            if(total%2!=0){
                System.out.println("First");
            }else{
                System.out.println("Second");
            }
        }
    }

}

import java.io.*;
import java.util.Scanner;
import java.util.Arrays;
import java.util.Collections;
import java.lang.Math;
import java.util.ArrayList;
import java.util.*;
import java.math.*;

public class plategame{

	public static void main(String[] args) {

		Scanner sc = new Scanner(System.in);

		int a = sc.nextInt();
		int b = sc.nextInt();
		int r = sc.nextInt();

		int plate = r * 2;

		if(plate > Math.min(a,b)){
			System.out.println("Second");
		}

		else{

			int min = Math.min(a,b);

			int turn = min / plate;

			if(turn % 2 == 1){
				System.out.println("First");
			}

			else{
				System.out.println("Second");
			}

		}

	}
}

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

public class Solution {
    //<editor-fold desc="input parse" defaultstate="collapsed">

    private static StringTokenizer st;
    private static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

    private static long nextLong() {
        return Long.parseLong(st.nextToken());
    }

    private static int nextInt() {
        return Integer.parseInt(st.nextToken());
    }

    private static double nextDouble() {
        return Double.parseDouble(st.nextToken());
    }

    private static short nextShort() {
        return Short.parseShort(st.nextToken());
    }

    private static byte nextByte() {
        return Byte.parseByte(st.nextToken());
    }

    private static void initTokenizer() throws Exception {
        st = new StringTokenizer(reader.readLine());
    }

    //</editor-fold>

    public static void main(String[] args) throws Exception {
        initTokenizer();

        int a = nextInt();
        int b = nextInt();
        int r = nextInt();

        int d = r << 1;

        int all = (a / d) * (b / d);
        System.out.println(all % 2 == 1 ? "First" : "Second");
    }
}

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

public class Main197A
{
  static PrintWriter out=new PrintWriter(System.out);

  public static void main(String[] args) throws IOException
  {
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int r=sc.nextInt();
    if(2*r>a||2*r>b) out.println("Second");
    else
    {
      int f=(a*b)/(4*r*r);
      if(f%2==0)
        out.println("Second");
      else
        out.println("First");
    }
    out.flush();

  }
  static class Scanner
  {
    BufferedReader br;
    StringTokenizer tk=new StringTokenizer("");
    public Scanner(InputStream is)
        {
      br=new BufferedReader(new InputStreamReader(is));
    }
        public int nextInt() throws IOException
        {
          if(tk.hasMoreTokens())
                return Integer.parseInt(tk.nextToken());
          tk=new StringTokenizer(br.readLine());
          return nextInt();
        }
        public long nextLong() throws IOException
        {
            if(tk.hasMoreTokens())
              return Long.parseLong(tk.nextToken());
            tk=new StringTokenizer(br.readLine());
            return nextLong();
        }
        public String next() throws IOException
        {
          if(tk.hasMoreTokens())
            return (tk.nextToken());
            tk=new StringTokenizer(br.readLine());
            return next();
        }
        public String nextLine() throws IOException
        {
          tk=new StringTokenizer("");
          return br.readLine();
        }
        public double nextDouble() throws IOException
        {
            if(tk.hasMoreTokens())
              return Double.parseDouble(tk.nextToken());
            tk=new StringTokenizer(br.readLine());
            return nextDouble();
        }
        public char nextChar() throws IOException
        {
            if(tk.hasMoreTokens())
              return (tk.nextToken().charAt(0));
            tk=new StringTokenizer(br.readLine());
            return nextChar();
        }
        public int[] nextIntArray(int n) throws IOException
        {
            int a[]=new int[n];
            for(int i=0;i<n;i++)
              a[i]=nextInt();
            return a;
        }
        public long[] nextLongArray(int n) throws IOException
        {
          long a[]=new long[n];
            for(int i=0;i<n;i++)
              a[i]=nextLong();
            return a;
        }
        public int[] nextIntArrayOneBased(int n) throws IOException
        {
          int a[]=new int[n+1];
            for(int i=1;i<=n;i++)
              a[i]=nextInt();
            return a;
        }
        public long[] nextLongArrayOneBased(int n) throws IOException
        {
          long a[]=new long[n+1];
          for(int i=1;i<=n;i++)
                a[i]=nextLong();
          return a;
        }
  }
}

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

public class P197A {

  public PrintWriter run() {
    int a = sc.nextInt();
    int b = sc.nextInt();
    int r = sc.nextInt();

    if ((a < r) && (b < r)) {
      pw.println("Second");
    } else {
      pw.println(((((a / r) * (b / r)) % 2) == 0) ? "First" : "Second");
    }

    return pw;
  }

  private Scanner sc = new Scanner(new BufferedInputStream(System.in));
  private PrintWriter pw = new PrintWriter(new BufferedOutputStream(System.out));

  public static void main(String... args) throws Exception {
    new P197A().run().close();
  }
}

import java.io.InputStreamReader;
import java.io.IOException;
import java.math.BigDecimal;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.math.BigInteger;
import java.io.InputStream;

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

class TaskA {
	public void solve(int testNumber, InputReader in, PrintWriter out) {
        int a = in.nextInt();
        int b = in.nextInt();
        int r = in.nextInt();
        int s1 = (2 * r) * (2 * r);
        int v1 = a % (2 * r);
        int v2 = b % (2 * r);
        int n = ((a - v1) * (b - v2)) / s1;
        if (s1 > a * b || 2 * r > b || 2 * r > a)
            out.println("Second");
        else if (n % 2 == 0)
            out.println("Second");
        else
            out.println("First");
	}
}

class InputReader {
    private BufferedReader reader;
    private StringTokenizer tokenizer;

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

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

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

    }

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Scanner;
import java.util.StringTokenizer;

public class Main {

	static BufferedReader brscan = new BufferedReader(new InputStreamReader(
			System.in));
	static PrintWriter pw = new PrintWriter(System.out);
	static Scanner scan = new Scanner(System.in);

	public static void main(String[] args) throws IOException {
		StringTokenizer stoken;

		int a = scan.nextInt();
		int b = scan.nextInt();
		int r = scan.nextInt();

		if (Math.min(a, b)<2*r) {
			System.out.println("First");
		} else {
			System.out.println("Second");
		}

	}
}

class Node {

	int id;
	ArrayList<Node> edge;
	final int DEFAULT_SZ = 26;
	int chromatic_num = 0;

	public Node(int id) {
		this.id = id;
		edge = new ArrayList<Node>(DEFAULT_SZ);
	}

	public void addEdge(Node another) {
		edge.add(another);
	}

	public Node getEdge(int index) {
		return edge.get(index);
	}

	public String toString() {
		String edgeName = "";

		for (int n = 0; n < edge.size(); n++) {
			edgeName += " " + edge.get(n).id;
		}

		return "[" + this.id + "] - " + edgeName;
	}
}

import java.io.*;
import java.util.*;
import java.lang.Math;
import java.math.BigInteger;

public class Problem {

	public static void main(String[] args) throws IOException {

		new Problem().run();
	}

	BufferedReader in;
	PrintWriter out;
	StringTokenizer tok;
	static final boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null;
	Problem() throws FileNotFoundException{

		if (ONLINE_JUDGE) {
			in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
		} else {
			in = new BufferedReader(new FileReader("input.txt"));
			out = new PrintWriter("output.txt");
		}
		tok = new StringTokenizer("");
	}

	// ======================================================
	List<Integer>[] graph;
	int[] ans;
	boolean[] used;
	void solve() throws IOException {
		int n = rI();
		int m = rI();
		int a = rI();
		int ans=0;
		for(int i=0;i<n/(2*a);++i){
			for(int j=0;j<m/(2*a);++j){
				ans++;
			}
		}
		out.println(ans%2==0?"Second":"First");
	}

	// ======================================================
	void run() throws IOException {
		solve();
		out.close();
	}

	char[] reverseCharArray(char[] arr){
		char[] ans = new char[arr.length];
		for(int i=0;i<arr.length;++i){
			ans[i] = arr[arr.length-i-1];
		}
		return ans;
	}
	int sqrt(double m){
		int l = 0;
		int r = 1000000000+9;
		int i=1000;
		while(r-l>1){
			int mid = (r+l)/2;
			if(mid*mid>m){
				r = mid;
			}else{
				l = mid;
			}
		}
		return l;
	}
	int countPow(int m,int n){
		int ans = 0;
		while(m%n==0&&m>0){
			ans++;
			m/=n;
		}
		return ans;
	}
	long binPow(long a, long b){
		if(b == 0){
			return 1;
		}
		if(b%2==1){
			return a*binPow(a,b-1);
		}else{
			long c = binPow(a,b/2);
			return c*c;
		}

	}
	long gcd(long a, long b){
		return b==0?a:gcd(b,a%b);
	}

	long pow(long x, long k){
		long ans=1;
		for(int i=0;i<k;++i){
			ans*=x;
		}
		return ans;
	}
	//////////////////////////////////////////////////////////////////////

	String delimiter = " ";
	String readLine() throws IOException {
		return in.readLine();
	}
	String rS() throws IOException {
		while (!tok.hasMoreTokens()) {
			String nextLine = readLine();
			if (null == nextLine)
				return null;

			tok = new StringTokenizer(nextLine);
		}

		return tok.nextToken(delimiter);
	}
	int rI() throws IOException {
		return Integer.parseInt(rS());
	}

	long rL() throws IOException {
		return Long.parseLong(rS());
	}
	int[] rA(int b) {
		int a[] = new int[b];
		for (int i = 0; i < b; i++) {
			try {
				a[i] = rI();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return a;
	}

	int[] readSortedIntArray(int size) throws IOException {
	        Integer[] array = new Integer[size];

	        for (int index = 0; index < size; ++index) {
	            array[index] = rI();
	        }
	        Arrays.sort(array);

	        int[] sortedArray = new int[size];
	        for (int index = 0; index < size; ++index) {
	            sortedArray[index] = array[index];
	        }

	        return sortedArray;
	    }

}

import java.util.*;
public class Main {

   public static void main (String [] args){

   	  Scanner in = new Scanner (System.in);

   	    int a= in.nextInt();
   	      int b= in.nextInt();
   	        int r= in.nextInt();

   	        a = a/(2*r);

   	          b= b/(2*r);

   	          a = a*b;

   	          if((a*b)%2==0)
   	          	System.out.print("Second");

   	       else if((a*b)!=0)
   	  	 System.out.print("First");
   }
}

import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;
import java.util.ArrayList;
import java.util.Collections;
import java.lang.Math;

public class Lo {
    public static void main(String[] args){
      Scanner sc = new Scanner(System.in);
      int a = sc.nextInt();
      int b = sc.nextInt();
      int r = 2*sc.nextInt();
      int ans = (a/r)*(b/r);
      if(ans%2==0){
          System.out.println("Second");
      }
      else{
          System.out.println("First");
      }
    }
}

import java.util.Scanner;

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
/**
 *
 * @author KHALED
 */
public class PlateGame {
    public static void main(String[] args) {
        Scanner scan=new Scanner(System.in);
        int a=scan.nextInt();
        int b=scan.nextInt();
        int r=scan.nextInt();
        int d=r*2;
        int k=a/d,h=b/d;
        if(k==0||h==0)
        {
            System.out.println("Second");
            return;
        }
        if((k+h)%2==1)
            System.out.println("Second");
        else
            System.out.println("First");
    }
}

import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.IOException;
import java.io.BufferedReader;
import java.util.Scanner;
public class plate
{
   int a;
   int b;
   int r;
  private void run()throws IOException
  {
    //BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
	Scanner in = new Scanner(System.in);
	a = in.nextInt();
	b = in.nextInt();
	r = in.nextInt();
	int area1 = a*b;
	double area = r*r*3.14;
	int area2 = (int)area;
	if(area1>area2)
		System.out.println("First");
	else
		System.out.println("Second");
  }
  public static void main(String args[])throws IOException
  {
    new plate().run();
  }
}

import java.util.*;

/**
 * Created by IntelliJ IDEA.
 * User: piyushd
 * Date: 3/26/11
 * Time: 10:53 PM
 * To change this template use File | Settings | File Templates.
 */
public class TaskA {

    void run() {
        int a = nextInt(), b = nextInt(), r = nextInt();

        double can = ((Math.sqrt(a * a + b * b) - 2 * Math.sqrt(2) * r) / (2 * r)) + 1;

        int x = (int)(can + 1e-6);
        if (x % 2 == 0) {
            System.out.println("Second");
            return;
        }
        System.out.println("First");
    }

    int nextInt(){
        try{
            int c = System.in.read();
            if(c == -1) return c;
            while(c != '-' && (c < '0' || '9' < c)){
                c = System.in.read();
                if(c == -1) return c;
            }
            if(c == '-') return -nextInt();
            int res = 0;
            do{
                res *= 10;
                res += c - '0';
                c = System.in.read();
            }while('0' <= c && c <= '9');
            return res;
        }catch(Exception e){
            return -1;
        }
    }

    long nextLong(){
        try{
            int c = System.in.read();
            if(c == -1) return -1;
            while(c != '-' && (c < '0' || '9' < c)){
                c = System.in.read();
                if(c == -1) return -1;
            }
            if(c == '-') return -nextLong();
            long res = 0;
            do{
                res *= 10;
                res += c-'0';
                c = System.in.read();
            }while('0' <= c && c <= '9');
            return res;
        }catch(Exception e){
            return -1;
        }
    }

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

    String next(){
        try{
            StringBuilder res = new StringBuilder("");
            int c = System.in.read();
            while(Character.isWhitespace(c))
                c = System.in.read();
            do{
                res.append((char)c);
            }while(!Character.isWhitespace(c=System.in.read()));
            return res.toString();
        }catch(Exception e){
            return null;
        }
    }

    String nextLine(){
        try{
            StringBuilder res = new StringBuilder("");
            int c = System.in.read();
            while(c == '\r' || c == '\n')
                c = System.in.read();
            do{
                res.append((char)c);
                c = System.in.read();
            }while(c != '\r' && c != '\n');
            return res.toString();
        }catch(Exception e){
            return null;
        }
    }

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

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

public class Main {

    public static void main(String[] args) throws Exception{
        PrintWriter out = new PrintWriter(System.out,true);
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(in.readLine());
        int a = Integer.parseInt(st.nextToken());
        int b = Integer.parseInt(st.nextToken());
        int r = Integer.parseInt(st.nextToken());
        int c = (a/r)*(b/r);
        if(a < 2*r && b < 2*r) {
            out.println("Second");
        }
        if(c % 2 == 0) {
            out.println("First");
        }else{
            out.println("Second");
        }

    }
}

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;

/**
 * 111118315581
 *
 * -3 3 2 3 2 3 2 3 -3 3 -3 3 -3 3 2 3
 *
 * @author pttrung
 */
public class A {

    public static long x, y, gcd;
    public static int Mod = 1000000007;

    public static void main(String[] args) throws FileNotFoundException {
        Scanner in = new Scanner();
        PrintWriter out = new PrintWriter(System.out);
        // PrintWriter out = new PrintWriter(new FileOutputStream(new File("output.txt")));
        int a = in.nextInt();
        int b = in.nextInt();
        int r = in.nextInt();
        int d = 2 * r;
        int x = a/d;
        int y = a/d;
        if(x >0 && y > 0 ){
            out.println("First");
        }else{
            out.println("Second");
        }
        out.close();
    }

    public static int gcd(int a, int b) {
        if (b == 0) {
            return a;
        }
        return gcd(b, a % b);
    }

    public static void extendEuclid(long a, long b) {
        if (b == 0) {
            x = 1;
            y = 0;
            gcd = a;
            return;
        }
        extendEuclid(b, a % b);
        long x1 = y;
        long y1 = x - (a / b) * y;
        x = x1;
        y = y1;

    }

    static class Scanner {

        BufferedReader br;
        StringTokenizer st;

        public Scanner() throws FileNotFoundException {
            // System.setOut(new PrintStream(new BufferedOutputStream(System.out), true));
            br = new BufferedReader(new InputStreamReader(System.in));
            //      br = new BufferedReader(new InputStreamReader(new FileInputStream(new File("basketball_game.txt"))));
        }

        public String next() {

            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (Exception e) {
                    throw new RuntimeException();
                }
            }
            return st.nextToken();
        }

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

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

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

        public String nextLine() {
            st = null;
            try {
                return br.readLine();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }

        public boolean endLine() {
            try {
                String next = br.readLine();
                while (next != null && next.trim().isEmpty()) {
                    next = br.readLine();
                }
                if (next == null) {
                    return true;
                }
                st = new StringTokenizer(next);
                return st.hasMoreTokens();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }
    }
}

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Scanner;
import java.io.*;

public class Main {
	public static void main(String[] args) throws FileNotFoundException {
		// Scanner read = new Scanner(new FileInputStream(new
		// File("input.txt")));
		// PrintWriter out = new PrintWriter(new File("output.txt"));
		Scanner read = new Scanner(System.in);
		int area = read.nextInt() * read.nextInt(), turn = 0;
		float r = (float) (Math.pow(read.nextInt(), 2) * Math.PI);
		while(area > 0){
			turn++;
			area -= r;
		}
		if(turn % 2 != 0)
			System.out.println("Second");
		else
			System.out.println("First");

	}
}

import java.io.*;
import java.util.Scanner;
public class apples {

	public static void main(String[] args){
			Scanner sc=new Scanner(System.in);
            int a=sc.nextInt();
            int b=sc.nextInt();
            int r=sc.nextInt();
            double n1=Math.ceil(((double)a/(2*r))-1);
            double n2=Math.ceil(((double)b/(2*r))-1);
            if(n1<=0 || n2<=0) System.out.println("SECOND");
            if(n1>0 && n2>0) {
            	if((int)(n1*n2)%2==0) System.out.println("SECOND");
            	else System.out.println("FIRST");
            }

     }
}

import java.io.IOException;
import java.util.Arrays;
import java.util.Scanner;

public class first {

    /**
     * @param args
     * @throws IOException
     */

    public static void main(String[] args) throws IOException {
           Scanner sc=new Scanner(System.in);
        int a=sc.nextInt();
        int b=sc.nextInt();
        int r=sc.nextInt();
        if (r<Math.min(a, b))
            System.out.print("Second");
        else
            System.out.print("First");
        System.out.flush();

    }
}

import java.io.*;
import java.util.ArrayList;
import java.util.TreeSet;

public class Main {

	public static void main(String[] args) throws Exception {

		int a = nextInt();
		int b = nextInt();
		int r = nextInt();
		boolean winnerF = false;
		boolean[][] t = new boolean[a / 2 * r][b / 2 * r];
		if(a < r * 2 && b < r * 2) exit("Second");
		else if(a < r * 4 && b < r * 4) exit("First");
		else{
			for(int k = 0; k < b / (2 * r); k++){
				for(int i = 0; i < a / (2 * r); i++){
					t[k][i] = true;
					winnerF = !winnerF;
				}
			}
		}
		exit(winnerF ? "First" : "Second");
	}

	private static PrintWriter out =  new PrintWriter(System.out);;
	private static BufferedReader inB = new BufferedReader(new InputStreamReader(System.in));
	private static StreamTokenizer in = new StreamTokenizer(inB);

	private static void exit(Object o) throws Exception {
		out.println(o);
		out.flush();
		System.exit(0);
	}
	private static void println(Object o) throws Exception{
		out.println(o);
		out.flush();
	}
	private static void print(Object o) throws Exception{
		out.print(o);
		out.flush();
	}
	private static int nextInt() throws Exception {
		in.nextToken();
		return (int)in.nval;
	}
	private static String nextString() throws Exception {
		in.nextToken();
		return in.sval;
	}
}

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

public class Template {
    public static void main(String args[]) throws IOException{
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(in.readLine());
        int a = Integer.parseInt(st.nextToken());
        int b = Integer.parseInt(st.nextToken());
        int r = Integer.parseInt(st.nextToken());
        BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
        out.write((((a/(2*r))*(b/(2*r)))% 2 == 1)?"First":"Second");
        out.newLine();
        out.flush();
    }
}

import java.util.*;
public class Platos {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Scanner in=new Scanner(System.in);
		int alto=in.nextInt();
		int ancho=in.nextInt();
		int radio=in.nextInt();
		radio*=2;

		if(radio <= alto && radio <= ancho){

				System.out.println("First");

				System.out.println("Second");

		}else{

			System.out.println("Second");

		}

	}

}

import java.util.*;

/**
 * Created by IntelliJ IDEA.
 * User: piyushd
 * Date: 3/26/11
 * Time: 10:53 PM
 * To change this template use File | Settings | File Templates.
 */
public class TaskA {

    void run() {
        int a = nextInt(), b = nextInt(), r = nextInt();

        double can = ((Math.sqrt(a * a + b * b)) - 2 * Math.sqrt(2) * r) / (2 * r) + 1;

        int x = (int)(can + 1e-6);
        if (x % 2 == 0) {
            System.out.println("Second");
            return;
        }
        System.out.println("First");
    }

    int nextInt(){
        try{
            int c = System.in.read();
            if(c == -1) return c;
            while(c != '-' && (c < '0' || '9' < c)){
                c = System.in.read();
                if(c == -1) return c;
            }
            if(c == '-') return -nextInt();
            int res = 0;
            do{
                res *= 10;
                res += c - '0';
                c = System.in.read();
            }while('0' <= c && c <= '9');
            return res;
        }catch(Exception e){
            return -1;
        }
    }

    long nextLong(){
        try{
            int c = System.in.read();
            if(c == -1) return -1;
            while(c != '-' && (c < '0' || '9' < c)){
                c = System.in.read();
                if(c == -1) return -1;
            }
            if(c == '-') return -nextLong();
            long res = 0;
            do{
                res *= 10;
                res += c-'0';
                c = System.in.read();
            }while('0' <= c && c <= '9');
            return res;
        }catch(Exception e){
            return -1;
        }
    }

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

    String next(){
        try{
            StringBuilder res = new StringBuilder("");
            int c = System.in.read();
            while(Character.isWhitespace(c))
                c = System.in.read();
            do{
                res.append((char)c);
            }while(!Character.isWhitespace(c=System.in.read()));
            return res.toString();
        }catch(Exception e){
            return null;
        }
    }

    String nextLine(){
        try{
            StringBuilder res = new StringBuilder("");
            int c = System.in.read();
            while(c == '\r' || c == '\n')
                c = System.in.read();
            do{
                res.append((char)c);
                c = System.in.read();
            }while(c != '\r' && c != '\n');
            return res.toString();
        }catch(Exception e){
            return null;
        }
    }

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

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

public class PlateGame
{

	public static void main(String args[])
	{

		FastReader sc= new FastReader();
		PrintWriter out = new PrintWriter(System.out);

		int a,b,r,i,j;
		String s;

		a=sc.nextInt();
		b=sc.nextInt();
		r=sc.nextInt();
		int recArea=a*b;
		int plateArea=(int)3.14*r*r;
		int total=0;
		int count=0,nop=1;
		total=plateArea*nop;
		while(recArea-total>=plateArea) {
			nop++;
			total=plateArea*nop;
			count++;
		}
		if(count%2==0)
		out.println("Second");
		else
			out.println("First");

		out.close();
	}

	/*
		FASTREADER
	*/
	static class FastReader
    	{
        BufferedReader br;
        StringTokenizer st;

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

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

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

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

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

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

		/*DEFINED BY ME
		*/
		int[] readArray(int n){

			int arr[]=new int[n];

			for(int i=0;i<n;i++)
				arr[i]=nextInt();

			return arr;
		}
    }
}

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

public class Template {
    public static void main(String args[]) throws IOException{
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(in.readLine());
        int a = Integer.parseInt(st.nextToken());
        int b = Integer.parseInt(st.nextToken());
        int r = Integer.parseInt(st.nextToken());
        BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
        out.write((((int)Math.floor((a*b)/(Math.PI*r*r)))% 2 == 1)?"First":"Second");
        out.newLine();
        out.flush();
    }
}

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

public class Main implements Runnable {

	private void solve() throws IOException {
		int a = nextInt();
		int b = nextInt();
		int r = 2 * nextInt();

		int t = ((a / r) * (b / r));
		// out.println("t = " + t);
		out.println(t % 2 == 0 ? "Second" : "First");
	}

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

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

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

	String next() throws IOException {
		while (!st.hasMoreTokens()) {
			String line = in.readLine();
			if (line == null)
				return null;
			eat(line);
		}
		return st.nextToken();
	}

	public static void main(String[] args) {
		new Thread(null, new Main(), "Main", 1 << 28).start();
	}

	private BufferedReader in;
	private PrintWriter out;
	private StringTokenizer st;

	@Override
	public void run() {
		try {
			Locale.setDefault(Locale.US);
			in = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(System.out);
			eat("");
			solve();
			in.close();
			out.close();
		} catch (IOException e) {
			e.printStackTrace();
			System.exit(566);
		}
	}

	private void eat(String s) {
		st = new StringTokenizer(s);
	}

}

import java.util.*;
public class pg124{
 public static void main(String[] args)
    {
        Scanner obj = new Scanner(System.in);
        String nm=obj.nextLine();
        String[] arr_num = nm.split(" ");
        int a=Integer.parseInt(arr_num[0]);
        int b=Integer.parseInt(arr_num[1]);
        int r=Integer.parseInt(arr_num[2]);
        int d=2*r;
        int max=Math.max(a,b);
        if(max>=d)
        System.out.println("First");
        else
        System.out.println("Second");
}
}

/* package whatever; // don't place package name! */

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

/* Name of the class has to be "Main" only if the class is public. */
public class Ideone
{
	public static void main (String[] args) throws java.lang.Exception
	{
		// your code goes here
		Scanner sc=new Scanner(System.in);
		int a=sc.nextInt();
		int b=sc.nextInt();
		int r=sc.nextInt();
		int max=Math.max(a,b);
		int n=0;
		if(max>=2*r)
		 n=max/(2*r);

		if(n%2==1)
		System.out.println("First");
		else
		System.out.println("Second");

	}
}

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

public class Main {

	public static void main(String[] args) throws IOException {

		Scanner sc = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);

		int a = sc.nextInt(), b = sc.nextInt(), r = sc.nextInt() * 2;
		if((a / r) * (b / r) % 2 == 1)
			out.println("First");
		else
			out.println("Second");
		out.close();
	}

	static class Scanner
	{
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s){	br = new BufferedReader(new InputStreamReader(s));}

		public Scanner(String s) throws FileNotFoundException {	br = new BufferedReader(new FileReader(s));}

		public String next() throws IOException
		{
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

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

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

		public String nextLine() throws IOException {return br.readLine();}

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

		public boolean ready() throws IOException {return br.ready();}
	}
}

import java.io.*;
import java.util.ArrayList;
import java.util.TreeSet;

public class Main {

	public static void main(String[] args) throws Exception {

		int a = nextInt();
		int b = nextInt();
		int r = nextInt();
		int[][] t = new int[a / r][b / r];
		if(a < r * 2 && b < r * 2) exit("Second");
		else if(a < r * 4 && b < r * 4) exit("First");
		else{
			if(a / 2 * r % 2 == 0) exit("Second");
			else exit("First");
		}
	}

	private static PrintWriter out =  new PrintWriter(System.out);;
	private static BufferedReader inB = new BufferedReader(new InputStreamReader(System.in));
	private static StreamTokenizer in = new StreamTokenizer(inB);

	private static void exit(Object o) throws Exception {
		out.println(o);
		out.flush();
		System.exit(0);
	}
	private static void println(Object o) throws Exception{
		out.println(o);
		out.flush();
	}
	private static void print(Object o) throws Exception{
		out.print(o);
		out.flush();
	}
	private static int nextInt() throws Exception {
		in.nextToken();
		return (int)in.nval;
	}
	private static String nextString() throws Exception {
		in.nextToken();
		return in.sval;
	}
}

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.util.*;

public class A
{
	BufferedReader in;
	PrintStream out;
	StringTokenizer tok;
	public A() throws NumberFormatException, IOException
	{
		in = new BufferedReader(new InputStreamReader(System.in));
		//in = new BufferedReader(new FileReader("in.txt"));
		out = System.out;
		run();
	}
	void run() throws NumberFormatException, IOException
	{
		int a = nextInt();
		int b = nextInt();
		if(a%2==0 || b%2==0) out.println("Second");
		else out.println("First");
	}
	public static void main(String[] args) throws NumberFormatException, IOException
	{
		new A();
	}
	String nextToken() throws IOException
	{
		if(tok ==null || !tok.hasMoreTokens()) tok = new StringTokenizer(in.readLine());
		return tok.nextToken();
	}
	int nextInt() throws NumberFormatException, IOException
	{
		return Integer.parseInt(nextToken());
	}
	long nextLong() throws NumberFormatException, IOException
	{
		return Long.parseLong(nextToken());
	}
	double nextDouble() throws NumberFormatException, IOException
	{
		return Double.parseDouble(nextToken());
	}
}

import java.util.Arrays;
import java.io.*;
import java.util.*;
public class task implements Runnable {
    public static void main(String[] args) {
        new Thread(new task()).run();
    }
    BufferedReader br;
    StringTokenizer in;
    PrintWriter out;
    public String nextToken() throws IOException {
        while (in == null || !in.hasMoreTokens()) {
            in = new StringTokenizer(br.readLine());
        }
        return in.nextToken();
    }
    public String nextLine() throws IOException{
        return br.readLine();
    }
    public int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }
    public long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }
    public double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }
    public int nextTime()throws IOException {
        String s = nextToken();
        int hh = Integer.parseInt(s.substring(0,2));
        int mm = Integer.parseInt(s.substring(3,5));
        return hh*60 + mm;
    }
    public void printTime(int time){
        int h = time / 60;
        int m = time % 60;
        String s = "";
        if ( h < 10) s+="0";
        s+=h;
        s+=":";
        if ( m < 10) s+="0";
        s+=m;
        out.print(s);
    }
    public void run() {
        try {
            br = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
            solve();
            out.close();
        } catch (IOException e) {
            e.printStackTrace();
            System.exit(1);
        }
    }

    /////////////

    public void solve() throws IOException {
        int a = nextInt(),b = nextInt(), c = nextInt();
        int x = a / (2*c);
        int y = b / (2*c);
        if ( x*y % 2 == 1) out.print("First"); else out.println("Second");
    }
}

import java.util.*;
public class Platos {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Scanner in=new Scanner(System.in);
		int alto=in.nextInt();
		int ancho=in.nextInt();
		int radio=in.nextInt();
		int total=(alto*ancho)/radio;

		if(total%2==0){

			System.out.println("First");

		}else{

			System.out.println("Second");

		}

	}

}

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

/**
 *
 * @author Utsav
 */
import java.util.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class PlateGame {
    static class FastReader {

        BufferedReader br;
        StringTokenizer st;

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

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

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

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

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

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }
    public static void main(String[] args) {
        FastReader s = new FastReader();
        int a = s.nextInt();
        int b = s.nextInt();
        int r   = s.nextInt();
        double ca = Math.PI*r*r;
        double sa = 4*r*r;
        double ta = a*b;
        double nt = ta/ca;
        int np = (int) nt;
        double sp = ta/sa;
        int sq = (int) sp;
        int max;
        int wid;
        if(a>=b){
            max = a;
            wid = b;
        }else{
            max = b;
            wid = a;
        }

        int hor = max/(2*r);
        int ver = wid/(2*r);
        //System.out.println(hor+" "+ver);
        int time = hor*ver;
        //System.out.println(time);
        if(time != 0){
            if(time % 2 == 0){
                System.out.println("Second");
            }else{
                System.out.println("First");
            }
        }else{
            System.out.println("Second");
        }

    }
}

import java.util.Scanner;

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
/**
 *
 * @author KHALED
 */
public class PlateGame {
    public static void main(String[] args) {
        Scanner scan=new Scanner(System.in);
        int a=scan.nextInt();
        int b=scan.nextInt();
        int r=scan.nextInt();
        int d=r*2;
        int k=a/d,h=b/d;
        if(k+h==0)
        {
            System.out.println("Second");
            return;
        }
        if(k+h%2==1)
            System.out.println("Second");
        else
            System.out.println("First");
    }
}

import java.io.InputStreamReader;
import java.io.IOException;
import java.math.BigDecimal;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.math.BigInteger;
import java.io.InputStream;

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

class TaskA {
	public void solve(int testNumber, InputReader in, PrintWriter out) {
        int a = in.nextInt();
        int b = in.nextInt();
        int r = in.nextInt();
        int s1 = (2 * r) * (2 * r);
        int v1 = a / (2 * r);
        int v2 = b / (2 * r);
        int n = (v1 * v2) / s1;
        if (s1 > a * b)
            out.println("Second");
        else if (n % 2 == 0)
            out.println("First");
        else
            out.println("Second");
	}
}

class InputReader {
    private BufferedReader reader;
    private StringTokenizer tokenizer;

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

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

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

    }

import java.util.Arrays;
import java.io.*;
import java.util.*;
public class task implements Runnable {
    public static void main(String[] args) {
        new Thread(new task()).run();
    }
    BufferedReader br;
    StringTokenizer in;
    PrintWriter out;
    public String nextToken() throws IOException {
        while (in == null || !in.hasMoreTokens()) {
            in = new StringTokenizer(br.readLine());
        }
        return in.nextToken();
    }
    public String nextLine() throws IOException{
        return br.readLine();
    }
    public int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }
    public long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }
    public double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }
    public int nextTime()throws IOException {
        String s = nextToken();
        int hh = Integer.parseInt(s.substring(0,2));
        int mm = Integer.parseInt(s.substring(3,5));
        return hh*60 + mm;
    }
    public void printTime(int time){
        int h = time / 60;
        int m = time % 60;
        String s = "";
        if ( h < 10) s+="0";
        s+=h;
        s+=":";
        if ( m < 10) s+="0";
        s+=m;
        out.print(s);
    }
    public void run() {
        try {
            br = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
            solve();
            out.close();
        } catch (IOException e) {
            e.printStackTrace();
            System.exit(1);
        }
    }

    /////////////

    public void solve() throws IOException {
        int a = nextInt(),b = nextInt(), c = nextInt();
        int x = a / (2*c);
        int y = b / (2*c);
        if ( x*y == 0) out.print("Second");
        if ( x*y % 2 == 1) out.print("First"); else out.println("Second");
    }
}

import java.util.*;
import java.io.*;
public class rc {
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		int a=sc.nextInt();
		int b=sc.nextInt();
		int r=sc.nextInt();
		int flag=0;
		int m=Math.max(a,b);
		//System.out.println("m"+ m);
		if ((2*r)>m) {
			flag=1; //System.out.println("hey0");
		}

		int l=m/(2*r);
		//System.out.println("l"+ l);
		if(l==0) {
			flag=1;//System.out.println("hey");
		}
		else if (l%2==0) {
			flag=1;//System.out.println("hey2");
		}

		else
		{	flag=0;//System.out.println("hey3");
		}

		//System.out.println(flag);
		if (flag==1)
			System.out.println("Second");
		else
			System.out.println("First");
	}
}

import java.util.Scanner;

public class A {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        int b = sc.nextInt();
        int r = sc.nextInt();
        int p = a/(2*r);
        int q = b/(2*r);
        if ((p*q)%2==1) System.out.println("First");
        else System.out.println("Second");
    }

}

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

public class Main implements Runnable {

	private void solve() throws IOException {
		int a = nextInt();
		int b = nextInt();
		int r = nextInt();

		// int t = (a / r) * (b / r);
		out.println(((a / r) * (b / r)) % 2 == 0 ? "First" : "Second");
	}

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

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

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

	String next() throws IOException {
		while (!st.hasMoreTokens()) {
			String line = in.readLine();
			if (line == null)
				return null;
			eat(line);
		}
		return st.nextToken();
	}

	public static void main(String[] args) {
		new Thread(null, new Main(), "Main", 1 << 28).start();
	}

	private BufferedReader in;
	private PrintWriter out;
	private StringTokenizer st;

	@Override
	public void run() {
		try {
			Locale.setDefault(Locale.US);
			in = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(System.out);
			eat("");
			solve();
			in.close();
			out.close();
		} catch (IOException e) {
			e.printStackTrace();
			System.exit(566);
		}
	}

	private void eat(String s) {
		st = new StringTokenizer(s);
	}

}

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

public class Main {

    public static void main(String[] args) throws Exception{
        PrintWriter out = new PrintWriter(System.out,true);
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(in.readLine());
        int a = Integer.parseInt(st.nextToken());
        int b = Integer.parseInt(st.nextToken());
        int r = Integer.parseInt(st.nextToken());
        int c = (a/(2*r))*(b/(2*r));
        if(a < 2*r && b < 2*r) {
            out.println("Second");
            return;
        }
        if(c % 2 == 1) {
            out.println("First");
        }else{
            out.println("Second");
        }

    }
}

import java.util.*;

public class Main {

    public static void main(String[] args) {
        Scanner s=new Scanner(System.in);
        int fila=s.nextInt();
        int columna=s.nextInt();
        int total=fila*columna;
        int radio=s.nextInt();
        radio*=radio;
        if(radio>total){
            System.out.println("Second");
        }else{
            if((total%2!=0) || (columna%2==0 && fila%2==0)){
                System.out.println("First");
            }else{
                System.out.println("Second");
            }
        }

    }

}

import java.io.IOException;
import java.util.Arrays;
import java.util.Scanner;

public class first {

    /**
     * @param args
     * @throws IOException
     */

    public static void main(String[] args) throws IOException {
           Scanner sc=new Scanner(System.in);
        int a=sc.nextInt();
        int b=sc.nextInt();
        int r=sc.nextInt();
        if (r<Math.min(a, b))
            System.out.print("Second");
        else
            System.out.print("First");
        System.out.flush();

    }
}

import java.util.Scanner;

public class PlateGame {
    public static void main(String asd[])throws Exception
    {
        Scanner in=new Scanner(System.in);
        int a=in.nextInt();
        int b=in.nextInt();
        int r=in.nextInt();
        long c=0;
        c=(a/(2*r))*(b/(2*r));
        if(c%2==0)
            System.out.println("Second");
        else
            System.out.println("First");
    }
}

import java.awt.Point;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;

public class HelloWorld implements Runnable {
    BufferedReader in;
    PrintWriter out;
    StringTokenizer tok = new StringTokenizer("");

    final boolean OJ = System.getProperty("ONLINE_JUDGE") != null;

    void init() throws FileNotFoundException {
        if (OJ) {
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
        } else {
            in = new BufferedReader(new FileReader("input.txt"));
            out = new PrintWriter("output.txt");
        }
    }

    String readString() throws IOException {
        while (!tok.hasMoreTokens()) {
            try {
                tok = new StringTokenizer(in.readLine());
            } catch (Exception e) {
                return null;
            }
        }
        return tok.nextToken();
    }

    int readInt() throws IOException {
        return Integer.parseInt(readString());
    }

    long readLong() throws IOException {
        return Long.parseLong(readString());
    }

    double readDouble() throws IOException {
        return Double.parseDouble(readString());
    }

    public static void main(String[] args) {
        new Thread(null, new HelloWorld(), "", 128 * (1L << 20)).start();
    }

    public void run() {
        try {
            init();
            solve();
            out.close();
        } catch (IOException e) {
            System.err.println(e.getMessage());
            System.exit(-1);
        }
    }

    int gcd(int a, int b) {
        if (b == 0)
            return a;
        return gcd(b, a % b);
    }

    void solve() throws IOException {
       int a = readInt();
       int b = readInt();
       int r = readInt();
       int x = a / (2*r);
       int y = b / (2*r);
       int area = (x*y);
       if (area % 2 == 0){
           out.println("Second");
       }else{
           out.println("First");
       }

    }
}

import java.util.*;

public class PlateGame{
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);

		int a = input.nextInt();
		int b = input.nextInt();
		int r = input.nextInt();

		int d = 2*r;

		String ans = "Second";

		while(d<=a && d<=b){
			// System.out.println(a+" "+b+" "+d);
			a-=d;
			b-=d;
			if(ans == "Second"){
				ans = "First";
			}
			else{
				ans = "Second";
			}
		}

		System.out.println(ans);
	}
}

import java.util.Scanner;

public class plateGame {

	public static void main(String args[]){
		Scanner sc=new Scanner(System.in);
		int a=sc.nextInt();
		int b=sc.nextInt();
		int r=sc.nextInt();
		int d=2*r;
		int cnt=0;
		while(d<a && d<b)
		{
			a=d-a;
			b=d-b;
			cnt++;
		}

		if(cnt!=0 && cnt%2!=0){
			System.out.println("First");
		}
		else{
			System.out.println("Second");
		}
	}
}

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

public class Main
{
	BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
	StringTokenizer tokenizer=null;

	public static void main(String[] args) throws IOException
	{
		new Main().execute();
	}

	void debug(Object...os)
	{
		System.out.println(Arrays.deepToString(os));
	}

	int ni() throws IOException
	{
		return Integer.parseInt(ns());
	}

	long nl() throws IOException
	{
		return Long.parseLong(ns());
	}

	double nd() throws IOException
	{
		return Double.parseDouble(ns());
	}

	String ns() throws IOException
	{
		while (tokenizer == null || !tokenizer.hasMoreTokens())
			tokenizer = new StringTokenizer(br.readLine());
		return tokenizer.nextToken();
	}

	String nline() throws IOException
	{
		tokenizer=null;
		return br.readLine();
	}

	//Main Code starts Here
	int totalCases, testNum;
	int m,n;
	int mod = 1000000007;
	void execute() throws IOException
	{
		totalCases = 1;
		for(testNum = 1; testNum <= totalCases; testNum++)
		{
			input();
			solve();
		}
	}

	void solve()
	{

	}
	int a,b,r;
	void printarr(int [] a,int b)
	{
		for(int i = 0;i<=b;i++)
		{
			if(i==0)
				System.out.print(a[i]);
			else
				System.out.print(" "+a[i]);
		}
		System.out.println();
	}

	boolean input() throws IOException
	{
		a = ni();
		b = ni();
		r = ni();
		if(r>=2*a || r>=2*b)
			System.out.println("Second");
		else
			System.out.println("First");
		return true;
	}
}

import java.util.*;
public class plateGame {

	public static void main(String[] args) {
	Scanner scn = new Scanner(System.in);
	int l=scn.nextInt();
	int b=scn.nextInt();
	int r=scn.nextInt();
	int ans=fun(l,b,r);
	ans=ans/2;
	if(ans%2==0)
		System.out.println("Second");
	else
		System.out.println("First");
	}
public static int fun(int l,int b,int r) {

	if(l==0 || b==0)
		return 0;
	int nl=(l-(2*r));
	int nb=(b-(2*r));
	int ans1=0,ans2=0;
	if(nl >=0)
	 ans1= 1+fun((nl/2),b,r);
	if(nb>=0)
	 ans2= fun(2*r,(nb/2),r);
	return 2*(ans1+ans2);
}
}

import java.util.*;
public class plateGame {

	public static void main(String[] args) {
	Scanner scn = new Scanner(System.in);
	int l=scn.nextInt();
	int b=scn.nextInt();
	int r=scn.nextInt();
	int areap=(r*2)*(r*2);
	int areat=l*b;

	boolean flag=false;
	while(areat>0) {
		areat=areat-areap;
		flag=!flag;
	}
	if(flag)
		System.out.println("Second");
	else
		System.out.println("First");
	}

}

/*
If you want to aim high, aim high
Don't let that studying and grades consume you
Just live life young
******************************
What do you think? What do you think?
1st on Billboard, what do you think of it
Next is a Grammy, what do you think of it
However you think, I’m sorry, but shit, I have no fcking interest
*******************************
I'm standing on top of my Monopoly board
That means I'm on top of my game and it don't stop
til my hip don't hop anymore
https://www.a2oj.com/Ladder16.html
*******************************
300iq as writer = Sad!
*/
import java.util.*;
import java.io.*;
import java.math.*;

   public class x197A
   {
      public static void main(String hi[]) throws Exception
      {
         BufferedReader infile = new BufferedReader(new InputStreamReader(System.in));
         StringTokenizer st = new StringTokenizer(infile.readLine());
         int A = Integer.parseInt(st.nextToken());
         int B = Integer.parseInt(st.nextToken());
         int R = Integer.parseInt(st.nextToken());
         //trash
         if(2*R > Math.min(A,B))
            System.out.println("Second");
         else
         {
            //treat circle as square
            int area = A*B;
            int cnt = area/(R*R);
            if(cnt%2 == 1)
               System.out.println("First");
            else
               System.out.println("Second");
         }
      }
   }

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Scanner;

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

    static class CF_197A {
        public void solve(int testNumber, Scanner input, PrintWriter out) {
            ShortScanner in = new ShortScanner(input);
            int a = in.i(), b = in.i(), r = in.i();
            int t = a * b / (4 * r * r);
            if (t % 2 == 0)
                out.println("Second");
            else
                out.println("First");
        }

        class ShortScanner {
            Scanner in;

            ShortScanner(Scanner in) {
                this.in = in;
            }

            int i() {
                return in.nextInt();
            }

        }

    }
}

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

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

public class NewMain_122 {

    public static void main(String[] args) {
        // TODO code application logic here
        FastReader s = new FastReader();
        int a = s.nextInt();
        int b = s.nextInt();
        int r = s.nextInt();

        int q1 = a / (r * 2);
        int q2 = b / (r * 2);
        int ans = q1 * q2;
        //System.out.println(ans);
        if (ans == 0) {
            System.out.println("Second");
        } else if (ans % 2 == 1) {
            System.out.println("First");
        } else {
            System.out.println("Second");
        }

    }

    static class FastReader {

        BufferedReader br;
        StringTokenizer st;

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

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

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

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

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

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

import java.util.Scanner;

public class plate {

	public static void main(String[] args) {
		Scanner scaner = new Scanner (System.in);
		int l= scaner.nextInt();
		int a= scaner.nextInt();
		int d= (scaner.nextInt())*2;

		double pi=3.14;
		int circ=(d*d);
		int gan=0;
		int mes=(l*a);

		for(int i=0;i<=d;i++){

			if(mes>=circ){
				mes=mes-circ;
				gan++;

			}else{
				break;
			}

		}

		if(gan%2==0){
		System.out.println("Second");
		}else{
			System.out.println("First");
		}

	}

}

import java.util.Scanner;

/**
 *
 * @author AdminHP-262
 */
public class PlateGame {

    public static void main(String[] args) throws Exception {
        Scanner scanner = new Scanner(System.in);
        int a = scanner.nextInt();
        int b = scanner.nextInt();
        int r = scanner.nextInt();

        int result = (a / (r * 2)) * (a / (r * 2));

        if (result == 0) {
            System.out.println("Second");
        } else {
            System.out.println("First");
        }
    }
}

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

/**
 * Author: Maksim Novik
 * Date: 30.06.12
 * Time: 22:34
 */
public class Round124ProblemA {

    public static void main(String[] args) {
        InputStream in = System.in;
        OutputStream out = System.out;
        InputReader reader = new InputReader(in);
        PrintWriter writer = new PrintWriter(out);
        solve(reader, writer);
        writer.close();
    }

    static void solve(InputReader in, PrintWriter out) {
        int a = in.nextInt();
        int b = in.nextInt();
        int r = in.nextInt();
        if (2 * r < a && 2 * r < b) {
            out.write("First");
        } else {
            out.write("Second");
        }
    }

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

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

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

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

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

    }
}

import java.util.*;

public class A {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int a = sc.nextInt();
		int b = sc.nextInt();
		int r = sc.nextInt();

		if (a<=2*r && b<=2*r) {
			System.out.println("Second");
		} else if (a*a + b*b >= 36 * r * r) {
			System.out.println("Second");
		} else {
			System.out.println("First");
		}
	}
}

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

public class TaskA {
    BufferedReader in;
    PrintWriter out;
    StringTokenizer tokenizer;
    Integer a, b, r, i;
    double  s1, s2, summa;

    public TaskA() {
        in = new BufferedReader(new InputStreamReader(System.in));
        out = new PrintWriter(System.out);
    }

    public void solve() throws IOException {
        a = nextInt();
        b = nextInt();
        r = nextInt();

        s1 = a*b;

        s2 = 2*Math.PI*r*r;

        if(s2>s1){
            out.println("Second");
        } else {
             out.println("First");
        }

        out.flush();
    }

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

    private int nextInt() throws NumberFormatException, IOException {
        return Integer.parseInt(nextToken());
    }

    public static void main(String[] args) throws IOException {
        long startTime = System.currentTimeMillis();
        TaskA ob = new TaskA();
        ob.solve();
        System.err.printf("%.3f\n", 1e-3 * (System.currentTimeMillis() - startTime));
    }
}

//package com.prituladima.codeforce.a2oj.div2A;

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

import static java.util.stream.IntStream.range;

public class Pro92 {

    private void solve() {

        int a = nextInt(), b = nextInt(), r = nextInt();
        int d = 2 * r;
        int A = a / d;
        int B = b / d;
        sout(((A * B) & 1) != 0 ? "First" : "Second");
    }

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

    private BufferedReader reader;
    private StringTokenizer tokenizer;
    private PrintWriter writer;

    private void run() {
        try {
            reader = new BufferedReader(new InputStreamReader(System.in));
            tokenizer = null;
            writer = new PrintWriter(System.out);
            solve();
            reader.close();
            writer.close();
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(1);
        }
    }

    private int nextInt() {
        return Integer.parseInt(nextToken());
    }

    private long nextLong() {
        return Long.parseLong(nextToken());
    }

    private double nextDouble() {
        return Double.parseDouble(nextToken());
    }

    private int[] nextArr(int size) {
        return Arrays.stream(new int[size]).map(c -> nextInt()).toArray();
    }

    private long[] nextArrL(int size) {
        return Arrays.stream(new long[size]).map(c -> nextLong()).toArray();
    }

    private double[] nextArrD(int size) {
        return Arrays.stream(new double[size]).map(c -> nextDouble()).toArray();
    }

    private char[][] nextCharMatrix(int n) {
        return range(0, n).mapToObj(i -> nextToken().toCharArray()).toArray(char[][]::new);
    }

    private int[][] nextIntMatrix(int n, int m) {
        return range(0, n).mapToObj(i -> nextArr(m)).toArray(int[][]::new);
    }

    private double[][] nextDoubleMatrix(int n, int m) {
        return range(0, n).mapToObj(i -> nextArr(m)).toArray(double[][]::new);
    }

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

    private void soutn() {
        writer.println();
    }

    private void soutn(Object o) {
        writer.println(o);
    }

    private void sout(Object o) {
        writer.print(o);
    }

    private void souf(String format, Object... args) {
        writer.printf(format, args);
    }

    private <Param> void sout(Param[] arr) {
        writer.println(Arrays.toString(arr));
    }

}

import java.util.*;

/**
 * Created by IntelliJ IDEA.
 * User: piyushd
 * Date: 3/26/11
 * Time: 10:53 PM
 * To change this template use File | Settings | File Templates.
 */
public class TaskA {

    void run() {
        int a = nextInt(), b = nextInt(), r = nextInt();

        if (a < 2 * r || b < 2 * r) {
            System.out.println("Second");
            return;
        }

        double can = ((Math.sqrt(a * a + b * b) - 2 * Math.sqrt(2) * r) / (2 * r)) + 1;

        int x = (int)(can + 1e-6);
        if (x % 2 == 0) {
            System.out.println("Second");
            return;
        }
        System.out.println("First");
    }

    int nextInt(){
        try{
            int c = System.in.read();
            if(c == -1) return c;
            while(c != '-' && (c < '0' || '9' < c)){
                c = System.in.read();
                if(c == -1) return c;
            }
            if(c == '-') return -nextInt();
            int res = 0;
            do{
                res *= 10;
                res += c - '0';
                c = System.in.read();
            }while('0' <= c && c <= '9');
            return res;
        }catch(Exception e){
            return -1;
        }
    }

    long nextLong(){
        try{
            int c = System.in.read();
            if(c == -1) return -1;
            while(c != '-' && (c < '0' || '9' < c)){
                c = System.in.read();
                if(c == -1) return -1;
            }
            if(c == '-') return -nextLong();
            long res = 0;
            do{
                res *= 10;
                res += c-'0';
                c = System.in.read();
            }while('0' <= c && c <= '9');
            return res;
        }catch(Exception e){
            return -1;
        }
    }

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

    String next(){
        try{
            StringBuilder res = new StringBuilder("");
            int c = System.in.read();
            while(Character.isWhitespace(c))
                c = System.in.read();
            do{
                res.append((char)c);
            }while(!Character.isWhitespace(c=System.in.read()));
            return res.toString();
        }catch(Exception e){
            return null;
        }
    }

    String nextLine(){
        try{
            StringBuilder res = new StringBuilder("");
            int c = System.in.read();
            while(c == '\r' || c == '\n')
                c = System.in.read();
            do{
                res.append((char)c);
                c = System.in.read();
            }while(c != '\r' && c != '\n');
            return res.toString();
        }catch(Exception e){
            return null;
        }
    }

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

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

public class Main {

    public static void main(String[] args) throws Exception{
        PrintWriter out = new PrintWriter(System.out,true);
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(in.readLine());
        int a = Integer.parseInt(st.nextToken());
        int b = Integer.parseInt(st.nextToken());
        int r = Integer.parseInt(st.nextToken());
        int c = (a/r)*(b/r);
        if(a < 2*r && b < 2*r) {
            out.println("Second");
            return;
        }
        if(c % 2 == 0) {
            out.println("First");
        }else{
            out.println("Second");
        }

    }
}

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

public class Main {
    public static void main(String[] args) {
        InputReader in = new InputReader(System.in);
        PrintWriter out = new PrintWriter(System.out);
        int a = in.nextInt(), b = in.nextInt(), r = in.nextInt();
        if (b < 2 * r || a < 2 * r)
            out.println("Second");
        else
            out.println("First");
    }
}

class InputReader {
    private BufferedReader reader;
    private StringTokenizer tokenizer;

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

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

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

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

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

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

import java.util.Scanner;

public class A {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        int b = sc.nextInt();
        int r = sc.nextInt();
        int p = a/(2*r);
        int q = b/(2*r);
        if ((p*q)%2==1) System.out.println("First");
        else System.out.println("Second");
    }

}

import java.util.*;
import java.io.*;
public class rc {
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		int a=sc.nextInt();
		int b=sc.nextInt();
		int r=sc.nextInt();
		int flag=0;
		int m=Math.max(a,b);
		//System.out.println("m"+ m);
		if ((2*r)>m) {
			flag=1;// System.out.println("hey0");
		}

		int l=m/(2*r);
		//System.out.println("l"+ l);
		if(l==0) {
			flag=0;//System.out.println("hey");
		}
		else if (l%2==0) {
			flag=1;//System.out.println("hey2");
		}

		else
		{	flag=0;//System.out.println("hey3");
		}

		//System.out.println(flag);
		if (flag==1)
			System.out.println("Second");
		else
			System.out.println("First");
	}
}

import java.io.BufferedInputStream;
import java.io.IOException;
import java.util.Scanner;

public class A197 {
	public static void main(String[] args) throws IOException {
		solve();
	}

	public static void solve()throws IOException{
		String player[] = new String[]{"First", "Second"};
		Scanner scan = new Scanner(new BufferedInputStream(System.in));
		int a = scan.nextInt();
		int b = scan.nextInt();
		int r2 = scan.nextInt() * 2;

		int c = (int)((a/r2) * (b/r2));

		System.out.println(player[1 - c%2]);
	}
}

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;

public class A {

    public static int[] x = {0, 1, 0, -1, 1, -1, 1, -1};
    public static int[] y = {1, 0, -1, 0, 1, 1, -1, -1};
    public static double[][][][] dp;

    public static void main(String[] args) {
        try {
            Scanner in = new Scanner();
            // PrintWriter out = new PrintWriter(new FileOutputStream(new File("vans.out")));
            PrintWriter out = new PrintWriter(System.out);
            int n = in.nextInt();
            int total = 0;
            int []data= new int[7];

            for(int i = 0; i < data.length; i++){
                data[i] = in.nextInt();
            }
            int index = 0;
            while(true){
                total += data[index];
                if(total >= n){
                    out.println((index + 1));
                    break;
                }
                index = (index + 1)%7;

            }

            out.close();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    static double dist(Point a, Point b) {
        long total = (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y);
        return Math.sqrt(total);
    }

    static class Point {

        int x, y;

        public Point(int x, int y) {
            this.x = x;
            this.y = y;

        }
    }

    public static boolean nextPer(int[] data) {
        int i = data.length - 1;
        while (i > 0 && data[i] < data[i - 1]) {
            i--;
        }
        if (i == 0) {
            return false;
        }
        int j = data.length - 1;
        while (data[j] < data[i - 1]) {
            j--;
        }
        int temp = data[i - 1];
        data[i - 1] = data[j];
        data[j] = temp;
        Arrays.sort(data, i, data.length);
        return true;
    }

    static class FT {

        int[] data;

        FT(int n) {
            data = new int[n];
        }

        void update(int index, int val) {
            // System.out.println("UPDATE INDEX " + index);
            while (index < data.length) {
                data[index] += val;
                index += index & (-index);

                //    System.out.println("NEXT " +index);
            }
        }

        int get(int index) {
            //  System.out.println("GET INDEX " + index);
            int result = 0;
            while (index > 0) {
                result += data[index];
                index -= index & (-index);
                // System.out.println("BACK " + index);
            }
            return result;
        }
    }

    static int gcd(int a, int b) {
        if (b == 0) {
            return a;
        } else {
            return gcd(b, a % b);
        }
    }

    static int pow(int a, int b) {
        if (b == 0) {
            return 1;
        }
        if (b == 1) {
            return a;
        }
        int val = pow(a, b / 2);
        if (b % 2 == 0) {

            return val * val;
        } else {
            return val * val * a;
        }
    }

//    static Point intersect(Point a, Point b, Point c) {
//        double D = cross(a, b);
//        if (D != 0) {
//            return new Point(cross(c, b) / D, cross(a, c) / D);
//        }
//        return null;
//    }
//
//    static Point convert(Point a, double angle) {
//        double x = a.x * cos(angle) - a.y * sin(angle);
//        double y = a.x * sin(angle) + a.y * cos(angle);
//        return new Point(x, y);
//    }
//    static Point minus(Point a, Point b) {
//        return new Point(a.x - b.x, a.y - b.y);
//    }
//
//    static Point add(Point a, Point b) {
//        return new Point(a.x + b.x, a.y + b.y);
//    }
//
//    static double cross(Point a, Point b) {
//        return a.x * b.y - a.y * b.x;
//
//
//    }
//
//    static class Point {
//
//        int x, y;
//
//        Point(int x, int y) {
//            this.x = x;
//            this.y = y;
//        }
//
//        @Override
//        public String toString() {
//            return "Point: " + x + " " + y;
//        }
//    }
    static class Scanner {

        BufferedReader br;
        StringTokenizer st;

        public Scanner() throws FileNotFoundException {
            //System.setOut(new PrintStream(new BufferedOutputStream(System.out), true));
            br = new BufferedReader(new InputStreamReader(System.in));
            //br = new BufferedReader(new FileReader(new File("vans.in")));
        }

        public String next() {

            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (Exception e) {
                    throw new RuntimeException();
                }
            }
            return st.nextToken();
        }

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

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

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

        public String nextLine() {
            st = null;
            try {
                return br.readLine();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }

        public boolean endLine() {
            try {
                String next = br.readLine();
                while (next != null && next.trim().isEmpty()) {
                    next = br.readLine();
                }
                if (next == null) {
                    return true;
                }
                st = new StringTokenizer(next);
                return st.hasMoreTokens();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }
    }
}

import java.util.*;
public class Platos {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Scanner in=new Scanner(System.in);
		int alto=in.nextInt();
		int ancho=in.nextInt();
		int radio=in.nextInt();
		radio*=2;

		if(radio <= alto && radio <= ancho){

			int aux=(alto/radio)*(ancho/radio);

			if(aux%2==0){

				System.out.println("First");

			}else{

				System.out.println("Second");

			}

		}else{

			System.out.println("Second");

		}

	}

}

import java.util.*;
public class plateGame {

	public static void main(String[] args) {
	Scanner scn = new Scanner(System.in);
	int l=scn.nextInt();
	int b=scn.nextInt();
	int r=scn.nextInt();
	int areap=(r*2)*(r*2);
	int areat=l*b;

	boolean flag=false;
	while(areat>0) {
		areat=areat-areap;
		flag=!flag;
	}
	if(flag)
		System.out.println("Second");
	else
		System.out.println("First");
	}

}

import java.io.BufferedInputStream;
import java.util.Scanner;

/**
 * Created by jizhe on 2015/12/20.
 */
public class PlateGame {
    public static void main(String[] args) {
        Scanner in = new Scanner(new BufferedInputStream(System.in));

        int a = in.nextInt();
        int b = in.nextInt();
        int r = in.nextInt();
        int num = a/(2*r)*b/(2*r);
        if( num%2 == 1 )
        {
            System.out.printf("First\n");
        }
        else
        {
            System.out.printf("Second\n");
        }
    }
}

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

/**
 *
12345
FSFSF
SFSFS
 * */
public class A_Div2_124 {
    public static void main(String[]arg) throws IOException
    {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        int a,b,r,m,n;
        StringTokenizer st = new StringTokenizer(in.readLine());
        a = Integer.parseInt(st.nextToken());
        b = Integer.parseInt(st.nextToken());
        r = Integer.parseInt(st.nextToken())*2;
        if(r > a || r > b)
            System.out.println("Second");
        else
        {
            n = Math.max(a, b);
            m = Math.min(a, b);
            n /= r; m /= r;
            if(n%2 == 0)
            {
                if(m%2 == 0)
                    System.out.println("First");
                else
                    System.out.println("Second");
            }
            else
            {
                if(m%2 == 0)
                    System.out.println("Second");
                else
                    System.out.println("First");
            }
        }
    }
}

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.StringTokenizer;

public class Main {
    Scanner in;
    PrintWriter out;

    void setIn(String fI) {

        try {
            in = new Scanner(new FileInputStream(new File(fI)));
        } catch (FileNotFoundException e) {
            throw new Error(e);
        }
    }

    void setIn() {
        in = new Scanner(System.in);
    }

    void setOut(String fO) {
        try {
            out = new PrintWriter(new FileWriter(fO));
        } catch (IOException e) {
            throw new Error(e);
        }
    }

    void setOut() {
        out = new PrintWriter(System.out);
    }

    class Scanner {
        StringTokenizer st;
        BufferedReader in;
        String del;

        Scanner(InputStream is) {
            in = new BufferedReader(new InputStreamReader(is));
            st = null;
            del = " \t\n\r\f";
        }

        void setDelimiters(String del) {
            this.del = del;
        }

        String next() {
            if (st == null || !st.hasMoreTokens()) {
                st = new StringTokenizer(nextLine(), del);
            }
            return st.nextToken();
        }

        String nextLine() {
            try {
                st = null;
                return in.readLine();
            } catch (IOException e) {
                throw new Error(e);
            }
        }

        char nextChar() {
            try {
                char ch = (char) in.read();
                while (del.indexOf(ch) >= 0)
                    ch = (char) in.read();
                return ch;
            } catch (IOException e) {
                throw new Error(e);
            }
        }

        boolean hasNext() {
            try {
                return in.ready() || (st != null && st.hasMoreTokens());
            } catch (IOException e) {
                throw new Error(e);
            }
        }

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

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

        BigInteger nextBigInteger() {
            return new BigInteger(next());
        }

        BigDecimal nextBigDecimal() {
            return new BigDecimal(next());
        }

        int[] nextIntArray(int len) {
            int[] a = new int[len];
            for (int i = 0; i < len; i++) {
                a[i] = nextInt();
            }
            return a;
        }

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

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

    void run() {
        setIn();
        setOut();
        try {
            solve();
        } finally {
            out.close();
        }
    }

    void solve() {
        double a = in.nextInt();
        double b = in.nextInt();
        double r = in.nextInt() * 2;
        int c = (int) ((a / r) * (b / r));
        if (c % 2 == 0) {
            out.println("Second");
        } else {
            out.println("First");
        }
    }
}

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.util.StringTokenizer;
import java.util.*;
import java.io.*;
public class codeforces
{
   static class Student{
       int x,y,z;
        Student(int x,int y,int z){
            this.x=x;
            this.y=y;
            this.z=z;
        }
    }
    static int prime[];
    static void sieveOfEratosthenes(int n)
    {
        // Create a boolean array "prime[0..n]" and initialize
        // all entries it as true. A value in prime[i] will
        // finally be false if i is Not a prime, else true.
        int pos=0;
        prime= new int[n+1];
        for(int p = 2; p*p <=n; p++)
        {
            // If prime[p] is not changed, then it is a prime
            if(prime[p] == 0)
            {
                // Update all multiples of p
                prime[p]=p;
                for(int i = p*p; i <= n; i += p)
                    prime[i] = p;
            }
        }
    }
static    class Sortbyroll implements Comparator<Student>
{
    // Used for sorting in ascending order of
    // roll number
    public int compare(Student c, Student b)
    {
        return b.x - c.x;
    }
}
static class FastReader
    {
        BufferedReader br;
        StringTokenizer st;

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

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

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

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

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

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

    static class Edge{
        int a,b;
        Edge(int a,int b){
            this.a=a;
            this.b=b;
        }
    }
    static class Trie{
        HashMap<Character,Trie>map;
         int c;
        Trie(){
            map=new HashMap<>();
            //z=null;
            //o=null;
            c=0;
        }
    }
    //static long ans;
    static int parent[];
    static int rank[];
    static int b[][];
    static int bo[];
    static int ho[];
    static int seg[];
    //static int pos;
   // static long mod=1000000007;
    //static int dp[][];
    static HashMap<Integer,Integer>map;
    static PriorityQueue<Student>q=new PriorityQueue<>();
    //static Stack<Integer>st;
   // static ArrayList<Character>ans;
    static ArrayList<ArrayList<Integer>>adj;
    static int ans;
    static Trie root;
    static long fac[];
    static long mod=(long)(1000000007);
    static void solve()throws IOException{
        FastReader sc=new FastReader();
        int a,b,r,x=0,y=0,t;
        t=1;
        a=sc.nextInt();
        b=sc.nextInt();
        r=sc.nextInt();
        while(t+2*r<=a)
        {
            t+=2*r;
            ++x;
        }
        t=1;
        while(t+2*r<=b){
            t+=2*r;
            ++y;
        }
        x=x*y;
        if(x%2==0)
            System.out.println("Second");
        else
            System.out.println("First");
    }
    static void build(StringBuilder sb,int n,char a){
        if(n==0)
        {
            sb.append(a);
            return;
        }
        int x=(int)Math.sqrt(2*n);
        if(x*(x+1)>2*n)
            x-=1;
        for(int i=0;i<=x;i++)
            sb.append(a);
        n-=(x*(x+1))/2;
        build(sb,n,(char)((int)a+1));
    }
    static void dfs(Trie root,int k){
        if(root==null)
            return;
        for(char i='A';i<='Z';i++){
            if(root.map.containsKey(i)){
                ans+=root.map.get(i).c/k;
                dfs(root.map.get(i),k);
            }
        }
    }
    static long nCr(long n, long r,
                                    long p)
    {
        return (fac[(int)n]* modInverse(fac[(int)r], p)
                % p * modInverse(fac[(int)(n-r)], p)
                                    % p) % p;
    }
    //static int prime[];
    //static int dp[];
    public static void main(String[] args){
        //long sum=0;
        try {
                codeforces.solve();
                } catch (Exception e) {
                    e.printStackTrace();
                }
    }
       static long modInverse(long n, long p)
    {
        return power(n, p-(long)2);
    }
 /*static long power(long x, long y, long p)
{
    long res = 1;      // Initialize result

    x = x % p;  // Update x if it is more than or
                // equal to p

    while (y > 0)
    {
        // If y is odd, multiply x with result
        if (y %(long)2!=0)
            res = (res*x) % p;

        // y must be even now
        y = y>>1; // y = y/2
        x = (x*x) % p;
    }
    return res%p;
 }*/
    public static long power(long x,long a) {
		if(a==0) return 1;
		if(a%2==1)return (x*1L*power(x,a-1))%mod;
		return (power((int)((x*1L*x)%mod),a/2))%mod;
	}
   static int find(int x)
    {
        // Finds the representative of the set
        // that x is an element of
        while(parent[x]!=x)
        {
            // if x is not the parent of itself
            // Then x is not the representative of
            // his set,
            x=parent[x];

            // so we recursively call Find on its parent
            // and move i's node directly under the
            // representative of this set
        }

        return x;
    }
    static void union(int x, int y)
    {
        // Find representatives of two sets
        int xRoot = find(x), yRoot = find(y);

        // Elements are in the same set, no need
        // to unite anything.
        if (xRoot == yRoot)
            return;

         // If x's rank is less than y's rank
        if (rank[xRoot] < rank[yRoot])

            // Then move x under y  so that depth
            // of tree remains less
            parent[xRoot] = yRoot;

        // Else if y's rank is less than x's rank
        else if (rank[yRoot] < rank[xRoot])

            // Then move y under x so that depth of
            // tree remains less
            parent[yRoot] = xRoot;

        else // if ranks are the same
        {
            // Then move y under x (doesn't matter
            // which one goes where)
            parent[yRoot] = xRoot;

            // And increment the the result tree's
            // rank by 1
            rank[xRoot] = rank[xRoot] + 1;
        }
    }
    static long gcd(long a, long b)
    {
        if (a == 0)
            return b;
        return gcd(b % a, a);
    }
}

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.StringTokenizer;

public class Main {
    Scanner in;
    PrintWriter out;

    void setIn(String fI) {

        try {
            in = new Scanner(new FileInputStream(new File(fI)));
        } catch (FileNotFoundException e) {
            throw new Error(e);
        }
    }

    void setIn() {
        in = new Scanner(System.in);
    }

    void setOut(String fO) {
        try {
            out = new PrintWriter(new FileWriter(fO));
        } catch (IOException e) {
            throw new Error(e);
        }
    }

    void setOut() {
        out = new PrintWriter(System.out);
    }

    class Scanner {
        StringTokenizer st;
        BufferedReader in;
        String del;

        Scanner(InputStream is) {
            in = new BufferedReader(new InputStreamReader(is));
            st = null;
            del = " \t\n\r\f";
        }

        void setDelimiters(String del) {
            this.del = del;
        }

        String next() {
            if (st == null || !st.hasMoreTokens()) {
                st = new StringTokenizer(nextLine(), del);
            }
            return st.nextToken();
        }

        String nextLine() {
            try {
                st = null;
                return in.readLine();
            } catch (IOException e) {
                throw new Error(e);
            }
        }

        char nextChar() {
            try {
                char ch = (char) in.read();
                while (del.indexOf(ch) >= 0)
                    ch = (char) in.read();
                return ch;
            } catch (IOException e) {
                throw new Error(e);
            }
        }

        boolean hasNext() {
            try {
                return in.ready() || (st != null && st.hasMoreTokens());
            } catch (IOException e) {
                throw new Error(e);
            }
        }

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

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

        BigInteger nextBigInteger() {
            return new BigInteger(next());
        }

        BigDecimal nextBigDecimal() {
            return new BigDecimal(next());
        }

        int[] nextIntArray(int len) {
            int[] a = new int[len];
            for (int i = 0; i < len; i++) {
                a[i] = nextInt();
            }
            return a;
        }

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

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

    void run() {
        setIn();
        setOut();
        try {
            solve();
        } finally {
            out.close();
        }
    }

    void solve() {
        int max = Math.max(in.nextInt(), in.nextInt());
        if (2 * in.nextInt() > max)
            out.println("Second");
        else
            out.println("First");

    }
}

import java.util.*;

public class Main {

    public static void main(String[] args) {
        Scanner s=new Scanner(System.in);
        int fila=s.nextInt();
        int columna=s.nextInt();
        int total=fila*columna;
        int radio=s.nextInt();
        radio*=radio;
        if(radio>total){
            System.out.println("Second");
        }else{
            if((total%2!=0) || (columna%2==0 && fila%2==0)){
                System.out.println("First");
            }else{
                System.out.println("Second");
            }
        }

    }

}

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

/**
 *
12345
FSFSF
SFSFS
--------
 12
1FS

 * */
public class A_Div2_124 {
    public static void main(String[]arg) throws IOException
    {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        int a,b,r,m,n;
        StringTokenizer st = new StringTokenizer(in.readLine());
        a = Integer.parseInt(st.nextToken());
        b = Integer.parseInt(st.nextToken());
        r = Integer.parseInt(st.nextToken())*2;
        if(r > a && r > b)
            System.out.println("Second");
        else
            System.out.println("First");
    }
}

import java.util.Scanner;

public class A124 {

    public static void main (String [] args) {

        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        int b = sc.nextInt();
        int r = sc.nextInt();

        int result = 0;
        r = 2*r;
        if(a>=r && b>=r) {
            result = (a*b)/(r*r);
        }
        //System.out.println(result);
        if(result%2==0)
            System.out.println("Second");
        else
            System.out.println("First");

    }

}

import java.io.*;
import java.util.ArrayList;
import java.util.TreeSet;

public class Main {

	public static void main(String[] args) throws Exception {

		int a = nextInt();
		int b = nextInt();
		int r = nextInt();
		int[][] t = new int[a / r][b / r];
		if(a < r * 2 && b < r * 2) exit("Second");
		else if(a < r * 4 && b < r * 4) exit("First");
		else{
			if(a / 2 * r % 2 == 0) exit("Second");
			else exit("First");
		}
	}

	private static PrintWriter out =  new PrintWriter(System.out);;
	private static BufferedReader inB = new BufferedReader(new InputStreamReader(System.in));
	private static StreamTokenizer in = new StreamTokenizer(inB);

	private static void exit(Object o) throws Exception {
		out.println(o);
		out.flush();
		System.exit(0);
	}
	private static void println(Object o) throws Exception{
		out.println(o);
		out.flush();
	}
	private static void print(Object o) throws Exception{
		out.print(o);
		out.flush();
	}
	private static int nextInt() throws Exception {
		in.nextToken();
		return (int)in.nval;
	}
	private static String nextString() throws Exception {
		in.nextToken();
		return in.sval;
	}
}

import java.util.Scanner;

public class PlateGame {
    public static void main(String asd[])throws Exception
    {
        Scanner in=new Scanner(System.in);
        int a=in.nextInt();
        int b=in.nextInt();
        int r=in.nextInt();
        long c=0;
        c=(a/(2*r))*(b/(2*r));
        if(c%2==0)
            System.out.println("Second");
        else
            System.out.println("First");
    }
}