Two players play a game. The game is played on a rectangular board with n × m squares. At the beginning of the game two different squares of the board have two chips. The first player's goal is to shift the chips to the same square. The second player aims to stop the first one with a tube of superglue.We'll describe the rules of the game in more detail.The players move in turns. The first player begins.With every move the first player chooses one of his unglued chips, and shifts it one square to the left, to the right, up or down. It is not allowed to move a chip beyond the board edge. At the beginning of a turn some squares of the board may be covered with a glue. The first player can move the chip to such square, in this case the chip gets tightly glued and cannot move any longer.At each move the second player selects one of the free squares (which do not contain a chip or a glue) and covers it with superglue. The glue dries long and squares covered with it remain sticky up to the end of the game.If, after some move of the first player both chips are in the same square, then the first player wins. If the first player cannot make a move (both of his chips are glued), then the second player wins. Note that the situation where the second player cannot make a move is impossible — he can always spread the glue on the square from which the first player has just moved the chip.We will further clarify the case where both chips are glued and are in the same square. In this case the first player wins as the game ends as soon as both chips are in the same square, and the condition of the loss (the inability to move) does not arise.You know the board sizes and the positions of the two chips on it. At the beginning of the game all board squares are glue-free. Find out who wins if the players play optimally.

The first line contains six integers n, m, x1, y1, x2, y2 — the board sizes and the coordinates of the first and second chips, correspondingly (1 ≤ n, m ≤ 100; 2 ≤ n × m; 1 ≤ x1, x2 ≤ n; 1 ≤ y1, y2 ≤ m). The numbers in the line are separated by single spaces. It is guaranteed that the chips are located in different squares.

If the first player wins, print "First" without the quotes. Otherwise, print "Second" without the quotes.

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

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