import java.io.OutputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.io.PrintWriter;
    import java.util.Arrays;
    import java.io.BufferedWriter;
    import java.io.Writer;
    import java.io.OutputStreamWriter;
    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;
            InputReader in = new InputReader(inputStream);
            OutputWriter out = new OutputWriter(outputStream);
            GCDQuery solver = new GCDQuery();
            solver.solve(1, in, out);
            out.close();
        }

        static class GCDQuery {
            int[][] ans;
            int[] last;

            void q(int div, int idx) {
                if (idx != last[div] && last[div] != -1)
                    ans[last[div]][idx] = Math.max(ans[last[div]][idx], div);
                last[div] = idx;
            }

            public void solve(int testNumber, InputReader in, OutputWriter out) {
                int n = in.nextInt(), q = in.nextInt();
                int[] arr = in.readIntArray(n);
                ans = new int[n][n];
                last = new int[100000001];
                Arrays.fill(last, -1);
                for (int i = 0; i < n; i++) {
                    for (int div = 1; div * div <= arr[i]; div++) {
                        if (arr[i] % div == 0) {
                            q(div, i);
                            q(arr[i] / div, i);
                        }
                    }
                }
                for (int i = n - 1; i >= 0; i--) {
                    for (int j = i + 1; j < n; j++) {
                        ans[i][j] = AUtils.max(ans[i][j - 1], ans[i + 1][j], ans[i][j]);
                    }
                }
                while (q-- > 0) {
                    int l = in.nextInt() - 1, r = in.nextInt() - 1;
                    out.println(ans[l][r]);
                }

            }

        }

        static class InputReader {
            private InputStream stream;
            private byte[] buf = new byte[1 << 16];
            private int curChar;
            private int numChars;

            public InputReader(InputStream stream) {
                this.stream = stream;
            }

            public int[] readIntArray(int tokens) {
                int[] ret = new int[tokens];
                for (int i = 0; i < tokens; i++) {
                    ret[i] = nextInt();
                }
                return ret;
            }

            public int read() {
                if (this.numChars == -1) {
                    throw new InputMismatchException();
                } else {
                    if (this.curChar >= this.numChars) {
                        this.curChar = 0;

                        try {
                            this.numChars = this.stream.read(this.buf);
                        } catch (IOException var2) {
                            throw new InputMismatchException();
                        }

                        if (this.numChars <= 0) {
                            return -1;
                        }
                    }

                    return this.buf[this.curChar++];
                }
            }

            public int nextInt() {
                int c;
                for (c = this.read(); isSpaceChar(c); c = this.read()) {
                    ;
                }

                byte sgn = 1;
                if (c == 45) {
                    sgn = -1;
                    c = this.read();
                }

                int res = 0;

                while (c >= 48 && c <= 57) {
                    res *= 10;
                    res += c - 48;
                    c = this.read();
                    if (isSpaceChar(c)) {
                        return res * sgn;
                    }
                }

                throw new InputMismatchException();
            }

            public static boolean isSpaceChar(int c) {
                return c == 32 || c == 10 || c == 13 || c == 9 || c == -1;
            }

        }

        static class OutputWriter {
            private final PrintWriter writer;

            public OutputWriter(OutputStream outputStream) {
                writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
            }

            public OutputWriter(Writer writer) {
                this.writer = new PrintWriter(writer);
            }

            public void close() {
                writer.close();
            }

            public void println(int i) {
                writer.println(i);
            }

        }

        static class AUtils {
            public static <E extends Comparable<E>> E max(E... arr) {
                E res = arr[0];
                for (E x : arr) if (x.compareTo(res) > 0) res = x;
                return res;
            }

        }
    }