You've got a rectangular table with length a and width b and the infinite number of plates of radius r. Two players play the following game: they take turns to put the plates on the table so that the plates don't lie on each other (but they can touch each other), and so that any point on any plate is located within the table's border. During the game one cannot move the plates that already lie on the table. The player who cannot make another move loses. Determine which player wins, the one who moves first or the one who moves second, provided that both players play optimally well.

A single line contains three space-separated integers a, b, r (1 ≤ a, b, r ≤ 100) — the table sides and the plates' radius, correspondingly.

If wins the player who moves first, print "First" (without the quotes). Otherwise print "Second" (without the quotes).

NoteIn the first sample the table has place for only one plate. The first player puts a plate on the table, the second player can't do that and loses.  In the second sample the table is so small that it doesn't have enough place even for one plate. So the first player loses without making a single move.

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.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.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.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.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.*;
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();
  }
}

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.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 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 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;
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.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.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");
		}

	}
}

/*
 * 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 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.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.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.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");
	}
}

/*
 * 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.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 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.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.*;

/**
 * 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.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.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.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.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.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.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.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.*;
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");
  }
}

//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.*;
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();

/*
 * 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.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");
		}
	}

}

//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 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.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.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.*;
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.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.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");

		}

	}

}

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.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.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.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.*;
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.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.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.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");
		}
	}
}

//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);
    }
}

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();
    }
}

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

//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");
        }
    }
}

//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.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.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.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();
	}

}

/* 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.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 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.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 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.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.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.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.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());
	}

	}

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.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.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.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;

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.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.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();
		}
	}
}

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.*;
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.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");
    }
}

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.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.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.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.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();
   }
}

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.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 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.*;
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.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.*;

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.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.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");
    }
}