import static java.lang.Double.parseDouble;
import static java.lang.Integer.parseInt;
import static java.lang.Long.parseLong;
import static java.lang.Math.abs;
import static java.lang.System.exit;

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

public class C {

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

//	static final int DX[] = {1, 0, -1, 0};
//	static final int DY[] = {0, 1, 0, -1};
//
//	static boolean solveFirst(boolean glue[][], int x1, int y1, int x2, int y2) {
//		if (x1 == x2 && y1 == y2) {
//			return true;
//		}
//		if (!glue[x1][y1]) {
//			for (int d = 0; d < 4; d++) {
//				int nx1 = x1 + DX[d];
//				int ny1 = y1 + DY[d];
//				if (nx1 < 0 || nx1 >= glue.length || ny1 < 0 || ny1 >= glue[0].length) {
//					continue;
//				}
//				if (solveSecond(glue, nx1, ny1, x2, y2)) {
//					return true;
//				}
//			}
//		}
//		if (!glue[x2][y2]) {
//			for (int d = 0; d < 4; d++) {
//				int nx2 = x2 + DX[d];
//				int ny2 = y2 + DY[d];
//				if (nx2 < 0 || nx2 >= glue.length || ny2 < 0 || ny2 >= glue[0].length) {
//					continue;
//				}
//				if (solveSecond(glue, x1, y1, nx2, ny2)) {
//					return true;
//				}
//			}
//		}
//		return false;
//	}
//
//	static boolean solveSecond(boolean glue[][], int x1, int y1, int x2, int y2) {
//		for (int x = 0; x < glue.length; x++) {
//			for (int y = 0; y < glue[0].length; y++) {
//				if (!(x == x1 && y == y1) && !(x == x2 && y == y2) && !glue[x][y]) {
//					glue[x][y] = true;
//					boolean res = solveFirst(glue, x1, y1, x2, y2);
//					glue[x][y] = false;
//					if (!res) {
//						return false;
//					}
//				}
//			}
//		}
//		return true;
//	}

	static void solve() throws Exception {
		/*int n = */nextInt();
		/*int m = */nextInt();
		int x1 = nextInt() - 1;
		int y1 = nextInt() - 1;
		int x2 = nextInt() - 1;
		int y2 = nextInt() - 1;
		// dx > 4 || dy > 4 -> Second
		// dx + dy <= 4 -> First
		// dx == 4 && dy == 1 -> First
		// dx == 4 && dy == 4 -> Second
		int dx = abs(x1 - x2);
		int dy = abs(y1 - y2);
		if (dx > 4 || dy > 4) {
			out.println("Second");
			return;
		}
		if (dx == 4 && dy >= 3 || dx >= 3 && dy == 4) {
			out.println("Second");
			return;
		}
		out.println("First");
//		int xMin = min(x1, x2);
//		int xMax = max(x1, x2);
//		int yMin = min(y1, y2);
//		int yMax = max(y1, y2);
//		n = xMax - xMin + 1;
//		x1 -= xMin;
//		x2 -= xMin;
//		m = yMax - yMin + 1;
//		y1 -= yMin;
//		y2 -= yMin;
//		boolean glue[][] = new boolean[n][m];
//		out.println(solveFirst(glue, x1, y1, x2, y2) ? "First" : "Second");
	}

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

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

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

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

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

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

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

    static class TaskC {
        public void solve(int testNumber, FastReader in, PrintWriter out) {
            in.nextInt();
            in.nextInt();
            int x1 = in.nextInt();
            int y1 = in.nextInt();
            int x2 = in.nextInt();
            int y2 = in.nextInt();

            int d1 = Math.abs(x2 - x1);
            int d2 = Math.abs(y2 - y1);
            if (d1 > 4 || d2 > 4) {
                out.println("Second");
            } else if (d1 == 4 && d2 >= 3 || d2 == 4 && d1 >= 3) {
                out.println("Second");
            } else {
                out.println("First");
            }
        }

    }

    static class FastReader {
        private InputStream stream;
        private byte[] buf = new byte[8192];
        private int curChar;
        private int pnumChars;

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

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

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

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

    }
}

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

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

    static class TaskB {
        public void solve(int testNumber, FastReader in, PrintWriter out) {
            int n = in.nextInt();
            int m = in.nextInt();
            int x1 = in.nextInt();
            int y1 = in.nextInt();
            int x2 = in.nextInt();
            int y2 = in.nextInt();

            int d1 = Math.abs(x2 - x1);
            int d2 = Math.abs(y2 - y1);
            if (d1 > 4 || d2 > 4) {
                out.println("Second");
            } else if (d1 == 4 && d2 >= 3 || d2 == 4 && d1 >= 3) {
                out.println("Second");
            } else {
                out.println("First");
            }
        }

    }

    static class FastReader {
        private InputStream stream;
        private byte[] buf = new byte[8192];
        private int curChar;
        private int pnumChars;

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

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

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

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

    }
}

import java.util.Scanner;

public class GameWithSuperglue
{
	public static void main(String[] args)
	{
		//Taking user input
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int m = sc.nextInt();
		int x1 = sc.nextInt();
		int y1 = sc.nextInt();
		int x2 = sc.nextInt();
		int y2 = sc.nextInt();
		int dx = Math.abs(x1-x2);
		int dy = Math.abs(y1-y2);
		//Both chips try to move towards each other and in such a
		// case smarter AI could not block the pieces to align together
		// if both dx and dy are less than 5.All other cases lead to
		// getting glued together
		if(dx <= 4 && dy <= 4)
		{
			int min = Math.min(dx, dy);
			int max = Math.max(dx, dy);
			if(min < 3)
				System.out.println("First");
			else
			{
				if(min == 3 && max == 4)
					System.out.println("Second");
				else
					if(min == 3)
						System.out.println("First");
				if(min == 4)
					System.out.println("Second");
			}
		}
		else
			System.out.println("Second");
	}
}

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

public class Main implements Runnable {
    void solution() throws Exception {
        int n = nextInt();
        int m = nextInt();
        int x1 = nextInt();
        int y1 = nextInt();
        int x2 = nextInt();
        int y2 = nextInt();
        int mini = Math.abs(x2-x1);
        int maxi = Math.abs(y2-y1);
        if (mini > maxi) {
            int t = mini;
            mini = maxi;
            maxi = t;
        }
        if (Math.abs(x2-x1) >= 5 || Math.abs(y2-y1) >= 5 || (Math.abs(x2-x1) == 4 && Math.abs(y2-y1) == 4) || (mini == 3 && maxi == 4))
            System.out.println("Second");
        else
            System.out.println("First");
    }

    ///////////////////// Template definitions //////////////////////////
    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 == null || !st.hasMoreTokens()) {
            String l = in.readLine();
            if (l == null) return null;
            st = new StringTokenizer(l);
        }
        return st.nextToken();
    }

    public static void main(String args[]) {
        //Locale.setDefault(Locale.UK);
        new Thread(new Main()).start();
    }

    public void run() {
        try {
            boolean online = true;
            Reader reader = online
                    ? new InputStreamReader(System.in)
                    : new FileReader("my.in");
            in = new BufferedReader(reader);
            out = new PrintWriter(System.out);
            solution();
            out.flush();
            out.close();
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(202);
        }
    }

    BufferedReader in;
    StringTokenizer st;
    PrintWriter out;
}

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

public class Solution implements Runnable {

	class State {
		int x, y;

		public State(int x, int y) {
			super();
			this.x = x;
			this.y = y;
		}

		public State(int encoding) {
			x = encoding / m;
			y = encoding % m;
		}

		int encode() {
			return x * m + y;
		}
	}

	int n, m;
	boolean[][][][] canWin;
	boolean[][][][] known;

	void solve() throws Exception {
		n = nextInt();
		m = nextInt();
		int x1 = nextInt(), y1 = nextInt(), x2 = nextInt(), y2 = nextInt();
		int dx = Math.abs(x1 - x2), dy = Math.abs(y1 - y2);
		int minD = Math.min(dx, dy), maxD = Math.max(dx, dy);
		boolean firstCanWin = false;
		if (minD == 0) {
			firstCanWin = maxD <= 4;
		} else if (minD == 1) {
			firstCanWin = maxD <= 4;
		} else if (minD == 2) {
			firstCanWin = maxD <= 4;
		} else if (minD == 3) {
			firstCanWin = maxD <= 3;
		}
		if (firstCanWin) {
			out.print("First");
		} else {
			out.print("Second");
		}
		/*for (n = 1; n < 8; ++n) {
			for (m = 1; m <= n; ++m) {
				canWin = new boolean[2][n * m][n * m][1 << (n * m)];
				known = new boolean[2][n * m][n * m][1 << (n * m)];
				System.err.println(n + " " + m + " " + (getWin(0, new State(0, 0).encode(), new State(n - 1, m - 1).encode(), 0) ? 1 : 0));
			}
		}*/
	}

	private boolean getWin(int player, int firstPos, int secondPos, int mask) {
		if (known[player][firstPos][secondPos][mask]) {
			return canWin[player][firstPos][secondPos][mask];
		}
		boolean value = false;
		known[player][firstPos][secondPos][mask] = true;
		State fP = new State(firstPos), sP = new State(secondPos);
		if (player == 0) {
			for (int dx = -1; dx <= 1; ++dx) {
				for (int dy = -1; dy <= 1; ++dy) {
					if (dx == 0 ^ dy == 0) {
						if (isGood(fP.x, fP.y, mask)) {
							int nx = fP.x + dx, ny = fP.y + dy;
							if (isGood(nx, ny, 0)) {
								if (nx == sP.x && ny == sP.y) {
									value = true;
								} else {
									value |= !getWin(player ^ 1, new State(nx, ny).encode(), secondPos, mask);
								}
							}
						}
						if (isGood(sP.x, sP.y, mask)) {
							int nx = sP.x + dx, ny = sP.y + dy;
							if (isGood(nx, ny, 0)) {
								if (nx == fP.x && ny == fP.y) {
									value = true;
								} else {
									value |= !getWin(player ^ 1, firstPos, new State(nx, ny).encode(), mask);
								}
							}
						}

					}
				}
			}
		} else {
			for (int x = 0; x < n; ++x) {
				for (int y = 0; y < m; ++y) {
					if (isGood(x, y, mask) && (fP.x != x || fP.y != y) && (sP.x != x || sP.y != y)) {
						value |= !getWin(player ^ 1, firstPos, secondPos, mask | (1 << (new State(x, y).encode())));
					}
				}
			}
		}

		canWin[player][firstPos][secondPos][mask] = value;
		return value;
	}

	private boolean isGood(int x, int y, int mask) {
		return x >= 0 && y >= 0 && x < n && y < m && (mask & (1 << (new State(x, y).encode()))) == 0;
	}

	public void run() {
		try {
			solve();
		} catch (Exception e) {
			NOO(e);
		} finally {
			out.close();
		}
	}

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

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

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

	String nextToken() {
		while (!stringTokenizer.hasMoreTokens()) {
			String line = null;
			try {
				line = in.readLine();
			} catch (IOException e) {
				NOO(e);
			}
			if (line == null) {
				return null;
			}
			stringTokenizer = new StringTokenizer(line);
		}
		return stringTokenizer.nextToken();
	}

	BufferedReader in;
	PrintWriter out;
	StringTokenizer stringTokenizer;

	void NOO(Exception e) {
		e.printStackTrace();
		System.exit(42);
	}

	public Solution(String name) {
		try {
			in = new BufferedReader(new FileReader("input.txt"));
			out = new PrintWriter(new FileWriter("output.txt"));
			stringTokenizer = new StringTokenizer("");
		} catch (Exception e) {
			NOO(e);
		}
	}

	public Solution() {
		try {
			in = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(System.out);
			stringTokenizer = new StringTokenizer("");
		} catch (Exception e) {
			NOO(e);
		}
	}

	public static void main(String[] args) {
		Locale.setDefault(Locale.US);
		new Solution().run();
	}
}

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

import static java.lang.Math.*;

public class Solution implements Runnable {

	public void solve () throws Exception {
		int n = nextInt();
		int m = nextInt();
		int x1 = nextInt();
		int y1 = nextInt();
		int x2 = nextInt();
		int y2 = nextInt();
		int d1 = abs (x1 - x2);
		int d2 = abs (y1 - y2);
		if (d1 >= 5 || d2 >= 5) {
			out.println("Second");
			return;
		}
		int maxd = max (d1, d2);
		int mind = min (d1, d2);
		if (maxd < 4 && mind < 4) {
			out.println("First");
			return;
		}
		if (maxd == 4 && mind == 4) {
			out.println("Second");
			return;
		}
		if (maxd == 4 && mind == 3) {
			out.println("Second");
			return;
		}
		out.println("First");
	}

	static final String fname = "";
	long stime = 0;

	BufferedReader in;
	PrintWriter out;
	StringTokenizer st;

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

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

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

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

	@Override
	public void run() {
		try {
			in = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(System.out);
			solve ();
		} catch (Exception e) {
			throw new RuntimeException(e);
		} finally {
			out.close();
		}
	}

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

}

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

public class PlayingWithSuperglue {

	static int[][][][][][] dp;

	public static void main(String[] args) throws IOException {
		Kattio io = new Kattio(System.in);
		int n = io.getInt();
		int m = io.getInt();
		int x1 = io.getInt();
		int y1 = io.getInt();
		int x2 = io.getInt();
		int y2 = io.getInt();
		dp = new int[n+1][m+1][2][2][2][2];
		for (int i = 0; i <= n; i++) {
			for (int j = 0; j <= m; j++) {
				for (int k = 0; k < 2; k++) {
					for (int k2 = 0; k2 < 2; k2++) {
						for (int k3 = 0; k3 < 2; k3++) {
							Arrays.fill(dp[i][j][k][k2][k3], -1);
						}
					}
				}
			}
		}
		io.println(solve(Math.abs(x1-x2), Math.abs(y1-y2), 0, 0, 0, 0)==1?"First":"Second");
		io.close();
	}

	static int solve(int x, int y, int t, int tr, int r, int player) {
		int res = dp[x][y][t][tr][r][player];
		if (res != -1) return res;
		res = 0;
		if (player == 1) { // Glue
			if (solve(x, y, 1, tr, r, 0) == 0) {
				res = 1;
			} else if (solve(x, y, t, 1, r, 0) == 0) {
				res = 1;
			} else {
				res = (solve(x, y, t, tr, 1, 0)+1)%2;
			}
		} else {
			if (x+y <= 3 || tr == 0 && x != 0 && y != 0 && x+y <= 4) {
				res = 1;
			} else {
				if (t == 0 && x > 0) {
					if (solve(x-1, y, 0, 0, tr, 1) == 0) {
						res = 1;
					}
				}
				if (r == 0 && y > 0) {
					if (solve(x, y-1, tr, 0, 0, 1) == 0) {
						res = 1;
					}
				}
			}
		}
		return dp[x][y][t][tr][r][player] = res;
	}

	static class Kattio extends PrintWriter {
	    public Kattio(InputStream i) {
		super(new BufferedOutputStream(System.out));
		r = new BufferedReader(new InputStreamReader(i));
	    }
	    public Kattio(InputStream i, OutputStream o) {
		super(new BufferedOutputStream(o));
		r = new BufferedReader(new InputStreamReader(i));
	    }

	    public boolean hasMoreTokens() {
		return peekToken() != null;
	    }

	    public int getInt() {
		return Integer.parseInt(nextToken());
	    }

	    public double getDouble() {
		return Double.parseDouble(nextToken());
	    }

	    public long getLong() {
		return Long.parseLong(nextToken());
	    }

	    public String getWord() {
		return nextToken();
	    }

	    private BufferedReader r;
	    private String line;
	    private StringTokenizer st;
	    private String token;

	    private String peekToken() {
		if (token == null)
		    try {
			while (st == null || !st.hasMoreTokens()) {
			    line = r.readLine();
			    if (line == null) return null;
			    st = new StringTokenizer(line);
			}
			token = st.nextToken();
		    } catch (IOException e) { }
		return token;
	    }

	    private String nextToken() {
		String ans = peekToken();
		token = null;
		return ans;
	    }
	}
}

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

import com.sun.rowset.internal.Row;

/**
 * @author Roman Elizarov
 */
public class Krok2012_2_C {
	private static final String FIRST = "First";
	private static final String SECOND = "Second";

	private static final int W = 7;
	private static final long ROW = (1L << W) - 1;
	private static final long COL;

	static {
		long col = 0;
		for (int i = 0; i < W; i++)
			col |= 1L << (i * W);
		COL = col;
	}

	public static void main(String[] args) {
		new Krok2012_2_C().go();
	}

	private void go() {
		Scanner in = new Scanner(System.in);
		PrintStream out = System.out;
		int n = in.nextInt();
		int m = in.nextInt();
		int x1 = in.nextInt();
		int y1 = in.nextInt();
		int x2 = in.nextInt();
		int y2 = in.nextInt();
		out.println(solve(n, m, x1, y1, x2, y2));
	}

	String solve(int n, int m, int x1, int y1, int x2, int y2) {
		int dx = Math.abs(x1 - x2);
		int dy = Math.abs(y1 - y2);
		if (dx >= W || dy >= W)
			return SECOND;
		return solved(dx, dy, 0) ? FIRST : SECOND;
	}

	Map<Long, Boolean> dp = new HashMap<Long, Boolean>();

	boolean solved(int dx, int dy, long mask) {
		// 0 <= dx, dy < W
		if (dx + dy <= 2)
			return true;
		Long pos = mask | (dx << (W * W)) | (dy << (W * W + 3));
		Boolean res = dp.get(pos);
		if (res != null)
			return res;
		if (dx > 0) {
			if (get(1, 0, mask) == 0 && solve2(dx - 1, dy, (mask & ~COL) >> 1)) {
				dp.put(pos, true);
				//System.out.println("(" + dx + "," + dy + "," + Long.toHexString(mask) + ") -> 1,0");
				return true;
			}
			if (get(dx - 1, dy, mask) == 0 && solve2(dx - 1, dy, mask & ~(COL << dx))) {
				dp.put(pos, true);
				//System.out.println("(" + dx + "," + dy + "," + Long.toHexString(mask) + ") -> -1,0");
				return true;
			}
		}
		if (dy > 0) {
			if (get(0, 1, mask) == 0 && solve2(dx, dy - 1, mask >> W)) {
				dp.put(pos, true);
				//System.out.println("(" + dx + "," + dy + "," + Long.toHexString(mask) + ") -> 0,1");
				return true;
			}
			if (get(dx, dy - 1, mask) == 0 && solve2(dx, dy - 1, mask & ~(ROW << (dy * W)))) {
				dp.put(pos, true);
				//System.out.println("(" + dx + "," + dy + "," + Long.toHexString(mask) + ") -> 0,-1");
				return true;
			}
		}
		dp.put(pos, false);
		return false;
	}

	private boolean solve2(int dx, int dy, long mask) {
		for (int i = 0; i <= dx; i++)
			for (int j = 0; j <= dy; j++)
				if ((i != 0 || j != 0) && (i != dx || j != dy) && get(i, j, mask) == 0 &&
						!solved(dx, dy, mask | (1L << (i + j * W))))
					return false;
		return solved(dx, dy, mask);
	}

	private int get(int dx, int dy, long mask) {
		return (int)((mask >> (dx + dy * W)) & 1);
	}
}

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

public class Main {
	static Scanner in; static int next() throws Exception {return in.nextInt();}
	static PrintWriter out;
//	static StreamTokenizer in; static int next() throws Exception {in.nextToken(); return (int) in.nval;}
//	static BufferedReader in;

	public static void main(String[] args) throws Exception {
		in = new Scanner(System.in);
//		in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
//		in = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);

		int n = next();
		int m = next();
		int x1 = next();
		int y1 = next();
		int x2 = next();
		int y2 = next();

		int sum = Math.abs(x1 - x2) + Math.abs(y1 - y2);

		if (sum >= 7) out.println("Second");
		if (sum <= 4) out.println("First");
		if (sum == 5) {
			if (Math.min(Math.abs(x1 - x2), Math.abs(y1 - y2)) == 2) out.println("First");
			if (Math.min(Math.abs(x1 - x2), Math.abs(y1 - y2)) == 1) out.println("First");
			if (Math.min(Math.abs(x1 - x2), Math.abs(y1 - y2)) == 0) out.println("Second");
		}
		if (sum == 6) {
			if (Math.min(Math.abs(x1 - x2), Math.abs(y1 - y2)) == 3) out.println("First");
			if (Math.min(Math.abs(x1 - x2), Math.abs(y1 - y2)) == 2) out.println("First");
			if (Math.min(Math.abs(x1 - x2), Math.abs(y1 - y2)) == 1) out.println("Second");
			if (Math.min(Math.abs(x1 - x2), Math.abs(y1 - y2)) == 0) out.println("Second");
		}

		out.close();
	}
}

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

public class Solution {

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

	int[] dx = {-1, 1, 0, 0};
	int[] dy = {0, 0, -1, 1};

	Boolean[][][] d = new Boolean[16][16][1 << 16];
	boolean gen(int x1, int y1, int x2, int y2, int mask) {
		int p1 = x1 * 4 + y1;
		int p2 = x2 * 4 + y2;
		if (p1 == p2) {
			return true;
		}
//		System.err.println(x1 + " " + y1 + " " + x2 + " " + y2);
		if (d[p1][p2][mask] == null) {
			loop: for (int p = 0; p < 16; ++p) {
				if (p == p1 || p == p2) {
					continue;
				}
				if ((mask & (1 << p1)) == 0) {
					for (int dir = 0; dir < 4; ++dir) {
						int x = x1 + dx[dir];
						int y = y1 + dy[dir];
						if ((Math.abs(x - x2) + Math.abs(y - y2)) < (Math.abs(x1 - x2) + Math.abs(y1 - y2)) && gen(x, y, x2, y2, mask | (1 << p))) {
							continue loop;
						}
					}
				}
				if ((mask & (1 << p2)) == 0) {
					for (int dir = 0; dir < 4; ++dir) {
						int x = x2 + dx[dir];
						int y = y2 + dy[dir];
						if ((Math.abs(x1 - x) + Math.abs(y1 - y)) < (Math.abs(x1 - x2) + Math.abs(y1 - y2)) && gen(x1, y1, x, y, mask | (1 << p))) {
							continue loop;
						}
					}
				}
				return d[p1][p2][mask] = false;
			}
			d[p1][p2][mask] = true;
		}
		return d[p1][p2][mask];
	}

	public void solve() throws IOException {
		nextInt();
		nextInt();
		int x0 = nextInt();
		int y0 = nextInt();
		int x2 = nextInt();
		int y2 = nextInt();
		for (int dir = 0; dir < 4; ++dir) {
			int x1 = x0 + dx[dir];
			int y1 = y0 + dy[dir];
			int minx = Math.min(x1, x2);
			int miny = Math.min(y1, y2);
			if (Math.abs(x1 - x2) < 4 && Math.abs(y1 - y2) < 4 && gen(x1 - minx, y1 - miny, x2 - minx, y2 - miny, 0)) {
				out.println("First");
				return;
			}
		}
		out.println("Second");
	}

	public void run() throws IOException {
		in = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);
		eat("");

		solve();

		out.close();
	}

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

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

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

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

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

	public static void main(String[] args) throws IOException {
		Locale.setDefault(Locale.US);
		new Solution().run();
	}

}

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

public class C176 {

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

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

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

    public static void main(String[] args) throws Exception {
        int n = nextInt(), m = nextInt();
        int x1 = nextInt(), y1 = nextInt();
        int x2 = nextInt(), y2 = nextInt();
        int dx = Math.abs(x1-x2)+1, dy = Math.abs(y1-y2)+1;
        int max = Math.max(dx, dy), min = Math.min(dx, dy);
        if (max > 5) out.println("Second");
        else if (max == 5 && min > 3) out.println("Second");
        else out.println("First");
        out.flush();
    }

}

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

public class Main implements Runnable {

    public void _main() throws Exception {
	int n = nextInt();
	int m = nextInt();
	int x1 = nextInt();
	int y1 = nextInt();
	int x2 = nextInt();
	int y2 = nextInt();
	int h = Math.abs(x1 - x2) + 1;
	int w = Math.abs(y1 - y2) + 1;
	if ((h >= 4 && w >= 5) || (h >= 5 && w >= 4) || h >= 6 || w >= 6) {
	    out.println("Second");
	} else {
	    out.println("First");
	}
    }

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

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

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

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

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

    public void run() {
        try {
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);

            _main();

            out.close();
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(202);
        }
    }

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

}

import java.util.*;
import java.awt.*;

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

		int m = scan.nextInt();
		int n = scan.nextInt();
		int r1 = scan.nextInt();
		int c1 = scan.nextInt();
		int r2 = scan.nextInt();
		int c2 = scan.nextInt();
		int dr = Math.abs(r1 - r2);
		int dc = Math.abs(c1 - c2);

		int min = Math.min(dr, dc);
		int max = Math.max(dr, dc);

		if(min == 0 && max <= 4) System.out.println("First");
		else if(min == 1 && max <= 4) System.out.println("First");
		else if(min == 2 && max <= 4) System.out.println("First");
		else if(min == 3 && max <= 3) System.out.println("First");
		else System.out.println("Second");
	}
}

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

public class CROC2012_Round2_C implements Runnable {

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

	BufferedReader in;
	PrintWriter out;
	StringTokenizer tok;

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

	@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");
			}
			Locale.setDefault(Locale.US);
			tok = new StringTokenizer("");
			solve();
			in.close();
			out.close();
			long freeMemory = Runtime.getRuntime().freeMemory();
			long totalMemory = Runtime.getRuntime().totalMemory();
			long endTime = System.currentTimeMillis();
			System.err.println("Time = " + (endTime - startTime));
			System.err.println("Memory = " + ((totalMemory - freeMemory) >> 10));
		} catch (Throwable t) {
			t.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));
		}
	}

	/** http://pastebin.com/j0xdUjDn */
	static class Utils {

		private Utils() {}

		public static void mergeSort(int[] a) {
			mergeSort(a, 0, a.length - 1);
		}

		private static final int MAGIC_VALUE = 50;

		private static void mergeSort(int[] a, int leftIndex, int rightIndex) {
			if (leftIndex < rightIndex) {
				if (rightIndex - leftIndex <= MAGIC_VALUE) {
					insertionSort(a, leftIndex, rightIndex);
				} else {
					int middleIndex = (leftIndex + rightIndex) / 2;
					mergeSort(a, leftIndex, middleIndex);
					mergeSort(a, middleIndex + 1, rightIndex);
					merge(a, leftIndex, middleIndex, rightIndex);
				}
			}
		}

		private static void merge(int[] a, int leftIndex, int middleIndex, int rightIndex) {
			int length1 = middleIndex - leftIndex + 1;
			int length2 = rightIndex - middleIndex;
			int[] leftArray = new int[length1];
			int[] rightArray = new int[length2];
			System.arraycopy(a, leftIndex, leftArray, 0, length1);
			System.arraycopy(a, middleIndex + 1, rightArray, 0, length2);
			for (int k = leftIndex, i = 0, j = 0; k <= rightIndex; k++) {
				if (i == length1) {
					a[k] = rightArray[j++];
				} else if (j == length2) {
					a[k] = leftArray[i++];
				} else {
					a[k] = leftArray[i] <= rightArray[j] ? leftArray[i++] : rightArray[j++];
				}
			}
		}

		private static void insertionSort(int[] a, int leftIndex, int rightIndex) {
			for (int i = leftIndex + 1; i <= rightIndex; i++) {
				int current = a[i];
				int j = i - 1;
				while (j >= leftIndex && a[j] > current) {
					a[j + 1] = a[j];
					j--;
				}
				a[j + 1] = current;
			}
		}

	}

	// solution

	void solve() throws IOException {
		int n = readInt();
		int m = readInt();
		int x1 = readInt();
		int y1 = readInt();
		int x2 = readInt();
		int y2 = readInt();
		int dx = abs(x1 - x2);
		int dy = abs(y1 - y2);
		int min = min(dx, dy);
		int max = max(dx, dy);

		if (max >= 5) {
			out.println("Second");
			return;
		}

		if (max == 4 && min >= 3) {
			out.println("Second");
			return;
		}

		out.println("First");
	}

}

import java.util.Scanner;

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

		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int m = sc.nextInt();
		int x1 = sc.nextInt();
		int y1 = sc.nextInt();
		int x2 = sc.nextInt();
		int y2 = sc.nextInt();
		int dx = Math.abs(x1-x2);
		int dy = Math.abs(y1 - y2);
		if(dx <= 4 && dy <= 4)
		{
			int min = Math.min(dx, dy);
			int max = Math.max(dx, dy);
			if(min < 3)
				System.out.println("First");
			else
			{
				if(max == 3)
					System.out.println("First");
				else
					System.out.println("Second");
			}
		}
		else
			System.out.println("Second");
	}
}

import java.util.Scanner;

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

		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int m = sc.nextInt();
		int x1 = sc.nextInt();
		int y1 = sc.nextInt();
		int x2 = sc.nextInt();
		int y2 = sc.nextInt();
		int dx = Math.abs(x1-x2);
		int dy = Math.abs(y1 - y2);
		if(dx <= 4 && dy <= 4)
		{
			int min = Math.min(dx, dy);
			int max = Math.max(dx, dy);
			if(min < 3)
				System.out.println("First");
			else
			{
				if(min == 3 && max == 4)
					System.out.println("Second");
				else
					if(min == 3)
						System.out.println("First");
				if(min == 4)
					System.out.println("Second");
			}
		}
		else
			System.out.println("Second");
	}
}

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 codeKNIGHT
 */
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);
		TaskE solver = new TaskE();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskE {
	public void solve(int testNumber, Scanner in, PrintWriter out) {
        int n=in.nextInt(),m=in.nextInt(),x1=in.nextInt(),y1=in.nextInt(),x2=in.nextInt(),y2=in.nextInt(),win=0;
        int x=Math.abs(x1-x2),y=Math.abs(y1-y2);
        if(x>=5||y>=5)
            win=2;
        else if(x<=3&&y<=3)
            win=1;
        else if(x==4)
        {
            if(y<=2)
                win=1;
            else win=2;
        }
        else if(y==4)
        {
            if(x<=2)
                win=1;
            else win=2;
        }
        if(win==1)
            out.println("First");
        else out.println("Second");

	}
}

import java.io.*;

public class E {

	public E () throws IOException {
		int N = sc.nextInt();
		int M = sc.nextInt();
		int X1 = sc.nextInt();
		int Y1 = sc.nextInt();
		int X2 = sc.nextInt();
		int Y2 = sc.nextInt();
		solve(N, M, X1, Y1, X2, Y2);
	}

	public void solve (int N, int M, int X1, int Y1, int X2, int Y2) {
		int DX = Math.abs(X1-X2), DY = Math.abs(Y1-Y2);
		if (DX >= 5 || DY >= 5) exit("Second");
		if (DX <= 3 && DY <= 3) exit("First");

		if (DX == 4) {
			if (DY <= 2) exit ("First"); else exit("Second");
		}

		if (DY == 4) {
			if (DX <= 2) exit ("First"); else exit("Second");
		}
	}

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

	static MyScanner sc;
	static long t;

	static void print (Object o) {
		System.out.println(o);
	}

	static void exit (Object o) {
		print(o);
		//print2((millis() - t) / 1000.0);
		System.exit(0);
	}

	static void run () throws IOException {
		sc = new MyScanner ();
		new E();
	}

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

	static long millis() {
		return System.currentTimeMillis();
	}

	static void start() {
		t = millis();
	}

	static class MyScanner {
		String next() throws IOException {
			newLine();
			return line[index++];
		}

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

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

		String nextLine() throws IOException {
			line = null;
			return r.readLine();
		}

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

		private final BufferedReader r;

		MyScanner () throws IOException {
			this(new BufferedReader(new InputStreamReader(System.in)));
		}

		MyScanner(BufferedReader r) throws IOException {
			this.r = r;
		}

		private String [] line;
		private int index;

		private void newLine() throws IOException {
			if (line == null || index == line.length) {
				line = r.readLine().split(" ");
				index = 0;
			}
		}
	}
}

import java.util.*;

/**
 * Created by IntelliJ IDEA.
 * User: piyushd
 * Date: 3/29/11
 * Time: 7:56 PM
 * To change this template use File | Settings | File Templates.
 */
public class TaskE {

    void run() {
        int N = nextInt(), M = nextInt();
        int x1 = nextInt(), y1 = nextInt();
        int x2 = nextInt(), y2 = nextInt();

        int d1 = Math.abs(x1 - x2);
        int d2 = Math.abs(y1 - y2);
        if (d1 <= 4 && d2 <= 4 && d1 + d2 <= 6) {
            System.out.println("First");
        } else {
            System.out.println("Second");
        }
    }

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

import java.io.*;
import java.math.BigInteger;
import java.util.*;
import java.util.Map.Entry;

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

   void solve()  throws IOException {
	  //BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
	  //Scanner in = new Scanner(System.in);
	   MyReader in = new MyReader();
	  PrintWriter out = new PrintWriter(System.out);
     // Scanner in = new Scanner(new FileReader("input.txt"));
	//  PrintWriter out = new PrintWriter("output.txt");

	  int n = in.nextInt();
	  int m = in.nextInt();
	  int x1 = in.nextInt();
	  int y1 = in.nextInt();
	  int x2 = in.nextInt();
	  int y2 = in.nextInt();

	  int a1 = Math.abs(x1 - x2);
	  int a2 = Math.abs(y1 - y2);

	  if (a1 > 4 || a2 > 4) {
		  out.println("Second");
	  } else {
		  if ((a1 == 4 && a2 > 2) || (a2 == 4 && a1 > 2))  {
			  out.println("Second");
		  } else {
			  out.println("First");
		  }
	  }

	out.close();
   }

};

class MyReader {
	private BufferedReader in;
	String[] parsed;
	int index = 0;

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

	public int nextInt() throws NumberFormatException, IOException {
		if (parsed == null || parsed.length == index) {
			read();
		}
		return Integer.parseInt(parsed[index++]);
	}

	public long nextLong() throws NumberFormatException, IOException {
		if (parsed == null || parsed.length == index) {
			read();
		}
		return Long.parseLong(parsed[index++]);
	}

	public String nextString() throws IOException {
		if (parsed == null || parsed.length == index) {
			read();
		}
		return parsed[index++];
	}

	private void read() throws IOException {
		parsed = in.readLine().split(" ");
		index = 0;
	}

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

import java.util.Scanner;

public class Main{

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int c = 0;

        int n = in.nextInt();
        int m = in.nextInt();
        int x1 = in.nextInt();
        int y1 = in.nextInt();
        int x2 = in.nextInt();
        int y2 = in.nextInt();
        boolean f = false;
        int xx = Math.abs(x1 - x2);
        int yy = Math.abs(y1 - y2);
        if (xx == 4 && yy<3){
            System.out.println("First");
            f = true;
        }
        if (xx < 4 &&yy <= 3 && !f) {
            System.out.println("First");
                f = true;
            }
        if (yy == 4 && xx<3 && !f){
            System.out.println("First");
            f = true;
        }
        if (yy < 4 && !f && xx <= 3) {
            System.out.println("First");
                f = true;

        }
        if (!f) {
            System.out.println("Second");
        }
        }
    }

import static java.lang.Math.*;
import static java.lang.System.currentTimeMillis;
import static java.lang.System.exit;
import static java.lang.System.arraycopy;
import static java.util.Arrays.sort;
import static java.util.Arrays.binarySearch;
import static java.util.Arrays.fill;
import java.util.*;
import java.io.*;

public class Main {

	public static void main(String[] args) throws IOException {
		try {
			if (new File("input.txt").exists())
				System.setIn(new FileInputStream("input.txt"));
		} catch (SecurityException e) {
		}
		new Thread(null, new Runnable() {
			public void run() {
				try {
					new Main().run();
				} catch (IOException e) {
					e.printStackTrace();
					exit(999);
				}
			}
		}, "kek", 1 << 23).start();
	}

	BufferedReader in;
	PrintWriter out;
	StringTokenizer st = new StringTokenizer("");

	private void run() throws IOException {
		in = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);
		solve();
		in.close();
		out.close();
	}
	private void solve() throws IOException{
		nextInt();
		nextInt();
		int x1 = nextInt();
		int y1 = nextInt();

		int x2 = nextInt();
		int y2 = nextInt();

		int dx = max(abs(x1 - x2), abs(y1 - y2));
		int dy = min(abs(x1 - x2), abs(y1 - y2));
		out.println(dx + dy > 6 || dx > 4 ? "Second" : "First");

	}
	String nextToken() throws IOException {
		while (!st.hasMoreTokens())
			st = new StringTokenizer(in.readLine());
		return st.nextToken();
	}
	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 nextLine() throws IOException {
		st = new StringTokenizer("");
		return in.readLine();
	}
	boolean EOF() throws IOException {
		while (!st.hasMoreTokens()) {
			String s = in.readLine();
			if (s == null)
				return true;
			st = new StringTokenizer(s);
		}
		return false;
	}
}

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

//4/20/12 7:26 PM
//by Abrackadabra

public class C {
    public static void main(String[] args) throws IOException {
        if (args.length > 0 && args[0].equals("Abra")) debugMode = true;
        new C().run();
        /*new Thread(null, new Runnable() {
            public void run() {
                try {
                    new C().run();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }, "1", 1 << 24).start();*/
    }

    int IOMode = 0; //0 - consoleIO, 1 - <taskName>.in/out, 2 - input.txt/output.txt, 3 - test case generator
    String taskName = "";

    void solve() throws IOException {

        HashSet<int[]> ok = new HashSet<int[]>();
        ok.add(new int[]{0, 0});
        ok.add(new int[]{1, 0});
        ok.add(new int[]{2, 0});
        ok.add(new int[]{3, 0});
        ok.add(new int[]{4, 0});
        ok.add(new int[]{1, 1});
        ok.add(new int[]{2, 1});
        ok.add(new int[]{2, 2});
        ok.add(new int[]{3, 1});
        ok.add(new int[]{3, 2});
        ok.add(new int[]{3, 3});
        ok.add(new int[]{4, 1});
        ok.add(new int[]{4, 2});
        //ok.add(new int[]{4, 3});

        int n = nextInt(), m = nextInt();
        int x0 = nextInt() - 1, y0 = nextInt() - 1;
        int x1 = nextInt() - 1, y1 = nextInt() - 1;
        int dx = Math.abs(x0 - x1), dy = Math.abs(y0 - y1);
        if (dx < dy) {
            int t = dx;
            dx = dy;
            dy = t;
        }
        int[] q = {dx, dy};
        boolean ook = false;
        for (int[] w : ok) {
            if (w[0] == q[0] && w[1] == q[1])
                ook = true;
        }
        if (ook)
            out.println("First");
        else
            out.println("Second");
    }

    long startTime = System.nanoTime(), tempTime = startTime, finishTime = startTime;
    long startMem = Runtime.getRuntime().totalMemory(), finishMem = startMem;

    void run() throws IOException {
        init();
        if (debugMode) {
            con.println("Start");
            con.println("Console:");
        }
        solve();
        finishTime = System.nanoTime();
        finishMem = Runtime.getRuntime().totalMemory();
        out.flush();
        if (debugMode) {
            int maxSymbols = 1000;
            BufferedReader tbr = new BufferedReader(new FileReader("input.txt"));
            char[] a = new char[maxSymbols];
            tbr.read(a);
            if (a[0] != 0) {
                con.println("File input:");
                con.println(a);
                if (a[maxSymbols - 1] != 0) con.println("...");
            }
            tbr = new BufferedReader(new FileReader("output.txt"));
            a = new char[maxSymbols];
            tbr.read(a);
            if (a[0] != 0) {
                con.println("File output:");
                con.println(a);
                if (a[maxSymbols - 1] != 0) con.println("...");
            }
            con.println("Execution time: " + (finishTime - startTime) / 1000000000.0 + " sec");
            con.println("Used memory:    " + (finishMem - startMem) + " bytes");
            con.println("Total memory:   " + Runtime.getRuntime().totalMemory() + " bytes");
        }
    }

    boolean tick(double x) {
        if (System.nanoTime() - tempTime > x * 1e9) {
            tempTime = System.nanoTime();
            con.println("Tick at " + (tempTime - startTime) / 1000000000 + " sec");
            con.print("   ");
            return true;
        }
        return false;
    }

    static boolean debugMode = false;
    PrintStream con = System.out;

    void init() throws IOException {
        if (debugMode && IOMode != 3) {
            br = new BufferedReader(new FileReader("input.txt"));
            out = new PrintWriter(new FileWriter("output.txt"));
        } else
            switch (IOMode) {
                case 0:
                    br = new BufferedReader(new InputStreamReader(System.in));
                    out = new PrintWriter(System.out);
                    break;
                case 1:
                    br = new BufferedReader(new FileReader(taskName + ".in"));
                    out = new PrintWriter(new FileWriter(taskName + ".out"));
                    break;
                case 2:
                    br = new BufferedReader(new FileReader("input.txt"));
                    out = new PrintWriter(new FileWriter("output.txt"));
                    break;
                case 3:
                    out = new PrintWriter(new FileWriter("input.txt"));
                    break;
            }
    }

    BufferedReader br;
    PrintWriter out;
    StringTokenizer in;

    boolean hasMoreTokens() throws IOException {
        while (in == null || !in.hasMoreTokens()) {
            String line = br.readLine();
            if (line == null) return false;
            in = new StringTokenizer(line);
        }
        return true;
    }

    String nextString() throws IOException {
        return hasMoreTokens() ? in.nextToken() : null;
    }

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

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

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

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.ObjectInputStream.GetField;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.*;

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

        int n = in.nextInt();
        int m = in.nextInt();
        int x1 = in.nextInt();
        int y1 = in.nextInt();
        int x2 = in.nextInt();
        int y2 = in.nextInt();

        int dx = Math.abs(x2-x1);
        int dy = Math.abs(y2-y1);

        if(dx > dy)
        {
            int t = dx;
            dx = dy;
            dy = t;
        }

        if(dx + dy >= 7)
        {
            writer.println("Second");
        }
        else
        {
            if(dx <= 1)
            {
                writer.println(dy >= 5 ? "Second" : "First");

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

        writer.flush();
        writer.close();
    }
}

import java.util.Scanner;

public class Main{

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int c = 0;
        int n = in.nextInt();
        int m = in.nextInt();
        int x1 = in.nextInt();
        int y1 = in.nextInt();
        int x2 = in.nextInt();
        int y2 = in.nextInt();
        boolean f = false;
        int xx = Math.abs(x1 - x2);
        int yy = Math.abs(y1 - y2);
        if (xx == 4 && yy<=3){
            System.out.println("First");
            f = true;
        }
        if (xx < 4 &&yy <= 3 && !f) {
            System.out.println("First");
                f = true;
            }
        if (yy == 4 && xx<=3 && !f){
            System.out.println("First");
            f = true;
        }
        if (yy <= 4 && !f && xx <= 3) {
            System.out.println("First");
                f = true;

        }
        if (!f) {
            System.out.println("Second");
        }
        }
    }

import java.util.Scanner;

public class Main{

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int m = in.nextInt();
        int x1 = in.nextInt();
        int y1 = in.nextInt();
        int x2 = in.nextInt();
        int y2 = in.nextInt();
        boolean f = false;
        if (Math.abs(x1 - x2) <= 4) {
            if (Math.abs(y1 - y2) <= 3) {
                System.out.println("First");
                f = true;
            }
        }
        if (Math.abs(y1 - y2) <= 4 && !f) {
            if (Math.abs(x1 - x2) <= 3) {
                System.out.println("First");
                f = true;
            }
        }
        if (!f) {
            System.out.println("Second");
        }

    }
}

import java.util.Scanner;

public class Main{

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int m = in.nextInt();
        int x1 = in.nextInt();
        int y1 = in.nextInt();
        int x2 = in.nextInt();
        int y2 = in.nextInt();
        boolean f = false;
        if (Math.abs(x1 - x2) <= 4) {
            if (Math.abs(y1 - y2) <= 2) {
                System.out.println("First");
                f = true;
            }
        }
        if (Math.abs(y1 - y2) <= 4 && !f) {
            if (Math.abs(x1 - x2) <= 2) {
                System.out.println("First");
                f = true;
            }
        }
        if (!f) {
            System.out.println("Second");
        }

    }
}

import java.util.Scanner;

public class Main{

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int c = 0;
        int n = in.nextInt();
        int m = in.nextInt();
        int x1 = in.nextInt();
        int y1 = in.nextInt();
        int x2 = in.nextInt();
        int y2 = in.nextInt();
        boolean f = false;
        int xx = Math.abs(x1 - x2);
        int yy = Math.abs(y1 - y2);
        if (xx == 4 && yy<3){
            System.out.println("First");
            f = true;
        }
        if (xx < 4 &&yy <= 3 && !f) {
            System.out.println("First");
                f = true;
            }
        if (yy == 4 && xx<3 && !f){
            System.out.println("First");
            f = true;
        }
        if (yy <= 4 && !f && xx <= 3) {
            System.out.println("First");
                f = true;

        }
        if (!f) {
            System.out.println("Second");
        }
        }
    }

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.ObjectInputStream.GetField;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.*;

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

        int n = in.nextInt();
        int m = in.nextInt();
        int x1 = in.nextInt();
        int y1 = in.nextInt();
        int x2 = in.nextInt();
        int y2 = in.nextInt();

        n = Math.abs(x1-x2) + 1;
        m = Math.abs(y1-y2) + 1;
        x1 = y1 = 0;
        x2 = n-1;
        y2 = m-1;

        boolean res = true;
        for(int x = 0 ; x + 1 < n ; x++)
            for(int y = 0 ; y < m ; y++)
            {
                boolean oka1 = true;
                boolean oka2 = true;
                boolean okb1 = true;
                boolean okb2 = true;
                for(int i = 0 ; i <= 1 ; i++)
                    for(int j = 0 ; j <= 1 ; j++)
                    {
                        if(i-x == j-y)
                            oka1 = false;
                        if(i-x == y-j)
                            oka2 = false;

                        if((x2-i)-(x+1) == (y2-j)-y)
                            okb1 = false;
                        if((x2-i)-(x+1) == y-(y2-j))
                            okb2 = false;
                    }

                if((oka1 || oka2) && (okb2))
                    res = false;
            }

        if(res)
            writer.println("First");
        else
            writer.println("Second");

        writer.flush();
        writer.close();

    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.ObjectInputStream.GetField;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.*;

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

        int n = in.nextInt();
        int m = in.nextInt();
        int x1 = in.nextInt();
        int y1 = in.nextInt();
        int x2 = in.nextInt();
        int y2 = in.nextInt();

        n = Math.abs(x1-x2) + 1;
        m = Math.abs(y1-y2) + 1;
        x1 = y1 = 0;
        x2 = n-1;
        y2 = m-1;

        boolean res = true;
        for(int x = 0 ; x + 1 < n ; x++)
            for(int y = 0 ; y < m ; y++)
            {
                boolean oka1 = true;
                boolean oka2 = true;
                boolean okb1 = true;
                boolean okb2 = true;
                for(int i = 0 ; i <= 1 ; i++)
                    for(int j = 0 ; j <= 1 ; j++)
                    {
                        if(i-x == j-y)
                            oka1 = false;
                        if(i-x == y-j)
                            okb1 = false;

                        if((x2-i)-(x+1) == (y2-j)-y)
                            oka1 = false;
                        if((x2-i)-(x+1) == y-(y2-j))
                            okb1 = false;
                    }

                if((oka1) && (okb1))
                    res = false;
            }

        if(res)
            writer.println("First");
        else
            writer.println("Second");

        writer.flush();
        writer.close();

    }
}

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

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

    static class TaskB {
        public void solve(int testNumber, FastReader in, PrintWriter out) {
            int n = in.nextInt();
            int m = in.nextInt();
            int x1 = in.nextInt();
            int y1 = in.nextInt();
            int x2 = in.nextInt();
            int y2 = in.nextInt();
            if (n > m) {
                int t = n;
                n = m;
                m = t;
            }
            if (n == 1) {
                int d1 = Math.abs(x2 - x1) - 1;
                int d2 = Math.abs(y2 - y1) - 1;
                if (d1 == 0) d1 = d2;
                if (d1 == 1) {
                    out.println("First");
                    return;
                }
                out.println(d1 >= 4 ? "Second" : "First");
            } else {
                int d1 = Math.abs(x2 - x1) - 1;
                int d2 = Math.abs(y2 - y1) - 1;
                int min = Math.max(d1, d2);
                if (d1 == 1) {
                    out.println("First");
                    return;
                }
                out.println(min >= 4 ? "Second" : "First");
            }
        }

    }

    static class FastReader {
        private InputStream stream;
        private byte[] buf = new byte[8192];
        private int curChar;
        private int pnumChars;

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

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

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

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

    }
}

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

public class Main implements Runnable {
    void solution() throws Exception {
        int n = nextInt();
        int m = nextInt();
        int x1 = nextInt();
        int y1 = nextInt();
        int x2 = nextInt();
        int y2 = nextInt();
        if (Math.abs(x2-x1) >= 5 || Math.abs(y2-y1) >= 5)
            System.out.println("Second");
        else
            System.out.println("First");
    }

    ///////////////////// Template definitions //////////////////////////
    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 == null || !st.hasMoreTokens()) {
            String l = in.readLine();
            if (l == null) return null;
            st = new StringTokenizer(l);
        }
        return st.nextToken();
    }

    public static void main(String args[]) {
        //Locale.setDefault(Locale.UK);
        new Thread(new Main()).start();
    }

    public void run() {
        try {
            boolean online = true;
            Reader reader = online
                    ? new InputStreamReader(System.in)
                    : new FileReader("my.in");
            in = new BufferedReader(reader);
            out = new PrintWriter(System.out);
            solution();
            out.flush();
            out.close();
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(202);
        }
    }

    BufferedReader in;
    StringTokenizer st;
    PrintWriter out;
}

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

public class PlayingWithSuperglue {

	static int[][][][][][] dp;

	public static void main(String[] args) throws IOException {
		Kattio io = new Kattio(System.in);
		int n = io.getInt();
		int m = io.getInt();
		int x1 = io.getInt();
		int y1 = io.getInt();
		int x2 = io.getInt();
		int y2 = io.getInt();
		dp = new int[n+1][m+1][2][2][2][2];
		for (int i = 0; i <= n; i++) {
			for (int j = 0; j <= m; j++) {
				for (int k = 0; k < 2; k++) {
					for (int k2 = 0; k2 < 2; k2++) {
						for (int k3 = 0; k3 < 2; k3++) {
							Arrays.fill(dp[i][j][k][k2][k3], -1);
						}
					}
				}
			}
		}
		io.println(solve(Math.abs(x1-x2), Math.abs(y1-y2), 0, 0, 0, 0)==1?"First":"Second");
		io.close();
	}

	static int solve(int x, int y, int t, int tr, int r, int player) {
		int res = dp[x][y][t][tr][r][player];
		if (res != -1) return res;
		res = 0;
		if (player == 1) { // Glue
			if (solve(x, y, 1, tr, r, 0) == 0) {
				res = 1;
			} else if (solve(x, y, t, 1, r, 0) == 0) {
				res = 1;
			} else {
				res = (solve(x, y, t, tr, 1, 0)+1)%2;
			}
		} else {
			if (x+y <= 3) {
				res = 1;
			} else {
				if (t == 0 && x > 0) {
					if (solve(x-1, y, 0, 0, tr, 1) == 0) {
						res = 1;
					}
				}
				if (r == 0 && y > 0) {
					if (solve(x, y-1, tr, 0, 0, 1) == 0) {
						res = 1;
					}
				}
			}
		}
		return dp[x][y][t][tr][r][player] = res;
	}

	static class Kattio extends PrintWriter {
	    public Kattio(InputStream i) {
		super(new BufferedOutputStream(System.out));
		r = new BufferedReader(new InputStreamReader(i));
	    }
	    public Kattio(InputStream i, OutputStream o) {
		super(new BufferedOutputStream(o));
		r = new BufferedReader(new InputStreamReader(i));
	    }

	    public boolean hasMoreTokens() {
		return peekToken() != null;
	    }

	    public int getInt() {
		return Integer.parseInt(nextToken());
	    }

	    public double getDouble() {
		return Double.parseDouble(nextToken());
	    }

	    public long getLong() {
		return Long.parseLong(nextToken());
	    }

	    public String getWord() {
		return nextToken();
	    }

	    private BufferedReader r;
	    private String line;
	    private StringTokenizer st;
	    private String token;

	    private String peekToken() {
		if (token == null)
		    try {
			while (st == null || !st.hasMoreTokens()) {
			    line = r.readLine();
			    if (line == null) return null;
			    st = new StringTokenizer(line);
			}
			token = st.nextToken();
		    } catch (IOException e) { }
		return token;
	    }

	    private String nextToken() {
		String ans = peekToken();
		token = null;
		return ans;
	    }
	}
}

import java.io.PrintStream;
import java.util.Scanner;

/**
 * @author Roman Elizarov
 */
public class Krok2012_2_C {
	private static final String FIRST = "First";
	private static final String SECOND = "Second";

	public static void main(String[] args) {
		new Krok2012_2_C().go();
	}

	private void go() {
		Scanner in = new Scanner(System.in);
		PrintStream out = System.out;
		int n = in.nextInt();
		int m = in.nextInt();
		int x1 = in.nextInt();
		int y1 = in.nextInt();
		int x2 = in.nextInt();
		int y2 = in.nextInt();
		out.println(solve(n, m, x1, y1, x2, y2));
	}

	String solve(int n, int m, int x1, int y1, int x2, int y2) {
		int dx = Math.abs(x1 - x2);
		int dy = Math.abs(y1 - y1);
		if (dx >= 5 || dy >= 5)
			return SECOND;
		return FIRST;
	}
}

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

import com.sun.rowset.internal.Row;

/**
 * @author Roman Elizarov
 */
public class Krok2012_2_C {
	private static final String FIRST = "First";
	private static final String SECOND = "Second";

	private static final int COL = (1 | (1 << 5) | (1 << 10) | (1 << 15) | (1 << 20));
	private static final int ROW = (1 << 5) - 1;

	public static void main(String[] args) {
		new Krok2012_2_C().go();
	}

	private void go() {
		Scanner in = new Scanner(System.in);
		PrintStream out = System.out;
		int n = in.nextInt();
		int m = in.nextInt();
		int x1 = in.nextInt();
		int y1 = in.nextInt();
		int x2 = in.nextInt();
		int y2 = in.nextInt();
		out.println(solve(n, m, x1, y1, x2, y2));
	}

	String solve(int n, int m, int x1, int y1, int x2, int y2) {
		int dx = Math.abs(x1 - x2);
		int dy = Math.abs(y1 - y1);
		if (dx >= 5 || dy >= 5)
			return SECOND;
		return solved(dx, dy, 0) ? FIRST : SECOND;
	}

	Map<Integer, Boolean> dp = new HashMap<Integer, Boolean>();

	boolean solved(int dx, int dy, int mask) {
		// 0 <= dx, dy <= 4
		if (dx + dy <= 2)
			return true;
		Integer pos = mask | (dx << 25) | (dy << 28);
		Boolean res = dp.get(pos);
		if (res != null)
			return res;
		if (dx > 0) {
			if (get(1, 0, mask) == 0 && solve2(dx - 1, dy, (mask & ~COL) >> 1)) {
				dp.put(pos, true);
				return true;
			}
			if (get(dx - 1, dy, mask) == 0 && solve2(dx - 1, dy, mask & ~(COL << dx))) {
				dp.put(pos, true);
				return true;
			}
		}
		if (dy > 0) {
			if (get(0, 1, mask) == 0 && solve2(dx, dy - 1, mask >> 5)) {
				dp.put(pos, true);
				return true;
			}
			if (get(dx, dy - 1, mask) == 0 && solve2(dx, dy - 1, mask & ~(ROW << (dy * 5)))) {
				dp.put(pos, true);
				return true;
			}
		}
		dp.put(pos, false);
		return false;
	}

	private boolean solve2(int dx, int dy, int mask) {
		for (int i = 0; i <= dx; i++)
			for (int j = 0; j <= dy; j++)
				if ((i != 0 || j != 0) && (i != dx || j != dy) && get(i, j, mask) == 0 &&
						!solved(dx, dy, mask | (1 << (dx + dy * 5))))
					return false;
		return true;
	}

	private int get(int dx, int dy, int mask) {
		return (mask >> (dx + dy * 5)) & 1;
	}
}

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

public class Main {
	static Scanner in; static int next() throws Exception {return in.nextInt();}
	static PrintWriter out;
//	static StreamTokenizer in; static int next() throws Exception {in.nextToken(); return (int) in.nval;}
//	static BufferedReader in;

	public static void main(String[] args) throws Exception {
		in = new Scanner(System.in);
//		in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
//		in = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);

		int n = next();
		int m = next();
		int x1 = next();
		int y1 = next();
		int x2 = next();
		int y2 = next();

		int sum = Math.abs(x1 - x2) + Math.abs(y1 - y2);

		if (sum >= 6) out.println("Second");
		if (sum <= 4) out.println("First");
		if (sum == 5) {
			if (Math.min(Math.abs(x1 - x2), Math.abs(y1 - y2)) == 2) out.println("First");
			if (Math.min(Math.abs(x1 - x2), Math.abs(y1 - y2)) == 1) out.println("First");
			if (Math.min(Math.abs(x1 - x2), Math.abs(y1 - y2)) == 0) out.println("Second");
		}

		out.close();
	}
}

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

public class C176 {

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

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

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

    public static void main(String[] args) throws Exception {
        int n = nextInt(), m = nextInt();
        int x1 = nextInt(), y1 = nextInt();
        int x2 = nextInt(), y2 = nextInt();
        int dx = Math.abs(x1-x2), dy = Math.abs(y1 - y2);
        int max = Math.max(dx, dy), min = Math.min(dx, dy);
        if (max > 5) out.println("Second");
        else if (max == 5 && min == 5) out.println("Second");
        else out.println("First");
        out.flush();
    }

}

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

public class C176 {

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

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

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

    public static void main(String[] args) throws Exception {
        int n = nextInt(), m = nextInt();
        int x1 = nextInt(), y1 = nextInt();
        int x2 = nextInt(), y2 = nextInt();
        int dx = Math.abs(x1-x2)+1, dy = Math.abs(y1-y2)+1;
        int max = Math.max(dx, dy), min = Math.min(dx, dy);
        if (max > 5) out.println("Second");
        else if (max == 5 && min > 3) out.println("Second");
        else if (max == 4 && min == 4) out.println("Second");
        else out.println("First");
        out.flush();
    }

}

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

public class Main implements Runnable {

    public void _main() throws Exception {
	int n = nextInt();
	int m = nextInt();
	int x1 = nextInt();
	int y1 = nextInt();
	int x2 = nextInt();
	int y2 = nextInt();
	int h = Math.abs(x1 - x2) + 1;
	int w = Math.abs(y1 - y2) + 1;
	if ((h >= 4 && w >= 5) || (h >= 5 && w >= 4)) {
	    out.println("Second");
	} else {
	    out.println("First");
	}
    }

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

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

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

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

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

    public void run() {
        try {
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);

            _main();

            out.close();
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(202);
        }
    }

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

}

import java.util.HashSet;
import java.util.Scanner;

public class PlayingWithSuperglue
{
	public static void main(String[] args)
	{
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int m = sc.nextInt();
		int x1 = sc.nextInt();
		int y1 = sc.nextInt();
		int x2 = sc.nextInt();
		int y2 = sc.nextInt();
		int dx = Math.abs(x1-x2);
		int dy = Math.abs(y1 - y2);
		if(dx <= 4 && dy <= 4)
			System.out.println("First");
		else
			System.out.println("Second");
	}

	static HashSet<String> bad = new HashSet<String>();
	static int n,m;
	static int[] dx = {0,0,1,-1};
	static int[] dy = {1,-1,0,0};

	public static boolean win(int turn, int x1, int y1, int x2, int y2)
	{
		if(x1 == x2 && y1 == y2)
			if(turn == 0)
				return true;
			else
				return false;

		if(turn == 0)
		{
			for (int k = 0; k < dx.length; k++)
			{
				if(!bad.contains(x1 + " " + y1))
				{
					int x1_ = x1+dx[k];
					int y1_ = y1+dy[k];
					if(!win(1, x1_, y1_, x2, y2))
						return true;
				}

				if(!bad.contains(x2 + " " + y2))
				{
					int x2_ = x2+dx[k];
					int y2_ = y2+dy[k];
					if(!win(1, x1, y1, x2_, y2_))
						return true;
				}
			}
			return false;
		}
		else
		{
			for (int i = 1; i < n+1; i++)
				for (int j = 1; j < m+1; j++)
				{
					if(bad.contains(i + " " + j))
						continue;
					if(i == x1 && j == y1)
						continue;
					if(i == x2 && j == y2)
						continue;

					String s = i + " " + j;
					bad.add(s);
					boolean b = win(0, x1, y1, x2, y2);
					bad.remove(s);
					if(!b)
						return true;
				}

			return false;
		}
	}
}

import java.io.*;

public class E {

	public E () throws IOException {
		int N = sc.nextInt();
		int M = sc.nextInt();
		int X1 = sc.nextInt();
		int Y1 = sc.nextInt();
		int X2 = sc.nextInt();
		int Y2 = sc.nextInt();
		solve(N, M, X1, Y1, X2, Y2);
	}

	public void solve (int N, int M, int X1, int Y1, int X2, int Y2) {
		int D = Math.max(Math.abs(X1-X2), Math.abs(Y1-Y2));
		exit(D <= 4 ? "First" : "Second");
	}

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

	static MyScanner sc;
	static long t;

	static void print (Object o) {
		System.out.println(o);
	}

	static void exit (Object o) {
		print(o);
		//print2((millis() - t) / 1000.0);
		System.exit(0);
	}

	static void run () throws IOException {
		sc = new MyScanner ();
		new E();
	}

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

	static long millis() {
		return System.currentTimeMillis();
	}

	static void start() {
		t = millis();
	}

	static class MyScanner {
		String next() throws IOException {
			newLine();
			return line[index++];
		}

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

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

		String nextLine() throws IOException {
			line = null;
			return r.readLine();
		}

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

		private final BufferedReader r;

		MyScanner () throws IOException {
			this(new BufferedReader(new InputStreamReader(System.in)));
		}

		MyScanner(BufferedReader r) throws IOException {
			this.r = r;
		}

		private String [] line;
		private int index;

		private void newLine() throws IOException {
			if (line == null || index == line.length) {
				line = r.readLine().split(" ");
				index = 0;
			}
		}
	}
}

import java.io.*;
import java.math.BigInteger;
import java.util.*;
import java.util.Map.Entry;

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

   void solve()  throws IOException {
	  //BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
	  //Scanner in = new Scanner(System.in);
	   MyReader in = new MyReader();
	  PrintWriter out = new PrintWriter(System.out);
     // Scanner in = new Scanner(new FileReader("input.txt"));
	//  PrintWriter out = new PrintWriter("output.txt");

	  int n = in.nextInt();
	  int m = in.nextInt();
	  int x1 = in.nextInt();
	  int y1 = in.nextInt();
	  int x2 = in.nextInt();
	  int y2 = in.nextInt();

	  int a1 = Math.abs(x1 - x2);
	  int a2 = Math.abs(y1 - y2);

	  if (a1 > 4 || a2 > 4) {
		  out.println("Second");
	  } else {
		  if (a1 == 4 && a2 > 2) {
			  out.println("Second");
		  } else {
			  out.println("First");
		  }
	  }

	out.close();
   }

};

class MyReader {
	private BufferedReader in;
	String[] parsed;
	int index = 0;

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

	public int nextInt() throws NumberFormatException, IOException {
		if (parsed == null || parsed.length == index) {
			read();
		}
		return Integer.parseInt(parsed[index++]);
	}

	public long nextLong() throws NumberFormatException, IOException {
		if (parsed == null || parsed.length == index) {
			read();
		}
		return Long.parseLong(parsed[index++]);
	}

	public String nextString() throws IOException {
		if (parsed == null || parsed.length == index) {
			read();
		}
		return parsed[index++];
	}

	private void read() throws IOException {
		parsed = in.readLine().split(" ");
		index = 0;
	}

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

import static java.lang.Math.*;
import static java.lang.System.currentTimeMillis;
import static java.lang.System.exit;
import static java.lang.System.arraycopy;
import static java.util.Arrays.sort;
import static java.util.Arrays.binarySearch;
import static java.util.Arrays.fill;
import java.util.*;
import java.io.*;

public class Main {

	public static void main(String[] args) throws IOException {
		try {
			if (new File("input.txt").exists())
				System.setIn(new FileInputStream("input.txt"));
		} catch (SecurityException e) {
		}
		new Thread(null, new Runnable() {
			public void run() {
				try {
					new Main().run();
				} catch (IOException e) {
					e.printStackTrace();
					exit(999);
				}
			}
		}, "kek", 1 << 23).start();
	}

	BufferedReader in;
	PrintWriter out;
	StringTokenizer st = new StringTokenizer("");

	private void run() throws IOException {
		in = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);
		solve();
		in.close();
		out.close();
	}
	private void solve() throws IOException{
		nextInt();
		nextInt();
		int x1 = nextInt();
		int y1 = nextInt();

		int x2 = nextInt();
		int y2 = nextInt();

		int kek = max(abs(x1 - x2), abs(y1 - y2));
		if(min(abs(x1 - x2), abs(y1 - y2)) >= kek) kek++;
		out.println(kek > 4 ? "Second" : "First");

	}
	String nextToken() throws IOException {
		while (!st.hasMoreTokens())
			st = new StringTokenizer(in.readLine());
		return st.nextToken();
	}
	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 nextLine() throws IOException {
		st = new StringTokenizer("");
		return in.readLine();
	}
	boolean EOF() throws IOException {
		while (!st.hasMoreTokens()) {
			String s = in.readLine();
			if (s == null)
				return true;
			st = new StringTokenizer(s);
		}
		return false;
	}
}

import static java.lang.Math.*;
import static java.lang.System.currentTimeMillis;
import static java.lang.System.exit;
import static java.lang.System.arraycopy;
import static java.util.Arrays.sort;
import static java.util.Arrays.binarySearch;
import static java.util.Arrays.fill;
import java.util.*;
import java.io.*;

public class Main {

	public static void main(String[] args) throws IOException {
		try {
			if (new File("input.txt").exists())
				System.setIn(new FileInputStream("input.txt"));
		} catch (SecurityException e) {
		}
		new Thread(null, new Runnable() {
			public void run() {
				try {
					new Main().run();
				} catch (IOException e) {
					e.printStackTrace();
					exit(999);
				}
			}
		}, "kek", 1 << 23).start();
	}

	BufferedReader in;
	PrintWriter out;
	StringTokenizer st = new StringTokenizer("");

	private void run() throws IOException {
		in = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);
		solve();
		in.close();
		out.close();
	}
	private void solve() throws IOException{
		nextInt();
		nextInt();
		int x1 = nextInt();
		int y1 = nextInt();

		int x2 = nextInt();
		int y2 = nextInt();

		int kek = max(abs(x1 - x2), abs(y1 - y2));
		out.println(kek > 4 ? "Second" : "First");

	}
	String nextToken() throws IOException {
		while (!st.hasMoreTokens())
			st = new StringTokenizer(in.readLine());
		return st.nextToken();
	}
	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 nextLine() throws IOException {
		st = new StringTokenizer("");
		return in.readLine();
	}
	boolean EOF() throws IOException {
		while (!st.hasMoreTokens()) {
			String s = in.readLine();
			if (s == null)
				return true;
			st = new StringTokenizer(s);
		}
		return false;
	}
}