#include <bits/stdc++.h>
#include <bits/extc++.h> 
using namespace std;
#define sz(x) (int)(x).size()
#define rep(i, l, r) for (int i = l; i < (r); i++)
#define rrep(i, l, r) for(int i = (int)(r)-1; i >= (int)(l); i--)
#define all(x) begin(x), end(x)

using ll = long long;
using vi = vector<int>;

using pii = pair<int, int>;


template <class S, S (*op)(S, S), S (*e)()> struct segtree {
  private:
    int n;
    int size;
    vector<S> data;

    void update(int i) {
        data[i] = op(data[2 * i], data[2 * i + 1]);
    }

  public:
    segtree(int n) : segtree(vector<S>(n, e())) {}
    segtree(const vector<S> &v) : n((int)v.size()), size(1) {
        while (size < n) size *= 2;
        data = vector<S>(2 * size, e());
        rep(i, 0, n) {
            data[size + i] = v[i];
        }
        rrep(i, 1, size) update(i);
    }

    void set(int p, S x) {
        assert(0 <= p && p < n);
        p += size;
        data[p] = x;
        while (p > 1) {
            p >>= 1;
            update(p);
        }
    }

    S get(int p) {
        assert(0 <= p && p < n);
        return data[p + size];
    }

    S prod(int l, int r) {
        assert(0 <= l && l <= r && r <= n);
        S sml = e(), smr = e();
        l += size;
        r += size;
        while (l < r) {
            if (l & 1) sml = op(sml, data[l++]);
            if (r & 1) smr = op(data[--r], smr);
            l >>= 1;
            r >>= 1;
        }
        return op(sml, smr);
    }

    S all_prod() {
        return data[1];
    }

    template <class F> int max_right(int l, F f) {
        assert(0 <= l && l <= n);
        assert(f(e()));
        if (l == n) return n;
        l += size;
        S sm = e();
        do {
            while (l % 2 == 0) l >>= 1;
            if (!f(op(sm, data[l]))) {
                while (l < size) {
                    l = 2 * l;
                    if (f(op(sm, data[l]))) {
                        sm = op(sm, data[l]);
                        l++;
                    }
                }
                return l - size;
            }
            sm = op(sm, data[l]);
            l++;
        } while ((l & -l) != l);
        return n;
    }

};

using ull = unsigned long long;

ull gcd(ull a, ull b) {
    if (b == 0) return a;
    return gcd(b, a % b);
}

ull e() {
    return 0;
}

int main() {
    int n, q;cin >> n >> q;
    vector<ull> a(n);rep(i, 0, n) cin >> a[i];

    segtree<ull, gcd, e> st(a);
    vector<vector<pair<int, ull>>> g(n);
    rep(i, 0, n) {
        ull now = a[i];
        int l = i;
        while (true) {
            int r = st.max_right(l, [&](ull x)->bool{if (now == 0)return x == 0;else return x % now == 0;});
            g[i].emplace_back(r, st.prod(i, r));
            // cout << i << " " << r << " " << st.prod(i, r) << endl;

            if (r == n)break;
            now = st.prod(i, r + 1);
        }
    }

    rep(_, 0, q) {
        int l, r, k;cin >> l >> r >> k;
        l--;
        auto dfs = [&](auto self, int x, int d, ull now) -> ull {
            if (d == k && x >= r)return now;
            if (x >= r) return 0;
            if (d == k) return gcd(now, st.prod(x, r));
            if (now == 1) return 1;
            ull ans = self(self, x+1, d+1, now);
            for (auto[y, gc] : g[x]) {
                ans = max(ans, self(self, y + 1, d + 1, gcd(now, gc)));
                if (y >= r) break;
            }
            return ans;
        };

        cout << dfs(dfs, l, 0, 0) << endl;
    }
}