#include <bits/stdc++.h>
using namespace std;
inline void read(int &x) {
  x = 0;
  char c = getchar();
  int f = 1;
  while (!isdigit(c)) {
    if (c == '-') f = -1;
    c = getchar();
  }
  while (isdigit(c)) {
    x = x * 10 + c - '0';
    c = getchar();
  }
  x *= f;
}
const int N = 204000, M = 18000000;
int X, Y, Z, n, m, k, mx;
int xl, xr, yl, yr, zl, zr, ans[N];
struct dot {
  int x, y, z;
} a[N / 2], b[N / 2], c[N / 2];
bool In(dot a) {
  return a.x >= xl && a.x <= xr && a.y >= yl && a.y <= yr && a.z >= zl &&
         a.z <= zr;
}
struct juxing {
  int xl, xr, yl, yr, z, ind;
} d[N];
int len;
bool cmp1(juxing a, juxing b) { return a.z < b.z; }
struct Seg {
  int size;
  int lc[M], rc[M], sum[M];
  inline void init() { size = mx; }
  inline void add(int k, int x, int L, int R) {
    sum[k]++;
    if (L == R) return;
    if (x <= ((L + R) >> 1)) {
      if (!lc[k]) lc[k] = ++size;
      add(lc[k], x, L, ((L + R) >> 1));
    } else {
      if (!rc[k]) rc[k] = ++size;
      add(rc[k], x, ((L + R) >> 1) + 1, R);
    }
  }
  inline int query(int k, int l, int r, int L, int R) {
    if (!k) return 0;
    if (l == L && r == R) return sum[k];
    if (r <= ((L + R) >> 1)) return query(lc[k], l, r, L, ((L + R) >> 1));
    if (l >= ((L + R) >> 1) + 1)
      return query(rc[k], l, r, ((L + R) >> 1) + 1, R);
    return query(lc[k], l, ((L + R) >> 1), L, ((L + R) >> 1)) +
           query(rc[k], ((L + R) >> 1) + 1, r, ((L + R) >> 1) + 1, R);
  }
} tree;
struct Node {
  inline void add(int x, int y) {
    while (x <= mx) {
      tree.add(x, y, 1, mx);
      x += x & -x;
    }
  }
  inline int query(int x, int l, int r) {
    int res = 0;
    int rec = x;
    while (x) {
      res += tree.query(x, l, r, 1, mx);
      x -= x & -x;
    }
    return res;
  }
} BIT;
bool cmp(dot a, dot b) { return a.z < b.z; }
int Abs(int x) { return x > 0 ? x : -x; }
int sgn(int x) { return x > 0 ? 1 : -1; }
int main() {
  read(X);
  read(Y);
  read(Z);
  mx = max(max(X, Y), Z);
  read(n);
  read(m);
  read(k);
  for (register int i = 1; i <= n; i++)
    read(a[i].x), read(a[i].y), read(a[i].z);
  for (register int i = 1; i <= m; i++)
    read(b[i].x), read(b[i].y), read(b[i].z);
  for (register int i = 1; i <= k; i++)
    read(c[i].x), read(c[i].y), read(c[i].z);
  xl = xr = a[1].x;
  yl = yr = a[1].y;
  zl = zr = a[1].z;
  for (register int i = 2; i <= n; i++) {
    xl = min(xl, a[i].x);
    xr = max(xr, a[i].x);
    yl = min(yl, a[i].y);
    yr = max(yr, a[i].y);
    zl = min(zl, a[i].z);
    zr = max(zr, a[i].z);
  }
  for (register int i = 1; i <= m; i++)
    if (In(b[i])) {
      puts("INCORRECT");
      return 0;
    }
  puts("CORRECT");
  for (register int i = 1; i <= k; i++)
    if (In(c[i]))
      ans[i] = -1;
    else {
      ++len;
      d[len].ind = i;
      d[len].z = max(zr, c[i].z);
      d[len].xl = min(xl, c[i].x);
      d[len].xr = max(xr, c[i].x);
      d[len].yl = min(yl, c[i].y);
      d[len].yr = max(yr, c[i].y);
      ++len;
      d[len].ind = -i;
      d[len].z = min(zl, c[i].z) - 1;
      d[len].xl = min(xl, c[i].x);
      d[len].xr = max(xr, c[i].x);
      d[len].yl = min(yl, c[i].y);
      d[len].yr = max(yr, c[i].y);
    }
  tree.init();
  sort(b + 1, b + m + 1, cmp);
  sort(d + 1, d + len + 1, cmp1);
  int p = 0;
  for (register int i = 1; i <= len; i++) {
    while (p + 1 <= m && b[p + 1].z <= d[i].z) {
      p++;
      BIT.add(b[p].x, b[p].y);
    }
    ans[Abs(d[i].ind)] +=
        sgn(d[i].ind) * (BIT.query(d[i].xr, d[i].yl, d[i].yr) -
                         BIT.query(d[i].xl - 1, d[i].yl, d[i].yr));
  }
  for (register int i = 1; i <= k; i++)
    if (ans[i] == -1)
      puts("OPEN");
    else if (ans[i] == 0)
      puts("UNKNOWN");
    else
      puts("CLOSED");
  return 0;
}
