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

public class game_ab implements Runnable {
    public static void main(String[] args) {
	new Thread(new game_ab()).start();
    }

    @Override
    public void run() {
	try {
	    br = new BufferedReader(new FileReader("game.in"));
	    out = new PrintWriter("game.out");
	    solve();
	    out.close();
	} catch (Throwable e) {
	    e.printStackTrace();
	    System.exit(-1);
	}
    }

    BufferedReader br;
    StringTokenizer st;
    PrintWriter out;
    boolean eof = true;

    String cnv(String a) {
	return a.equals("") ? "0" : a;
    }

    String nextToken() {
	while (st == null || !st.hasMoreElements()) {
	    try {
		st = new StringTokenizer(br.readLine());
	    } catch (Exception e) {
		eof = true;
		return "";
	    }
	}
	return st.nextToken();
    }

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

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

    final int MAX = 100000;
    final int MAXC = 1000000000;
    void myAssert(boolean e) {
	if (!e) {
	    throw new Error("assertion failed");
	}
    }
    
    private void solve() throws IOException {
	int n = nextInt();
	myAssert(1 <= n && n <= MAX);
	int m = nextInt();
	myAssert(1 <= m && m <= MAX);
	g = new ArrayList[n];
	for (int i = 0; i < n; ++i) {
	    g[i] = new ArrayList<Edge>();
	}
	for (int i = 0; i < m; ++i) {
	    int a = nextInt() - 1;
	    myAssert(0 <= a && a < n);
	    int b = nextInt() - 1;
	    myAssert(0 <= b && b < n);
	    myAssert(a != b);
	    int c = nextInt();
	    myAssert(1 <= c && c <= MAXC);
	    g[a].add(new Edge(b, c));
	    g[b].add(new Edge(a, c));
	}
	
	int s1 = nextInt() - 1;
	myAssert(0 <= s1 && s1 < n);
	int s2 = nextInt() - 1;
	myAssert(0 <= s2 && s2 < n);
	int t = nextInt() - 1;
	myAssert(0 <= t && t < n);
	
	long[] d = new long[n];
	Arrays.fill(d, INF);
	d[t] = 0;
	
	Tree pq = new Tree(n);
	pq.set(t, 0);
	while (pq.get(pq.getInd()) < INF) {
	    int u = pq.getInd();
	    pq.set(u, INF);
	    for (Edge e : g[u]) {
		if (d[e.b] > d[u] + e.c) {
		    d[e.b] = d[u] + e.c;
		    pq.set(e.b, d[e.b]);
		}
	    }
	}
	
	for (int i = 0; i < n; ++i) {
	    myAssert(d[i] < INF);
	}
	
	if (d[s1] <= d[s2]) {
	    out.println("First");
	} else {
	    out.println("Second");
	}
	
    }

    long INF = Long.MAX_VALUE / 8;
    
    
    ArrayList<Edge>[] g;
    
    class Edge {
	int b;
	long c;
	
	public Edge(int b, long c) {
	    this.b = b;
	    this.c = c;
	}
    }
    
    class Tree {
	long[] v;
	int[] x;
	int m;
	
	public Tree(int n) {
	    m = 1;
	    while (m < n) m <<= 1;
	    v = new long[2 * m];
	    x = new int[2 * m];
	    Arrays.fill(v, INF);
	    for (int i = 0; i < m; ++i) {
		x[i + m] = i;
	    }
	    for (int i = m - 1; i > 0; --i) {
		x[i] = x[2 * i];
	    }
	}
	
	void set(int i, long val) {
	    i += m;
	    v[i] = val;
	    i >>= 1;
	    while (i > 0) {
		int j = 2 * i;
		if (v[j + 1] < v[j]) ++j;
		v[i] = v[j];
		x[i] = x[j];
		i >>= 1;
	    }
	}
	
	int getInd() {
	    return x[1];
	}
	
	long get(int i) {
	    return v[i + m];
	}
	
    }
    
}
