There are n people taking part in auction today. The rules of auction are classical. There were n bids made, though it's not guaranteed they were from different people. It might happen that some people made no bids at all.

Each bid is define by two integers (ai, bi), where ai is the index of the person, who made this bid and bi is its size. Bids are given in chronological order, meaning bi < bi + 1 for all i < n. Moreover, participant never makes two bids in a row (no one updates his own bid), i.e. ai ≠ ai + 1 for all i < n.

Now you are curious with the following question: who (and which bid) will win the auction if some participants were absent? Consider that if someone was absent, all his bids are just removed and no new bids are added.

Note, that if during this imaginary exclusion of some participants it happens that some of the remaining participants makes a bid twice (or more times) in a row, only first of these bids is counted. For better understanding take a look at the samples.

You have several questions in your mind, compute the answer for each of them.

Input

The first line of the input contains an integer n (1 ≤ n ≤ 200 000) — the number of participants and bids.

Each of the following n lines contains two integers ai and bi (1 ≤ ai ≤ n, 1 ≤ bi ≤ 109, bi < bi + 1) — the number of participant who made the i-th bid and the size of this bid.

Next line contains an integer q (1 ≤ q ≤ 200 000) — the number of question you have in mind.

Each of next q lines contains an integer k (1 ≤ k ≤ n), followed by k integers lj (1 ≤ lj ≤ n) — the number of people who are not coming in this question and their indices. It is guarenteed that lj values are different for a single question.

It's guaranteed that the sum of k over all question won't exceed 200 000.

Output

For each question print two integer — the index of the winner and the size of the winning bid. If there is no winner (there are no remaining bids at all), print two zeroes.

Examples

Input

6
1 10
2 100
3 1000
1 10000
2 100000
3 1000000
3
1 3
2 2 3
2 1 2


Output

2 100000
1 10
3 1000


Input

3
1 10
2 100
1 1000
2
2 1 2
2 2 3


Output

0 0
1 10

Note

Consider the first sample: 

  * In the first question participant number 3 is absent so the sequence of bids looks as follows: 
    1. 1 10
    2. 2 100
    3. 1 10 000
    4. 2 100 000
Participant number 2 wins with the bid 100 000.
  * In the second question participants 2 and 3 are absent, so the sequence of bids looks: 
    1. 1 10
    2. 1 10 000
The winner is, of course, participant number 1 but the winning bid is 10 instead of 10 000 as no one will ever increase his own bid (in this problem). 
  * In the third question participants 1 and 2 are absent and the sequence is: 
    1. 3 1 000
    2. 3 1 000 000
The winner is participant 3 with the bid 1 000. 
#include <bits/stdc++.h>
using namespace std;
mt19937_64 rang(
    chrono::high_resolution_clock::now().time_since_epoch().count());
long long mpow(long long base, long long exp);
long long power(long long a, long long b);
const long long mod = 1e9 + 7;
struct node {
  set<int> s;
};
struct segTree {
  long long arr[2001];
  long long res[8003];
  int operation_arr[4003];
  int NO_OPERATION = 0;
  void init(int x, int lo, int hi) {
    if (lo == hi) {
      res[x] = arr[lo];
      return;
    }
    int mid = (lo + hi) / 2;
    init(2 * x, lo, mid);
    init(2 * x + 1, mid + 1, hi);
    update_point(x);
  }
  int merge_operation(int a, int b) { return (a ^ b); }
  long long merge_results(int a, int b) { return a + b; }
  void modify(int x, int lo, int hi, int l, int r, int op) {
    prop(x, lo, hi);
    if (lo >= l && hi <= r) {
      operation_arr[x] = merge_operation(operation_arr[x], op);
      return;
    }
    int mid = (lo + hi) / 2;
    if (lo > r || hi < l) return;
    modify(2 * x, lo, mid, l, r, op);
    modify(2 * x + 1, mid + 1, hi, l, r, op);
    update(x, lo, hi);
  }
  int get_sum(int x, int lo, int hi, int l, int r) {
    if (lo >= l && hi <= r) return res[x];
    if (lo > r || hi < l) return 0;
    int mid = (lo + hi) / 2;
    return get_sum(2 * x, lo, mid, l, r) +
           get_sum(2 * x + 1, mid + 1, hi, l, r);
  }
  void point_modify(int x, int lo, int hi, int pos, long long val) {
    if (lo == hi) {
      res[x] = val;
      return;
    }
    int mid = (lo + hi) / 2;
    if (pos <= mid)
      point_modify(2 * x, lo, mid, pos, val);
    else
      point_modify(2 * x + 1, mid + 1, hi, pos, val);
    update_point(x);
  }
  long long max_query(int x, int lo, int hi, int l, int r) {
    if (lo >= l && hi <= r) return res[x];
    if (lo > r || hi < l) return LLONG_MIN;
    int mid = (lo + hi) / 2;
    return max(max_query(2 * x, lo, mid, l, r),
               max_query(2 * x + 1, mid + 1, hi, l, r));
  }
  void update_point(int x) { res[x] = max(res[2 * x], res[2 * x + 1]); }
  int query(int x, int lo, int hi, int l, int r) {
    prop(x, lo, hi);
    if (lo >= l && hi <= r) return operate(res[x], operation_arr[x], lo, hi);
    if (lo > r || hi < l) return 0;
    int mid = (lo + hi) / 2;
    return merge_results(query(2 * x, lo, mid, l, r),
                         query(2 * x + 1, mid + 1, hi, l, r));
  }
  int kth_one(int x, int lo, int hi, int k) {
    if (lo == hi) return lo;
    int v1 = res[2 * x];
    int mid = (lo + hi) / 2;
    if (k <= v1)
      return kth_one(2 * x, lo, mid, k);
    else
      return kth_one(2 * x + 1, mid + 1, hi, k - v1);
  }
  void prop(int x, int lo, int hi) {
    if (lo == hi) return;
    int mid = (hi + lo) / 2;
    long long len = mid - lo + 1;
    operation_arr[2 * x] =
        merge_operation(operation_arr[2 * x], operation_arr[x]);
    operation_arr[2 * x + 1] =
        merge_operation(operation_arr[2 * x + 1], operation_arr[x]);
    operation_arr[x] = NO_OPERATION;
    update(x, lo, hi);
  }
  int operate(int val, int operatr, int l, int r) {
    if (operatr == NO_OPERATION) return val;
    int sz = r - l + 1;
    return sz - val;
  }
  void update(int x, int lo, int hi) {
    if (lo == hi) return;
    int mid = (lo + hi) / 2;
    long long len1 = (mid - lo + 1);
    long long len2 = (hi - mid);
    res[x] = merge_results(
        operate(res[2 * x], operation_arr[2 * x], lo, mid),
        operate(res[2 * x + 1], operation_arr[2 * x + 1], mid + 1, hi));
  }
};
struct FenwickTree {
  int arr[100];
  int n;
  void update(int i, int delta) {
    while (i <= n) {
      arr[i] += delta;
      i = i + (i & (-i));
    }
  }
  int sum(int i) {
    if (i == 0) return 0;
    int res = 0;
    while (i > 0) {
      res = res + arr[i];
      i -= (i & (-i));
    }
    return res;
  }
};
struct dsu {
  int par[1001];
  int size_set[1001];
  int get_par(int u) {
    vector<int> temp;
    while (par[u] != u) {
      temp.push_back(u);
      u = par[u];
    }
    for (int i : temp) par[i] = u;
    return u;
  }
  void union_set(int a, int b) {
    a = get_par(a);
    b = get_par(b);
    if (a == b) return;
    if (size_set[a] < size_set[b]) {
      int temp = a;
      a = b;
      b = temp;
    }
    par[b] = a;
    size_set[a] += size_set[b];
  }
};
int check(string s1, string s2) {
  int n1 = s1.size();
  int n2 = s2.size();
  s1 = '$' + s1;
  s2 = '$' + s2;
  int dp[n1 + 1][n2 + 1];
  for (int j = 0; j <= n2; j++) dp[0][j] = 0;
  dp[0][0] = 1;
  for (int i = 1; i <= n1; i++) {
    dp[i][0] = 0;
  }
  int i1 = 1;
  while (i1 <= n1 && s1[i1] == '*') {
    dp[i1][0] = 1;
    i1++;
  }
  int sum[n2 + 1];
  int s = 0;
  for (int i = 0; i <= n2; i++) s = s + dp[0][i], sum[i] = s;
  for (int i = 1; i <= n1; i++) {
    for (int j = 1; j <= n2; j++) {
      char c1 = s1[i];
      char c2 = s2[j];
      if (c1 == '*') {
        if (sum[j] > 0)
          dp[i][j] = 1;
        else
          dp[i][j] = 0;
      } else if (c1 == '?') {
        dp[i][j] = dp[i - 1][j - 1];
      } else {
        if (c1 != c2)
          dp[i][j] = 0;
        else
          dp[i][j] = dp[i - 1][j - 1];
      }
    }
    s = 0;
    for (int j = 0; j <= n2; j++) {
      s += dp[i][j];
      sum[j] = s;
    }
  }
  return dp[n1][n2];
}
long long gcd(long long a, long long b) {
  if (a == 0) return b;
  if (b == 0) return a;
  return gcd(b, a % b);
}
long long pw1[21];
long long pw2[21];
long long m1 = 1e9 + 7;
long long m2 = 1e9 + 9;
long long base = 30;
pair<long long, long long> string_hash(string s) {
  long long res1 = 0, res2 = 0;
  for (int i = 0; i < s.size(); i++) {
    int v = s[i] - 'a';
    res1 = (res1 + v * pw1[i]) % m1;
    res2 = (res2 + v * pw2[i]) % m2;
  }
  return make_pair(res1, res2);
}
bool isOverflow(long long a, long long b) {
  if (a == 0 || b == 0) return false;
  if (a <= LLONG_MAX / b)
    return false;
  else
    return true;
}
bool isOverflow_add(long long a, long long b) {
  long long res = a + b;
  if (res - a == b && res - b == a) return 0;
  return 1;
}
long long fact(long long i) {
  long long res = 1;
  for (int j = 1; j <= i; j++) res *= j;
  return res;
}
void solve() {
  int n;
  cin >> n;
  vector<int> bets[n + 1];
  pair<int, int> bet_arr[n + 1];
  int idx[n + 1];
  int variety[n + 1];
  int last_bet[n + 1];
  memset(last_bet, -1, sizeof(last_bet));
  for (int i = 1; i <= n; i++) {
    int u, v;
    cin >> u >> v;
    bet_arr[i] = make_pair(u, v);
    idx[i] = u;
    last_bet[u] = i;
    bets[u].push_back(i);
  }
  set<int> s;
  for (int i = n; i >= 1; i--) {
    s.insert(idx[i]);
    variety[i] = (int)s.size();
  }
  vector<pair<int, int> > sorted_last_bets;
  for (int i = 1; i <= n; i++) {
    if (last_bet[i] != -1) sorted_last_bets.push_back({last_bet[i], i});
  }
  sort(sorted_last_bets.begin(), sorted_last_bets.end());
  int q;
  cin >> q;
  while (q--) {
    int n1;
    cin >> n1;
    set<int> ids;
    for (int t = 1; t <= n1; t++) {
      int u;
      cin >> u;
      ids.insert(u);
    }
    int pos = sorted_last_bets.size() - 1;
    while (pos >= 0) {
      int person = sorted_last_bets[pos].second;
      if (ids.find(person) != ids.end())
        pos--;
      else
        break;
    }
    if (pos == -1) {
      cout << "0 0"
           << "\n";
      continue;
    } else {
      int person = sorted_last_bets[pos].second;
      int p1 = sorted_last_bets.size() - 1;
      while (p1 >= 0) {
        int per1 = sorted_last_bets[p1].second;
        if (ids.find(per1) != ids.end() || per1 == person)
          p1--;
        else
          break;
      }
      if (p1 == -1) {
        cout << person << " " << bet_arr[bets[person][0]].second << "\n";
      } else {
        int person_this_bet = sorted_last_bets[p1].second;
        int id_this_bet =
            bets[person_this_bet][bets[person_this_bet].size() - 1];
        int l = 0, r = bets[person].size() - 1;
        int res = -1;
        while (l <= r) {
          int mid = l + (r - l) / 2;
          if (bets[person][mid] < id_this_bet)
            l = mid + 1;
          else
            r = mid - 1, res = bets[person][mid];
        }
        cout << person << " " << bet_arr[res].second << "\n";
      }
    }
  }
}
int main() {
  ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
  srand(chrono::high_resolution_clock::now().time_since_epoch().count());
  int t = 1;
  while (t--) {
    solve();
  }
  return 0;
}
long long mpow(long long base, long long exp) {
  base %= mod;
  long long result = 1;
  while (exp > 0) {
    if (exp & 1) result = ((long long)result * base) % mod;
    base = ((long long)base * base) % mod;
    exp >>= 1;
  }
  return result;
}
long long power(long long a, long long b) {
  long long res = 1;
  while (b > 0) {
    if (b % 2 == 0) {
      b /= 2;
      if (isOverflow(a, a)) return LLONG_MAX;
      a = a * a;
    } else {
      if (isOverflow(res, a)) return LLONG_MAX;
      res = res * a;
      b--;
    }
  }
  return res;
}
