#include <bits/stdc++.h>
#define ios ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
#define x first
#define y second
#define endl '\n'
using namespace std;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
typedef pair<int, int> PII;
const int N = 2e5 + 10;
const int M = 5e5 + 10;
const int INF = 2e9;
const double INFF = 2e18, Pi = acos(-1);
const int mod = 1e9 + 7;
int t, n, m, q;

struct Edge
{
    int a, b, c;
    bool operator<(const Edge &W) const
    {
        return c < W.c;
    }
} E[N];
int h[N], e[M * 2], ne[M * 2], idx, cnt, idxx, dfn;
int p[N], val[N], fa[N][21], Max[N][21];
int L[N], R[N];
int rt[N];
int b[N];
int nn;
int a[N];
int se[N];

struct Node
{
    int ls, rs, cnt;
} tr[N << 5];
void init(int _n)
{
    cnt = _n;
    idx = 0;
    idxx = 0;
    for (int i = 0; i <= 2 * _n; i++)
    {
        p[i] = i, val[i] = 0;
        h[i] = -1;
    }
}

void add(int a, int b)
{
    e[idxx] = b, ne[idxx] = h[a], h[a] = idxx++;
}

int find(int x)
{
    if (x != p[x])
        p[x] = find(p[x]);
    return p[x];
}
int update(int p, int l, int r, int x)
{
    int q = ++idx;
    tr[q] = tr[p];
    if (l == r)
    {
        tr[q].cnt++;
    }
    else
    {
        int mid = (l + r) >> 1;
        if (x <= mid)
            tr[q].ls = update(tr[q].ls, l, mid, x);
        else
            tr[q].rs = update(tr[q].rs, mid + 1, r, x);
        tr[q].cnt = tr[tr[q].ls].cnt + tr[tr[q].rs].cnt;
    }
    return q;
}

int query(int p, int q, int l, int r, int k)
{
    if (l == r)
    {
        return l;
    }
    else
    {
        int mid = (l + r) >> 1;
        if (tr[tr[q].rs].cnt - tr[tr[p].rs].cnt >= k)
        {
            return query(tr[p].rs, tr[q].rs, mid + 1, r, k);
        }
        else
        {
            return query(tr[p].ls, tr[q].ls, l, mid, k - (tr[tr[q].rs].cnt - tr[tr[p].rs].cnt));
        }
    }
}

void build()
{
    sort(E + 1, E + m + 1);
    for (int i = 1; i <= m; i++)
    {
        auto [a, b, c] = E[i];
        int pa = find(a), pb = find(b);
        if (pa != pb)
        {
            ++cnt;
            add(cnt, pa), add(cnt, pb);
            val[cnt] = c;
            p[pa] = cnt, p[pb] = cnt;
            if (cnt == 2 * n - 1)
                break;
        }
    }
}

void dfs(int u, int p)
{
    fa[u][0] = p;
    Max[u][0] = val[p];
    L[u] = ++dfn;
    if (u <= n)
    {
        se[u] = 1;
        rt[dfn] = update(rt[dfn - 1], 1, nn, a[u]);
    }
    else
        rt[dfn] = rt[dfn - 1];
    for (int k = 1; k <= 20; k++)
    {
        fa[u][k] = fa[fa[u][k - 1]][k - 1];
        Max[u][k] = max(Max[u][k - 1], Max[fa[u][k - 1]][k - 1]);
    }
    for (int i = h[u]; i != -1; i = ne[i])
    {
        int j = e[i];
        dfs(j, u);
        se[u] += se[j];
    }
    R[u] = dfn;
}

int get(int u, int x)
{
    for (int i = 20; i >= 0; i--)
    {
        if (Max[u][i] <= x && fa[u][i] != 0)
        {
            u = fa[u][i];
        }
    }
    // cout << u << endl;
    return u;
}

signed main()
{
    ios;
    cin >> n >> m >> q;
    init(n);
    for (int i = 1; i <= n; i++)
        cin >> a[i], b[i] = a[i];
    sort(b + 1, b + n + 1);
    nn = unique(b + 1, b + n + 1) - (b + 1);
    for (int i = 1; i <= n; i++)
    {
        a[i] = lower_bound(b + 1, b + nn + 1, a[i]) - b;
    }
    for (int i = 1; i <= m; i++)
    {
        int a, b, c;
        cin >> a >> b >> c;
        E[i] = {a, b, c};
    }
    build();
    for (int i = 1; i <= 2 * n - 1; i++)
    {
        if (find(i) == i)
        {
            dfs(i, 0);
        }
    }
    int last = 0;
    while (q--)
    {
        int u, x, k;
        cin >> u >> x >> k;
        u = (u ^ last) % n + 1, k = (k ^ last) % n + 1, x = x ^ last;
        int now = get(u, x);
        int ans = 0;
        if (se[now] < k)
        {
            ans = -1;
            last = 0;
        }
        else
        {
            int l = L[now], r = R[now];
            int res = query(rt[l - 1], rt[r], 1, nn, k);
            ans = b[res];
            last = ans;
        }
        cout << ans << endl;
    }
    // cout << ">>>" << endl;
    return 0;
}
/*
stuff you should look for
* int overflow, array bounds
* special cases (n=1?)
* do smth instead of nothing and stay organized
* WRITE STUFF DOWN
* DON'T GET STUCK ON ONE APPROACH
*/