Berland amusement park shooting gallery is rightly acknowledged as one of the best in the world. Every day the country's best shooters master their skills there and the many visitors compete in clay pigeon shooting to win decent prizes. And the head of the park has recently decided to make an online version of the shooting gallery. During the elaboration process it turned out that the program that imitates the process of shooting effectively, is needed. To formulate the requirements to the program, the shooting gallery was formally described. A 3D Cartesian system of coordinates was introduced, where the X axis ran across the gallery floor along the line, along which the shooters are located, the Y axis ran vertically along the gallery wall and the positive direction of the Z axis matched the shooting direction. Let's call the XOY plane a shooting plane and let's assume that all the bullets are out of the muzzles at the points of this area and fly parallel to the Z axis. Every clay pigeon can be represented as a rectangle whose sides are parallel to X and Y axes, and it has a positive z-coordinate. The distance between a clay pigeon and the shooting plane is always different for every target. The bullet hits the target if it goes through the inner area or border of the rectangle corresponding to it. When the bullet hits the target, the target falls down vertically into the crawl-space of the shooting gallery and cannot be shot at any more. The targets are tough enough, that's why a bullet can not pierce a target all the way through and if a bullet hits a target it can't fly on. In input the simulator program is given the arrangement of all the targets and also of all the shots in the order of their appearance. The program should determine which target was hit by which shot. If you haven't guessed it yet, you are the one who is to write such a program.

Input

The first line contains an integer n (1 ≤ n ≤ 105) — the number of targets. Each of the subsequent n lines contains the description of a target. The target is described by five integers xl, xr, yl, yr, z, that determine it's location in space (0 ≤ xl < xr ≤ 107, 0 ≤ yl < yr ≤ 107, 0 < z ≤ 107). The next line contains an integer m (1 ≤ m ≤ 105), determining the number of shots. Then in m lines shots are described. Every shot is determined by the coordinates of a bullet on the shooting plane (x, y) (0 ≤ x, y ≤ 107, the coordinates of bullets are integers). The shots are given in the order of their firing. The intervals between shots are large enough, and a target falls very quickly, that's why assume that a falling target can not be an obstruction for all the shots following the one that hit it.

Output

For every shot in the single line print the number of the target which the shot has hit, or 0, if the bullet did not hit any target. The targets are numbered starting from 1 in the order in which they were given in the input data.

Examples

Input

2
1 4 1 4 1
2 5 2 6 2
4
0 0
3 3
4 5
3 5


Output

0
1
2
0
#include <bits/stdc++.h>
using namespace std;
struct node {
  int l, r, u, d, z, id;
} a[3001000];
int tr[3001000][2], cnt, pri[3001000], minn[3001000], x[3001000], y[3001000],
    root[3001000], ex[3001000], excnt, size, i, n, m, ans[3001000],
    anss[3001000];
pair<int, int> v[3001000];
bool cmp(node x, node y) { return x.z < y.z; }
inline int read() {
  int x = 0;
  char ch = getchar();
  while (ch < '0' || ch > '9') ch = getchar();
  while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
  return x;
}
void init() {
  sort(ex + 1, ex + 1 + excnt);
  size = unique(ex + 1, ex + 1 + excnt) - ex - 1;
  for (i = 1; i <= n; i++) x[i] = lower_bound(ex + 1, ex + 1 + size, x[i]) - ex;
  for (i = 1; i <= m; i++) {
    a[i].l = lower_bound(ex + 1, ex + 1 + size, a[i].l) - ex;
    a[i].r = lower_bound(ex + 1, ex + 1 + size, a[i].r) - ex;
  }
}
int point(int a, int b) {
  int o = ++cnt;
  pri[o] = rand();
  v[o] = make_pair(a, b);
  minn[o] = b;
  return o;
}
void pushup(int rt) {
  minn[rt] = min(min(tr[rt][0] ? minn[tr[rt][0]] : 100000000,
                     tr[rt][1] ? minn[tr[rt][1]] : 100000000),
                 v[rt].second);
}
void split(int rt, pair<int, int> k, int &x, int &y) {
  if (rt == 0) {
    x = 0, y = 0;
    return;
  }
  if (v[rt] <= k)
    x = rt, split(tr[rt][1], k, tr[x][1], y);
  else
    y = rt, split(tr[rt][0], k, x, tr[y][0]);
  pushup(rt);
}
int merge(int x, int y) {
  if (x == 0 || y == 0) return x + y;
  if (pri[x] < pri[y]) {
    tr[x][1] = merge(tr[x][1], y);
    pushup(x);
    return x;
  } else {
    tr[y][0] = merge(x, tr[y][0]);
    pushup(y);
    return y;
  }
}
void add(int rt, int id) {
  int a, c, b = point(y[id], id);
  split(root[rt], make_pair(y[id], id - 1), a, c);
  root[rt] = merge(merge(a, b), c);
}
void del(int rt, int id) {
  int a, b, c;
  split(root[rt], make_pair(y[id], id - 1), a, c);
  split(c, make_pair(y[id], id), b, c);
  root[rt] = merge(a, c);
}
int calc(int rt, int l, int r) {
  int a, b, c;
  split(root[rt], make_pair(l - 1, 100000000), a, c);
  split(c, make_pair(r, 100000000), b, c);
  int ret = (b == 0) ? 100000000 : minn[b];
  root[rt] = merge(merge(a, b), c);
  return ret;
}
void modify(int rt, int l, int r, int x, int id, int f) {
  if (f == 1)
    add(rt, id);
  else
    del(rt, id);
  if (l == r) return;
  if (x <= ((l + r) / 2))
    modify((rt << 1), l, ((l + r) / 2), x, id, f);
  else
    modify((rt << 1 | 1), ((l + r) / 2) + 1, r, x, id, f);
}
void query(int rt, int l, int r, int x, int y, int id) {
  if (x <= l && r <= y) {
    int tmp = calc(rt, a[id].d, a[id].u);
    ans[a[id].id] = min(ans[a[id].id], tmp);
    return;
  }
  if (x <= ((l + r) / 2)) query((rt << 1), l, ((l + r) / 2), x, y, id);
  if (y >= ((l + r) / 2) + 1)
    query((rt << 1 | 1), ((l + r) / 2) + 1, r, x, y, id);
}
int main() {
  srand(20010425);
  scanf("%d", &m);
  for (i = 1; i <= m; i++) {
    a[i].l = read();
    a[i].r = read(), a[i].d = read(), a[i].u = read(), a[i].z = read();
    a[i].id = i;
    ex[++excnt] = a[i].l, ex[++excnt] = a[i].r;
    ans[i] = 100000000;
  }
  sort(a + 1, a + 1 + m, cmp);
  scanf("%d", &n);
  for (i = 1; i <= n; i++) x[i] = read(), y[i] = read(), ex[++excnt] = x[i];
  init();
  for (i = 1; i <= n; i++) modify(1, 1, size, x[i], i, 1);
  for (i = 1; i <= m; i++) {
    query(1, 1, size, a[i].l, a[i].r, i);
    if (ans[a[i].id] == 100000000) continue;
    modify(1, 1, size, x[ans[a[i].id]], ans[a[i].id], -1);
  }
  for (i = 1; i <= m; i++)
    if (ans[i] != 100000000) anss[ans[i]] = i;
  for (i = 1; i <= n; i++) printf("%d\n", anss[i]);
}
