import java.io.OutputStream; import java.io.IOException; import java.io.InputStream; import java.util.Arrays; import java.nio.ByteBuffer; import java.nio.charset.Charset; import java.util.NoSuchElementException; import java.io.OutputStream; import java.nio.CharBuffer; import java.io.IOException; import java.nio.charset.CharsetDecoder; import java.lang.reflect.Field; import java.nio.charset.StandardCharsets; import java.util.Objects; import java.io.UncheckedIOException; import java.io.Writer; import java.io.InputStream; /** * Built using CHelper reloaded plug-in * Actual solution is at the top * * @author mikit */ public class Main { public static void main(String[] args) { InputStream inputStream = System.in; OutputStream outputStream = System.out; LightScanner2 in = new LightScanner2(inputStream); LightWriter2 out = new LightWriter2(outputStream); No1208AntiPrimenumberGame solver = new No1208AntiPrimenumberGame(); solver.solve(1, in, out); out.close(); } static class No1208AntiPrimenumberGame { public void solve(int testNumber, LightScanner2 in, LightWriter2 out) { out.setBoolLabel(LightWriter2.BoolLabel.FIRST_SECOND_FIRST_UP); int n = in.ints(); long m = in.longs(); long[] a = in.longs(n); long[][] dp = new long[2][n + 1]; for (int i = n - 1; i >= 0; i--) { if (a[i] == 1) { dp[0][i] = dp[1][i + 1] + (a[i] - m); dp[1][i] = dp[0][i + 1] - (a[i] - m); } else { dp[0][i] = Math.max(dp[0][i + 1] + (a[i] + m - 2), dp[1][i + 1] + (a[i] - m)); dp[1][i] = Math.max(dp[1][i + 1] - (a[i] + m - 2), dp[0][i + 1] - (a[i] - m)); } } out.ans(dp[0][0] > 0).ln(); } } static class LightScanner2 extends LightScannerAdapter { private static final int BUF_SIZE = 32 * 1024; private final InputStream stream; private final StringBuilder builder = new StringBuilder(); private final byte[] buf = new byte[BUF_SIZE]; private int ptr; private int len; public LightScanner2(InputStream stream) { this.stream = stream; } private int read() { if (ptr < len) return buf[ptr++]; try { ptr = 0; len = stream.read(buf); } catch (IOException ex) { throw new UncheckedIOException(ex); } if (len == -1) return -1; return buf[ptr++]; } private void skip() { int b; while (isTokenSeparator(b = read()) && b != -1) ; if (b == -1) throw new NoSuchElementException("EOF"); ptr--; } private void loadToken() { builder.setLength(0); skip(); for (int b = read(); !isTokenSeparator(b); b = read()) { builder.appendCodePoint(b); } } public String string() { loadToken(); return builder.toString(); } public int ints() { long x = longs(); if (x < Integer.MIN_VALUE || Integer.MAX_VALUE < x) throw new NumberFormatException("Overflow"); return (int) x; } public long longs() { skip(); int b = read(); boolean negate; if (b == '-') { negate = true; b = read(); } else negate = false; long x = 0; for (; !isTokenSeparator(b); b = read()) { if ('0' <= b && b <= '9') x = x * 10 + b - '0'; else throw new NumberFormatException("Unexpected character '" + b + "'"); } return negate ? -x : x; } public void close() { try { stream.close(); } catch (IOException e) { throw new UncheckedIOException(e); } } private static boolean isTokenSeparator(int b) { return b < 33 || 126 < b; } } static class LightWriter2 implements AutoCloseable { private static final int BUF_SIZE = 32 * 1024; private static final int BUF_THRESHOLD = 1024; private final OutputStream out; private final byte[] buf = new byte[BUF_SIZE]; private int ptr; private final Field fastStringAccess; private boolean autoflush = false; private boolean breaked = true; private LightWriter2.BoolLabel boolLabel = LightWriter2.BoolLabel.YES_NO_FIRST_UP; public LightWriter2(OutputStream out) { this.out = out; Field f; try { f = String.class.getDeclaredField("value"); f.setAccessible(true); if (f.getType() != byte[].class) f = null; } catch (ReflectiveOperationException ignored) { f = null; } this.fastStringAccess = f; } public LightWriter2(Writer out) { this.out = new LightWriter2.WriterOutputStream(out); this.fastStringAccess = null; } public void setBoolLabel(LightWriter2.BoolLabel label) { this.boolLabel = Objects.requireNonNull(label); } private void allocate(int n) { if (ptr + n <= BUF_SIZE) return; try { out.write(buf, 0, ptr); ptr = 0; } catch (IOException ex) { throw new UncheckedIOException(ex); } if (BUF_SIZE < n) throw new IllegalArgumentException("Internal buffer exceeded"); } public void close() { try { out.write(buf, 0, ptr); ptr = 0; out.flush(); out.close(); } catch (IOException ex) { throw new UncheckedIOException(ex); } } public LightWriter2 print(char c) { allocate(1); buf[ptr++] = (byte) c; breaked = false; return this; } public LightWriter2 print(String s) { byte[] bytes; if (this.fastStringAccess == null) bytes = s.getBytes(); else { try { bytes = (byte[]) fastStringAccess.get(s); } catch (IllegalAccessException ignored) { bytes = s.getBytes(); } } int n = bytes.length; if (n <= BUF_THRESHOLD) { allocate(n); System.arraycopy(bytes, 0, buf, ptr, n); ptr += n; return this; } try { out.write(buf, 0, ptr); ptr = 0; out.write(bytes); out.flush(); } catch (IOException ex) { throw new UncheckedIOException(ex); } return this; } public LightWriter2 ans(String s) { if (!breaked) { print(' '); } return print(s); } public LightWriter2 ans(boolean b) { return ans(boolLabel.transfer(b)); } public LightWriter2 ln() { print(System.lineSeparator()); breaked = true; if (autoflush) { try { out.flush(); } catch (IOException ex) { throw new UncheckedIOException(ex); } } return this; } public enum BoolLabel { YES_NO_FIRST_UP("Yes", "No"), YES_NO_ALL_UP("YES", "NO"), YES_NO_ALL_DOWN("yes", "no"), Y_N_ALL_UP("Y", "N"), POSSIBLE_IMPOSSIBLE_FIRST_UP("Possible", "Impossible"), POSSIBLE_IMPOSSIBLE_ALL_UP("POSSIBLE", "IMPOSSIBLE"), POSSIBLE_IMPOSSIBLE_ALL_DOWN("possible", "impossible"), FIRST_SECOND_FIRST_UP("First", "Second"), FIRST_SECOND_ALL_UP("FIRST", "SECOND"), FIRST_SECOND_ALL_DOWN("first", "second"), ALICE_BOB_FIRST_UP("Alice", "Bob"), ALICE_BOB_ALL_UP("ALICE", "BOB"), ALICE_BOB_ALL_DOWN("alice", "bob"), ; private final String positive; private final String negative; BoolLabel(String positive, String negative) { this.positive = positive; this.negative = negative; } private String transfer(boolean f) { return f ? positive : negative; } } private static class WriterOutputStream extends OutputStream { final Writer writer; final CharsetDecoder decoder; WriterOutputStream(Writer writer) { this.writer = writer; this.decoder = StandardCharsets.UTF_8.newDecoder(); } public void write(int b) throws IOException { writer.write(b); } public void write(byte[] b) throws IOException { writer.write(decoder.decode(ByteBuffer.wrap(b)).array()); } public void write(byte[] b, int off, int len) throws IOException { writer.write(decoder.decode(ByteBuffer.wrap(b, off, len)).array()); } public void flush() throws IOException { writer.flush(); } public void close() throws IOException { writer.close(); } } } static abstract class LightScannerAdapter implements AutoCloseable { public abstract String string(); public long longs() { return Long.parseLong(string()); } public final long[] longs(int length) { long[] res = new long[length]; Arrays.setAll(res, ignored -> longs()); return res; } public abstract void close(); } }