#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
const double eps = 1e-6;
inline bool sgn(double x) { return x < -eps ? -1 : x > eps; }
int n;
struct Node {
  int ls, rs;
  int cnt;
} T[2000001];
int tail = 0;
struct point {
  int x, y, id;
} P[100001], P2[100001];
void build(int &node, int l, int r) {
  node = ++tail;
  if (l == r) return;
  int mid = (l + r) >> 1;
  build(T[node].ls, l, mid);
  build(T[node].rs, mid + 1, r);
}
void insert(int &node, int pre, int l, int r, int k) {
  node = ++tail;
  T[node] = T[pre];
  T[node].cnt++;
  if (l == r) return;
  int mid = (l + r) >> 1;
  if (k <= mid)
    insert(T[node].ls, T[pre].ls, l, mid, k);
  else
    insert(T[node].rs, T[pre].rs, mid + 1, r, k);
}
int query(int node, int l, int r, int k) {
  Node &tmp = T[node];
  if (l == r) return l;
  int t = T[tmp.ls].cnt, mid = (l + r) >> 1;
  if (t >= k)
    return query(tmp.ls, l, mid, k);
  else
    return query(tmp.rs, mid + 1, r, k - t);
}
inline bool cmpx(point a, point b) { return a.x < b.x; }
inline bool cmpy(point a, point b) { return a.y < b.y; }
int a[10], root[100001];
int main() {
  scanf("%d", &n);
  for (int i = 1; i <= n; i++) {
    scanf("%d%d", &P[i].x, &P[i].y);
  }
  sort(P + 1, P + n + 1, cmpy);
  for (int i = 1; i <= n; i++)
    P[i].id = (i > 1 && P[i].y == P[i - 1].y) ? P[i - 1].id : i, P2[i] = P[i];
  sort(P + 1, P + n + 1, cmpx);
  build(root[0], 1, n);
  for (int i = 1; i <= n; i++) insert(root[i], root[i - 1], 1, n, P[i].id);
  for (int i = 1; i <= 9; i++) scanf("%d", &a[i]);
  sort(a + 1, a + 9 + 1);
  do {
    int A1 = a[1] + a[2] + a[3], A2 = a[4] + a[5] + a[6],
        B1 = a[1] + a[4] + a[7], B2 = a[2] + a[5] + a[8];
    int y1 = P2[B1].id, y2 = P2[B2 + B1].id, y3 = P2[B1 + 1].id,
        y4 = P2[B2 + B1 + 1].id;
    if (P[A1 + 1].x == P[A1].x || P[A2 + A1].x == P[A2 + A1 + 1].x ||
        P2[B1].y == P2[B1 + 1].y || P2[B1 + B2].y == P2[B1 + B2 + 1].y)
      continue;
    if (query(root[A1], 1, n, a[1]) > y1 ||
        query(root[A1], 1, n, a[1] + 1) < y3 ||
        query(root[A1 + A2], 1, n, a[1] + a[4]) > y1 ||
        query(root[A1 + A2], 1, n, a[1] + a[4] + 1) < y3 ||
        query(root[n], 1, n, B1) > y1 || query(root[n], 1, n, B1 + 1) < y3 ||
        query(root[A1], 1, n, a[1] + a[2]) > y2 ||
        query(root[A1], 1, n, a[1] + a[2] + 1) < y4 ||
        query(root[A1 + A2], 1, n, a[1] + a[2] + a[4] + a[5]) > y2 ||
        query(root[A1 + A2], 1, n, a[1] + a[2] + a[4] + a[5] + 1) < y4 ||
        query(root[n], 1, n, B1 + B2) > y2 ||
        query(root[n], 1, n, B1 + B2 + 1) < y4)
      continue;
    printf("%.8lf %.8lf\n%.8lf %.8lf", (P[A1].x + P[A1 + 1].x) / 2.0,
           (P[A1 + A2].x + P[A1 + A2 + 1].x) / 2.0,
           (P2[B1].y + P2[B1 + 1].y) / 2.0,
           (P2[B1 + B2].y + P2[B1 + B2 + 1].y) / 2.0);
    return 0;
  } while (next_permutation(a + 1, a + 9 + 1));
  printf("-1");
}
