/*
 * Solution Template for Tennis Robot II
 * 
 * Australian Informatics Olympiad 2024
 * 
 * This file is provided to assist with reading and writing of the input
 * files for the problem. You may modify this file however you wish, or
 * you may choose not to use this file at all.
 */

import java.io.*;

class Solution {

    /* N is the number of bins. */
    private static int N;

    /* M is the number of instructions. */
    private static int M;

    /*
     * X contains the number of balls in each bin. Note that this array starts
     * from 1 (not 0), and so the values are X[1] to X[N].
     */
    private static long X[] = new long[200005];

    /*
     * A and B contain the instructions. Note that the arrays start from 0, and
     * so the instructions are (A[0], B[0]) to (A[M-1], B[M-1]).
     */
    private static int A[] = new int[200005];
    private static int B[] = new int[200005];

    private static long answer;
    /*
     * Read the next token from the input file.
     * Tokens are separated by whitespace, i.e., spaces, tabs and newlines.
     * If end-of-file is reached then an empty string is returned.
     */
    private static String readToken(BufferedReader in) throws IOException {
        StringBuffer ans = new StringBuffer();
        int next;

        /* Skip any initial whitespace. */
        next = in.read();
        while (next >= 0 && Character.isWhitespace((char)next))
            next = in.read();

        /* Read the following token. */
        while (next >= 0 && ! Character.isWhitespace((char)next)) {
            ans.append((char)next);
            next = in.read();
        }

        return ans.toString();
    }

    public static void main(String[] args) throws IOException {
        /* Open the input and output files. */
        BufferedReader input_file = new BufferedReader(new FileReader(
                "tennisin.txt"));
        BufferedWriter output_file = new BufferedWriter(new FileWriter(
                "tennisout.txt"));

        /* Read the values of N, M, X, A, and B from input file. */
        N = Integer.parseInt(readToken(input_file));
        M = Integer.parseInt(readToken(input_file));

        /* Values in X are indexed from 1 to N (not 0 to N-1) */
        for (int i = 1; i <= N; i++) {
            X[i] = Long.parseLong(readToken(input_file));
        }

        for (int i = 0; i < M; i++) {
            A[i] = Integer.parseInt(readToken(input_file));
            B[i] = Integer.parseInt(readToken(input_file));
        }

        /*
         * TODO: This is where you should compute your solution. Store the
         * number of instructions that the robot will successfully complete (or
         * -1 if it will run forever) into the variable answer.
         */

        /*
         * Please note that the answer may exceed the maximum value
         * that can be stored in an "int" integer type.
         * Because of this, you should use the "long" integer type
         * instead of "int" when computing your solution.
         */

        /* Write the answer to the output file. */
        if (answer == -1) {
            output_file.write("FOREVER\n");
        } else {
            output_file.write(answer + "\n");
        }

        /* Finally, close the input/output files. */
        input_file.close();
        output_file.close();
    }
}