#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
const int M = 15000000;
pair<int, int> p[N];
int tab[N];
int lc[M], rc[M], key[M], cnt = 0;
int root[N], rtab[N], tt[N];
int pos;
bool ft;
inline void add(int x, int y, int l, int r, int pos) {
  key[x] = key[y] + 1;
  if (l == r) return;
  int mid = (l + r) >> 1;
  if (pos <= mid) {
    if (!lc[x]) lc[x] = ++cnt;
    rc[x] = rc[y];
    add(lc[x], lc[y], l, mid, pos);
  } else {
    if (!rc[x]) rc[x] = ++cnt;
    lc[x] = lc[y];
    add(rc[x], rc[y], mid + 1, r, pos);
  }
}
inline void dfs(int x, int y, int l, int r, int len) {
  if (l == r) {
    pos = l;
    if (len == key[x] - key[y]) ft = 1;
    return;
  }
  int mid = (l + r) >> 1;
  if (len <= key[lc[x]] - key[lc[y]])
    dfs(lc[x], lc[y], l, mid, len);
  else
    dfs(rc[x], rc[y], mid + 1, r, len - (key[lc[x]] - key[lc[y]]));
}
int main() {
  int n, x, y;
  scanf("%d", &n);
  for (int i = 1; i <= n; i++) {
    scanf("%d%d", &x, &y);
    p[i] = make_pair(x, y);
    tab[i] = y;
  }
  sort(p + 1, p + n + 1);
  sort(tab + 1, tab + n + 1);
  int tot = unique(tab + 1, tab + n + 1) - tab - 1, t = 0, cur, lst;
  for (int i = 1, j = 1; i <= n; i = j + 1) {
    j = i;
    while (j < n && p[j + 1].first == p[i].first) j++;
    lst = root[t++];
    tt[t] = p[i].first;
    for (int k = i; k <= j; k++) {
      p[k].second = lower_bound(tab + 1, tab + tot + 1, p[k].second) - tab;
      cur = ++cnt;
      add(cur, lst, 1, tot, p[k].second);
      lst = cur;
    }
    root[t] = cur;
    rtab[t] = key[cur];
  }
  int a[11], tmp[11];
  for (int i = 1; i <= 9; i++) scanf("%d", &a[i]);
  sort(a + 1, a + 10);
  int p, q, rd, sd, ru, su;
  bool flag;
  while (true) {
    flag = 1;
    tmp[0] = 0;
    for (int i = 1; i <= 9; i++) tmp[i] = tmp[i - 1] + a[i];
    p = lower_bound(rtab + 1, rtab + t + 1, tmp[3]) - rtab;
    flag = (flag && rtab[p] == tmp[3]);
    q = lower_bound(rtab + 1, rtab + t + 1, tmp[6]) - rtab;
    flag = (flag && rtab[q] == tmp[6]);
    if (!flag)
      if (!next_permutation(a + 1, a + 10)) break;
    ft = 0;
    dfs(root[p], 0, 1, tot, a[1]);
    rd = pos;
    flag = (flag && ft);
    dfs(root[p], 0, 1, tot, a[1] + 1);
    ru = pos;
    ft = 0;
    dfs(root[p], 0, 1, tot, a[1] + a[2]);
    sd = pos;
    flag = (flag && ft);
    dfs(root[p], 0, 1, tot, a[1] + a[2] + 1);
    su = pos;
    {
      if (!flag || sd >= su || rd >= ru) {
        if (!next_permutation(a + 1, a + 10)) break;
        ;
        continue;
      }
    }
    ft = 0;
    dfs(root[q], root[p], 1, tot, a[4]);
    rd = max(rd, pos);
    flag = (flag && ft);
    {
      if (!flag || sd >= su || rd >= ru) {
        if (!next_permutation(a + 1, a + 10)) break;
        ;
        continue;
      }
    }
    dfs(root[q], root[p], 1, tot, a[4] + 1);
    ru = min(ru, pos);
    {
      if (!flag || sd >= su || rd >= ru) {
        if (!next_permutation(a + 1, a + 10)) break;
        ;
        continue;
      }
    }
    ft = 0;
    dfs(root[q], root[p], 1, tot, a[4] + a[5]);
    sd = max(sd, pos);
    {
      if (!flag || sd >= su || rd >= ru) {
        if (!next_permutation(a + 1, a + 10)) break;
        ;
        continue;
      }
    }
    flag = (flag && ft);
    {
      if (!flag || sd >= su || rd >= ru) {
        if (!next_permutation(a + 1, a + 10)) break;
        ;
        continue;
      }
    }
    dfs(root[q], root[p], 1, tot, a[4] + a[5] + 1);
    su = min(su, pos);
    {
      if (!flag || sd >= su || rd >= ru) {
        if (!next_permutation(a + 1, a + 10)) break;
        ;
        continue;
      }
    }
    ft = 0;
    dfs(root[t], root[q], 1, tot, a[7]);
    rd = max(rd, pos);
    flag = (flag && ft);
    {
      if (!flag || sd >= su || rd >= ru) {
        if (!next_permutation(a + 1, a + 10)) break;
        ;
        continue;
      }
    }
    dfs(root[t], root[q], 1, tot, a[7] + 1);
    ru = min(ru, pos);
    {
      if (!flag || sd >= su || rd >= ru) {
        if (!next_permutation(a + 1, a + 10)) break;
        ;
        continue;
      }
    }
    ft = 0;
    dfs(root[t], root[q], 1, tot, a[7] + a[8]);
    sd = max(sd, pos);
    flag = (flag && ft);
    {
      if (!flag || sd >= su || rd >= ru) {
        if (!next_permutation(a + 1, a + 10)) break;
        ;
        continue;
      }
    }
    dfs(root[t], root[q], 1, tot, a[7] + a[8] + 1);
    su = min(su, pos);
    {
      if (!flag || sd >= su || rd >= ru) {
        if (!next_permutation(a + 1, a + 10)) break;
        ;
        continue;
      }
    }
    if (flag && sd < su && rd < ru) {
      printf("%.10lf %.10lf\n%.10lf %.10lf\n", (double)tt[p] + 0.5,
             (double)tt[q] + 0.5, (double)tab[rd] + 0.5, (double)tab[sd] + 0.5);
      return 0;
    }
  }
  puts("-1");
  return 0;
}
