#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool upmin(T &x, T y) {
  return y <= x ? x = y, 1 : 0;
}
template <typename T>
inline bool upmax(T &x, T y) {
  return x <= y ? x = y, 1 : 0;
}
const long double eps = 1e-9;
const long double pi = acos(-1);
const int oo = 1 << 30;
const long long loo = (1ll << 62) - 1;
const int mods = 998244353;
const int MAXN = 200005;
const int INF = 0x3f3f3f3f;
namespace FastIO {
constexpr int SIZE = (1 << 21) + 1;
int num = 0, f;
char ibuf[SIZE], obuf[SIZE], que[65], *iS, *iT, *oS = obuf,
                                                *oT = obuf + SIZE - 1, c;
inline void flush() {
  fwrite(obuf, 1, oS - obuf, stdout);
  oS = obuf;
}
inline void putc(char c) {
  *oS++ = c;
  if (oS == oT) flush();
}
inline void getc(char &c) {
  for (c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
                       (iS == iT ? EOF : *iS++))
                     : *iS++);
       !isalpha(c) && c != EOF;
       c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
                       (iS == iT ? EOF : *iS++))
                     : *iS++))
    ;
}
inline void reads(char *st) {
  char c;
  int n = 0;
  getc(st[++n]);
  for (c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
                       (iS == iT ? EOF : *iS++))
                     : *iS++);
       isalpha(c);
       c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
                       (iS == iT ? EOF : *iS++))
                     : *iS++))
    st[++n] = c;
  st[++n] = '\0';
}
template <class I>
inline void read(I &x) {
  for (f = 1, c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
                              (iS == iT ? EOF : *iS++))
                            : *iS++);
       c < '0' || c > '9';
       c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
                       (iS == iT ? EOF : *iS++))
                     : *iS++))
    if (c == '-') f = -1;
  for (x = 0; c >= '0' && c <= '9';
       c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
                       (iS == iT ? EOF : *iS++))
                     : *iS++))
    x = (x << 3) + (x << 1) + (c & 15);
  x *= f;
}
template <class I>
inline void print(I x) {
  if (x < 0) putc('-'), x = -x;
  if (!x) putc('0');
  while (x) que[++num] = x % 10 + 48, x /= 10;
  while (num) putc(que[num--]);
}
inline void putstr(string st) {
  for (int i = 0; i < (int)st.size(); ++i) putc(st[i]);
}
struct Flusher_ {
  ~Flusher_() { flush(); }
} io_Flusher_;
}  // namespace FastIO
using FastIO ::print;
using FastIO ::putc;
using FastIO ::putstr;
using FastIO ::read;
using FastIO ::reads;
int s[MAXN], Xmx, Ymx, Zmx, n, m, K, x1 = INF, Y1 = INF, z1 = INF, x2 = 0,
                                     y2 = 0, z2 = 0, Qnum = 0, Ans[MAXN];
struct Qnode {
  int opt, x, y, z;
} Q[MAXN << 3];
void add(int x, int y) {
  for (; x <= Zmx; x += x & (-x)) s[x] += y;
}
int query(int x) {
  int ans = 0;
  for (; x; x -= x & (-x)) ans += s[x];
  return ans;
}
void solve(int l, int r) {
  if (l == r) return;
  int mid = (l + r) >> 1;
  solve(l, mid);
  solve(mid + 1, r);
  int nw = l;
  for (int i = mid + 1; i <= r; ++i) {
    while (nw <= mid && Q[nw].y <= Q[i].y) {
      if (Q[nw].opt == 0) add(Q[nw].z, 1);
      ++nw;
    }
    if (Q[i].opt != 0)
      Ans[abs(Q[i].opt)] += query(Q[i].z) * (Q[i].opt < 0 ? -1 : 1);
  }
  for (int i = l; i < nw; ++i)
    if (Q[i].opt == 0) add(Q[i].z, -1);
  sort(Q + l, Q + r + 1, [&](Qnode a, Qnode b) { return a.y < b.y; });
}
signed main() {
  read(Xmx), read(Ymx), read(Zmx), read(n), read(m), read(K);
  for (int i = 1; i <= n; ++i) {
    int x, y, z;
    read(x), read(y), read(z);
    upmin(x1, x), upmax(x2, x);
    upmin(Y1, y), upmax(y2, y);
    upmin(z1, z), upmax(z2, z);
  }
  for (int i = 1; i <= m; ++i) {
    int x, y, z;
    read(x), read(y), read(z);
    if (x1 <= x && x <= x2 && Y1 <= y && y <= y2 && z1 <= z && z <= z2) {
      putstr(string("INCORRECT\n"));
      return 0;
    }
    Q[++Qnum] = (Qnode){0, x, y, z};
  }
  putstr(string("CORRECT\n"));
  for (int i = 1; i <= K; ++i) {
    int x, y, z;
    read(x), read(y), read(z);
    if (x1 <= x && x <= x2 && Y1 <= y && y <= y2 && z1 <= z && z <= z2) {
      Ans[i] = -INF;
      continue;
    }
    int a1 = min(x1, x), a2 = max(x2, x);
    int b1 = min(Y1, y), b2 = max(y2, y);
    int c1 = min(z1, z), c2 = max(z2, z);
    Q[++Qnum] = (Qnode){i, a2, b2, c2};
    if (a1 > 1) Q[++Qnum] = (Qnode){-i, a1 - 1, b2, c2};
    if (b1 > 1) Q[++Qnum] = (Qnode){-i, a2, b1 - 1, c2};
    if (c1 > 1) Q[++Qnum] = (Qnode){-i, a2, b2, c1 - 1};
    if (a1 > 1 && b1 > 1) Q[++Qnum] = (Qnode){i, a1 - 1, b1 - 1, c2};
    if (a1 > 1 && c1 > 1) Q[++Qnum] = (Qnode){i, a1 - 1, b2, c1 - 1};
    if (b1 > 1 && c1 > 1) Q[++Qnum] = (Qnode){i, a2, b1 - 1, c1 - 1};
    if (a1 > 1 && b1 > 1 && c1 > 1)
      Q[++Qnum] = (Qnode){-i, a1 - 1, b1 - 1, c1 - 1};
  }
  sort(Q + 1, Q + Qnum + 1, [&](Qnode a, Qnode b) {
    return (a.x < b.x) || (a.x == b.x && (a.opt == 0) > (b.opt == 0));
  });
  if (Qnum) solve(1, Qnum);
  for (int i = 1; i <= K; ++i) {
    if (Ans[i] == -INF)
      putstr(string("OPEN\n"));
    else if (Ans[i])
      putstr(string("CLOSED\n"));
    else
      putstr(string("UNKNOWN\n"));
  }
  return 0;
}
