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

public class TaskD {
    private final InputReader reader;
    private final OutputWriter writer;

    public TaskD(InputReader reader, OutputWriter writer) {
        this.reader = reader;
        this.writer = writer;
    }

    public static void main(String[] args) {
        InputReader reader = new InputReader(System.in);
        OutputWriter writer = new OutputWriter(System.out);
        new TaskD(reader, writer).run();
        writer.writer.flush();
    }

    int[] A, B, L;

    List<Integer>[] E;
    int n, m;

    long[] dij(int s) {
        long[] D = new long[n];
        Arrays.fill(D, (long) 1e18);
        D[s] = 0;
        boolean[] was = new boolean[n];
        long last = -1;
        int pt = 0;
        for (int i = 0; i < n; i++) {
            int mni = -1;
            for (int j = 0; j < n; j++)
                if (!was[j] && (mni == -1 || D[mni] > D[j]))
                    mni = j;
            if (mni == -1)
                throw new AssertionError();
            if (D[mni] != last) {
                last = D[mni];
                pt++;
            }
            for (int e : E[mni]) {
                int y = mni ^ A[e] ^ B[e];
                if (was[y])
                    continue;
                D[y] = Math.min(D[y], D[mni] + L[e]);
            }
            D[mni] = pt;
            was[mni] = true;
        }
        return D;
    }

    long[][] V;
    short[][] cnt;
    long[][] SV;
    short[][] Scnt;
    long get_sum(int x1, int y1, int x2, int y2) {
        x2++;
        y2++;
        return SV[x2][y2] - SV[x2][y1] - SV[x1][y2] + SV[x1][y1];
    }

    int get_cnt(int x1, int y1, int x2, int y2) {
        x2++;
        y2++;
        return Scnt[x2][y2] - Scnt[x2][y1] - Scnt[x1][y2] + Scnt[x1][y1];
    }

    public void run() {
        n = reader.nextInt();
        m = reader.nextInt();
        int s = reader.nextInt() - 1;
        int t = reader.nextInt() - 1;
        long[] W = new long[n];
        for (int i = 0; i < n; i++)
            W[i] = reader.nextInt();
        A = new int[m];
        B = new int[m];
        L = new int[m];
        E = new List[n];
        for (int i = 0; i < n; i++)
            E[i] = new ArrayList<Integer>(1);
        for (int i = 0; i < m; i++) {
            A[i] = reader.nextInt() - 1;
            B[i] = reader.nextInt() - 1;
            L[i] = reader.nextInt();
            E[A[i]].add(i);
            E[B[i]].add(i);
        }
        long[] Ds = dij(s);
        long[] Dt = dij(t);
        int mxs = -1, mxt = -1;
        for (long d : Ds)
            mxs = (int)Math.max(d, mxs);
        for (long d : Dt)
            mxt = (int)Math.max(d, mxt);
        long[][] DS = new long[mxs + 1][mxt + 1], DT = new long[mxs + 1][mxt + 1];
        V = new long[mxs + 1][mxt + 1];
        cnt = new short[mxs + 1][mxt + 1];
        for (int i = 0; i < n; i++) {
            V[(int) Ds[i]][(int) Dt[i]] += W[i];
            cnt[(int) Ds[i]][(int) Dt[i]]++;
        }
        SV = new long[mxs + 2][mxt + 2];
        Scnt = new short[mxs + 2][mxt + 2];
        for (int i = 0; i < mxs + 1; i++)
            for (int j = 0; j < mxt + 1; j++) {
                SV[i + 1][j + 1] = SV[i + 1][j] + SV[i][j + 1] - SV[i][j] + V[i][j];
                Scnt[i + 1][j + 1] = (short)(Scnt[i + 1][j] + Scnt[i][j + 1] - Scnt[i][j] + cnt[i][j]);
            }

        for (int i = 0; i <= mxs; i++)
            for (int j = 0; j <= mxt; j++)
                DS[i][j] = DT[i][j] = (long)-1e15;
        int[] posS = new int[mxt + 1];
        long[] curmnS = new long[mxt + 1];
        int[] posT = new int[mxs + 1];
        long[] curmnT = new long[mxs + 1];
        Arrays.fill(posS, mxs + 1);
        Arrays.fill(posT, mxt + 1);
        Arrays.fill(curmnS, (long)-1e15);
        Arrays.fill(curmnT, (long)-1e15);
        for (int i = mxs; i >= 0; i--)
            for (int j = mxt; j >= 0; j--) {
                if (get_cnt(i + 1, j + 1, mxs, mxt) == 0) {
                    DS[i][j] = DT[i][j] = 0;
                    continue;
                }
                if (get_cnt(i + 1, j + 1, i + 1, mxt) != 0) {
                    while (posS[j] >  i + 1) {
                        posS[j]--;
                        curmnS[j] = Math.max(curmnS[j], get_sum(0, j + 1, posS[j], mxt) - DT[posS[j]][j]);
                    }
                }
                if (get_cnt(i + 1, j + 1, mxs, j + 1) != 0) {
                    while (posT[i] > j + 1) {
                        posT[i]--;
                        curmnT[i] = Math.max(curmnT[i], get_sum(i + 1, 0, mxs, posT[i]) - DS[i][posT[i]]);
                    }
                }
                DS[i][j] = Math.max(DS[i][j], -get_sum(0, j + 1, i, mxt) + curmnS[j]);
                DT[i][j] = Math.max(DT[i][j], -get_sum(i + 1, 0, mxs, j) + curmnT[i]);
            }
        long val = DS[0][0];
        if (val > 0)
            writer.printf("Break a heart\n");
        else if (val < 0)
            writer.printf("Cry\n");
        else
            writer.printf("Flowers\n");
    }


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

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

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

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

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

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

    static class OutputWriter {
        public PrintWriter writer;

        OutputWriter(OutputStream stream) {
            writer = new PrintWriter(stream);
        }

        public void printf(String format, Object... args) {
            writer.print(String.format(Locale.ENGLISH, format, args));
        }
    }
}