#include <bits/stdc++.h>
using namespace std;

using ll = long long;
using ld = long double;

#define all(a) begin(a), end(a)
#define len(a) int((a).size())

#ifdef LOCAL
    #include "debug.h"
#else
    #define dbg(...)
    #define dprint(...)
    #define debug if constexpr (false)
    #define draw_tree(...)
    #define draw_array(...)
#endif // LOCAL

constexpr int LG = 25;

struct info {
    array<int, LG> a;
    int st = 0, length = 0;

    void push(int x) {
        if (length + 2 == LG) {
            length--;
        }
        length++;
        st = (st + LG - 1) % LG;
        a[st] = x;
    }

    int solve(int l) {
        if (length <= 1) {
            return 1e9;
        }
        int nxt = a[st];
        int lim = 2 * nxt - l;

        int lb = 0, rb = length;
        while (rb - lb > 1) {
            int mid = (lb + rb) / 2;
            (a[(st + mid) % LG] >= lim ? rb : lb) = mid;
        }
        if (rb != length) {
            return a[(st + rb) % LG];
        }
        return 1e9;
    }
};

int main() {
    cin.tie(nullptr)->sync_with_stdio(false);

    int n, q;
    cin >> n >> q;
    vector<int> a(n);
    for (auto &x : a) {
        cin >> x;
    }

    vector<vector<pair<int, int>>> queries(n);
    vector<int> ans(q);
    for (int i = 0; i < q; i++) {
        int l, r;
        cin >> l >> r;
        l--, r--;
        queries[l].emplace_back(r, i);
    }

    const int N = *max_element(all(a)) + 3;
    vector<vector<int>> divs(N);
    for (int x = 1; x < N; x++) {
        for (int y = x; y < N; y += x) {
            divs[y].push_back(x);
        }
    }

    const int B = sqrt(n);
    const int nblocks = (n + B - 1) / B;
    vector<int> best(n), block_best(nblocks);

    auto update = [&](int r, int value) {
        best[r] = max(best[r], value);
        int block = r / B;
        block_best[block] = max(block_best[block], value);
    };

    vector<info> data(N);
    for (int l = n - 1; l >= 0; l--) {
        for (auto d : divs[a[l]]) {
            int min_r = data[d].solve(l);
            if (min_r < n) {
                update(min_r, d);
            }
            data[d].push(l);
        }
        for (auto [r, i] : queries[l]) {
            while (r >= 0 && r % B != B - 1) {
                ans[i] = max(ans[i], best[r]);
                r--;
            }
            for (int j = 0; j <= r / B; j++) {
                ans[i] = max(ans[i], block_best[j]);
            }
        }
    }

    for (auto x : ans) {
        cout << x << '\n';
    }
}