#include <bits/stdc++.h>
using namespace std;
const int inf = 2000000000;
static inline int Rint() {
  struct X {
    int dig[256];
    X() {
      for (int i = '0'; i <= '9'; ++i) dig[i] = 1;
      dig['-'] = 1;
    }
  };
  static X fuck;
  int s = 1, v = 0, c;
  for (; !fuck.dig[c = getchar()];)
    ;
  if (c == '-')
    s = 0;
  else if (fuck.dig[c])
    v = c ^ 48;
  for (; fuck.dig[c = getchar()]; v = v * 10 + (c ^ 48))
    ;
  return s ? v : -v;
}
template <typename T>
static inline void cmax(T& a, const T& b) {
  if (b > a) a = b;
}
template <typename T>
static inline void cmin(T& a, const T& b) {
  if (b < a) a = b;
}
const int maxn = 100005;
struct Pt {
  int x, y;
  int left, right;
  int top, bottom;
  int me;
};
Pt data_b[2005];
Pt data_r[2005];
int havex[10000];
int havey[10000];
int cmp_y(const Pt& a, const Pt& b) {
  if (a.y != b.y) return a.y < b.y;
  return a.x < b.x;
}
int cmp_x(const Pt& a, const Pt& b) {
  if (a.x != b.x) return a.x < b.x;
  return a.y < b.y;
}
static inline int findx(int topx, int val) {
  return lower_bound(havex, havex + topx, val) - havex;
}
static inline int findy(int topy, int val) {
  return lower_bound(havey, havey + topy, val) - havey;
}
Pt H[2005], V[2005];
int tree[20][8192];
int val[8192];
void build_tree(int level, int l, int r) {
  if (l == r) {
    tree[level][l] = val[l];
    return;
  }
  const int mid = l + r >> 1;
  build_tree(level + 1, l, mid);
  build_tree(level + 1, mid + 1, r);
  int k = l;
  int i = l, j = mid + 1;
  int* src = tree[level + 1];
  int* dst = tree[level];
  while (i <= mid && j <= r)
    if (src[i] < src[j])
      dst[k++] = src[i++];
    else
      dst[k++] = src[j++];
  while (i <= mid) dst[k++] = src[i++];
  while (j <= r) dst[k++] = src[j++];
}
int query(int level, int l, int r, int a, int b, int val) {
  if (l == a & r == b) {
    int* data = tree[level];
    while (l <= r) {
      const int mid = l + r >> 1;
      if (data[mid] >= val)
        r = mid - 1;
      else
        l = mid + 1;
    }
    return b - l + 1;
  }
  const int mid = l + r >> 1;
  if (b <= mid) return query(level + 1, l, mid, a, b, val);
  if (a > mid) return query(level + 1, mid + 1, r, a, b, val);
  int u = query(level + 1, l, mid, a, mid, val);
  int v = query(level + 1, mid + 1, r, mid + 1, b, val);
  return u + v;
}
int check(int nn, int mm, int mid) {
  int top0 = 0, top1 = 0;
  {
    for (int i = 0; i < nn;) {
      int s = inf, e = inf;
      int j = i;
      for (; j < nn && data_b[j].y == data_b[i].y; ++j) {
        const int l = data_b[j].x - mid;
        const int r = data_b[j].x + mid;
        if (s == inf) {
          s = l, e = r;
        } else if (l > e) {
          H[top0].left = s, H[top0].right = e, H[top0++].y = data_b[i].y;
          s = l, e = r;
        } else {
          e = max(e, r);
        }
      }
      if (s != inf) {
        H[top0].left = s, H[top0].right = e, H[top0++].y = data_b[i].y;
      }
      i = j;
    }
  }
  {
    for (int i = 0; i < mm;) {
      int s = inf, e = inf;
      int j = i;
      for (; j < mm && data_r[j].x == data_r[i].x; ++j) {
        const int l = data_r[j].y - mid;
        const int r = data_r[j].y + mid;
        if (s == inf) {
          s = l, e = r;
        } else if (l > e) {
          V[top1].bottom = s, V[top1].top = e, V[top1++].x = data_r[i].y;
          s = l, e = r;
        } else {
          e = max(e, r);
        }
      }
      if (s != inf) {
        V[top1].bottom = s, V[top1].top = e, V[top1++].x = data_r[i].x;
      }
      i = j;
    }
  }
  const int n = top0, m = top1;
  int topx = 0;
  for (int i = 0; i < n; ++i)
    havex[topx++] = H[i].left, havex[topx++] = H[i].right;
  for (int i = 0; i < m; ++i) havex[topx++] = V[i].x;
  int topy = 0;
  for (int i = 0; i < m; ++i)
    havey[topy++] = V[i].bottom, havey[topy++] = V[i].top;
  for (int i = 0; i < n; ++i) havey[topy++] = H[i].y;
  sort(havex, havex + topx);
  sort(havey, havey + topy);
  topx = unique(havex, havex + topx) - havex;
  topy = unique(havey, havey + topy) - havey;
  for (int i = 0; i < n; ++i) {
    H[i].left = findx(topx, H[i].left);
    H[i].right = findx(topx, H[i].right);
  }
  for (int i = 0; i < m; ++i) {
    V[i].me = findx(topx, V[i].x);
  }
  for (int i = 0; i < m; ++i) {
    V[i].bottom = findy(topy, V[i].bottom);
    V[i].top = findy(topy, V[i].top);
  }
  for (int i = 0; i < n; ++i) {
    H[i].me = findy(topy, H[i].y);
  }
  for (int i = 0; i < m; ++i) {
    fill(val, val + topy, -1);
    int mv = -1;
    int cnt = 0;
    for (int j = 0; j < n; ++j) {
      if (H[j].me < V[i].bottom) continue;
      if (H[j].me > V[i].top) break;
      if (H[j].right < V[i].me || H[j].left > V[i].me) continue;
      cmax(val[H[j].me], H[j].right);
      cmax(mv, H[j].right);
      ++cnt;
    }
    if (cnt <= 1) continue;
    build_tree(1, 0, topy - 1);
    for (int j = i + 1; j < m; ++j)
      if (V[j].x > V[i].x) {
        if (V[j].me > mv) break;
        int a = V[j].bottom;
        int b = V[j].top;
        int cnt = query(1, 0, topy - 1, a, b, V[j].me);
        if (cnt >= 2) return 1;
      }
  }
  return 0;
}
int main() {
  const int n = Rint(), m = Rint();
  for (int i = 0; i < n; ++i) {
    const int x = Rint(), y = Rint();
    data_b[i].x = x - y;
    data_b[i].y = x + y;
  }
  for (int i = 0; i < m; ++i) {
    const int x = Rint(), y = Rint();
    data_r[i].x = x - y;
    data_r[i].y = x + y;
  }
  if (n == 1 || m == 1) {
    puts("Poor Sereja!");
    return 0;
  }
  sort(data_b, data_b + n, cmp_y);
  sort(data_r, data_r + m, cmp_x);
  int l = 1, r = 2000000;
  while (l <= r) {
    const int mid = l + r >> 1;
    if (check(n, m, mid))
      r = mid - 1;
    else
      l = mid + 1;
  }
  if (l > 2000000)
    puts("Poor Sereja!");
  else
    printf("%d\n", (l + 1) / 2);
  return 0;
}
