#include<cstdio>

 #include<algorithm>

 #include<string.h>

 #include<math.h>

 using namespace std;

 const int maxn=1e5+;

 int val[maxn];

 int f[maxn];

 int ch[maxn][];

 int dis[maxn];

 int getf(int x)  //标准并查集

 {

     if(f[x]==x) return x;

     else{

         f[x]=getf(f[x]);

         return f[x];

     }

 }

 int Merge(int x,int y)

 {

     if(!x||!y) return x+y;  //到底了；

     //保证最小堆性质     后面这个不懂

     if(val[x]<val[y]) swap(x,y);

     //这个大概就是创这个算法的人的习惯了，将其定在右子树。

     //然后再在下面进行操作来满足偏左树的性质；

     ch[x][]=Merge(ch[x][],y);

     f[ch[x][]]=x;   //并查集操作；

     //满足偏左；

     if(dis[ch[x][]]<dis[ch[x][]]) swap(ch[x][],ch[x][]);

     //这个是偏左树的性质，想想就知道是对的。

     dis[x]=dis[ch[x][]]+;

     return x;

 }

 int main()

 {

     int n,m;

     while(scanf("%d",&n)!=EOF){

         memset(dis,,sizeof(dis));

         memset(ch,,sizeof(ch));

         for(int i=;i<=n;i++){

             scanf("%d",&val[i]);

             f[i]=i;

         }

         scanf("%d",&m);

         while(m--){

             int t1,t2;

             scanf("%d%d",&t1,&t2);

             int u=getf(t1);

             int v=getf(t2);

             if(u==v){

                 printf("-1\n");

                 continue;

             }

             val[u]/=;

             int root=Merge(ch[u][],ch[u][]);

             ch[u][]=ch[u][]=dis[u]=;

             int newx=Merge(root,u);

             val[v]/=;

             root=Merge(ch[v][],ch[v][]);

             ch[v][]=ch[v][]=dis[v]=;

             int newy=Merge(root,v);

             root=Merge(newx,newy);

             f[newx]=f[newy]=root;   //这里两个点都要，其实只有一个点需要，

             //因为只有一个点的父节点没有从已经被减半的根节点那更新回来。

             //需要更新的点是根节点；

             printf("%d\n",val[root]);

         }

     }

     return ;

 }