ll n;
vector<ll> arr;
vector<vector<ll>> v(1005);
ll visited[1005];
map<pair<ll, ll>, ll> swapID;
vector<vector<ll>> comp;
vector<vector<ll>> perm;
vector<ll> ans;
void dfs(ll node, vector<ll> &c, vector<ll> &p)
{
    visited[node] = 1;
    c.push_back(node);
    p.push_back(arr[node]);

    for (auto x : v[node])
        if (!visited[x])
            dfs(x, c, p);
}

bool check(vector<ll> c, vector<ll> p)
{
    set<ll> st1(c.begin(), c.end()), st2(p.begin(), p.end());
    for (auto x : st1)
        if (st2.find(x) == st2.end())
            return false;

    return true;
}

vector<ll> Path(ll strt, ll dest)
{
    vector<ll> vis(1005, 0);
    vector<ll> par(1005, -1);

    queue<ll> q;
    q.push(strt);
    vis[strt] = 1;
    while (!q.empty())
    {
        ll node = q.front();
        q.pop();

        if (node == dest)
            break;

        for (auto x : v[node])
            if (!vis[x])
            {
                vis[x] = 1;
                par[x] = node;
                q.push(x);
            }
    }

    vector<ll> res;
    while (dest != -1)
    {
        res.push_back(dest);
        dest = par[dest];
    }
    reverse(res.begin(), res.end());
    return res;
}

void SORT(vector<ll> &c, vector<ll> &p)
{

    // stores the cuurent position of pi in Arr
    vector<ll> Arr(1005);
    for (int i = 0; i < c.size(); i++)
        Arr[c[i]] = p[i];

    set<ll> st(p.begin(), p.end());
    ll pos = 0;
    for (auto x : st)
    {
        ll ind = -1; // find the current position of x (pi)
        for (int i = 1; i <= 1000; i++)
        {
            if (Arr[i] == x)
            {
                ind = i;
                break;
            }
        }

        // using bfs find path between x(pi) and ind(i)
        vector<ll> path = Path(x, ind);

        ind = path.size() - 1;

        // perform swap operations
        while (ind - 1 >= 0)
        {
            ll from = path[ind], to = path[ind - 1];
            ans.push_back(swapID[{from, to}]);
            swap(Arr[from], Arr[to]);
            ind--;
        }
    }
}

void solve()
{
    cin >> n;
    arr = {0}; // the given permutation
    for (int i = 0; i < n; i++)
    {
        ll x;
        cin >> x;
        arr.push_back(x);
    }

    // adj matrix for the swaps possible
    ll m;
    cin >> m;
    for (int i = 0; i < m; i++)
    {
        ll a, b;
        cin >> a >> b;
        v[a].push_back(b);
        v[b].push_back(a);
        swapID[{a, b}] = i + 1;
        swapID[{b, a}] = i + 1;
    }

    // for each component, i am finding the answer
    for (int i = 1; i <= n; i++)
    {
        if (!visited[i])
        {
            vector<ll> c, p;
            dfs(i, c, p);

            // if any pi (vector p) and i(vector c)  are not in same component, return false, else sprt
            if (check(c, p) == false)
            {
                cout << -1 << "\n";
                return;
            }

            SORT(c, p);

            if (ans.size() > 500000)
            {
                cout << -1 << "\n";
                return;
            }
        }
    }

    cout << ans.size() << "\n";
    for (auto x : ans)
        cout << x << " ";
}

int main()
{
    solve();
}

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

int main()
{
    cout<<1000<<endl;
    for(int i = 1; i<1000; i++) cout<<(i+1)<<" ";
    cout<<1<<endl;
    cout<<999<<endl;
    for(int i = 1; i<1000; i++) cout<<i<<" "<<i+1<<endl;
}