#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector")
#pragma GCC target("avx")
using namespace std;
template <typename T, typename U>
inline void smin(T &a, const U &b) {
  if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, const U &b) {
  if (a < b) a = b;
}
char gchar() {
  static char tbuf1[1000], *tmp_st = tbuf1, *tmp_ed = tbuf1;
  if (tmp_st == tmp_ed) {
    int len = fread(tbuf1, 1, 1000, stdin);
    if (len == 0) return -1;
    tmp_ed = tbuf1 + len;
    tmp_st = tbuf1;
  }
  return *(tmp_st++);
}
inline bool gn(int &x) {
  char c, sg = 0;
  while (c = gchar(), (c > '9' || c < '0') && c != '-' && ~c)
    ;
  if (c == -1) return 0;
  for ((c == '-' ? sg = 1, c = gchar() : 0), x = 0; c >= '0' && c <= '9';
       c = gchar())
    x = (x << 1) + (x << 3) + c - '0';
  if (sg) x = -x;
  return 1;
}
int id[100100], LL[400400], RR[400400];
int xx, XX, yy, YY, zz, ZZ;
int Xmn = 100100, Ymn = 100100, Zmn = 100100, Xmx, Ymx, Zmx;
int x[100100], y[100100], z[100100], xmn[400400], xmx[400400], ymn[400400],
    ymx[400400];
vector<int> vec[400400];
inline void select(int L, int mid, int R, int *val) {
  R--;
  while (L + 1 <= R) {
    if (L + 1 == R) {
      if (val[id[L]] > val[id[R]]) swap(id[L], id[R]);
      return;
    }
    int S = L + 1, X = S + rand() * rand() % (R - L);
    swap(id[L], id[X]);
    if (val[id[L]] > val[id[R]]) swap(id[L], id[R]);
    if (val[id[L]] > val[id[S]]) swap(id[L], id[S]);
    if (val[id[S]] > val[id[R]]) swap(id[S], id[R]);
    int i = L, j = R, p = val[id[S]];
    while (1) {
      while (i <= R && val[id[i]] <= p) i++;
      while (j >= L && val[id[j]] >= p) j--;
      if (i > j) break;
      swap(id[i], id[j]);
    }
    if (mid <= j)
      R = j;
    else if (mid >= i)
      L = i;
    else
      break;
  }
}
inline void build(int u, int L, int R, int dp = 0) {
  LL[u] = L, RR[u] = R;
  if (L + 1 == R) {
    xmn[u] = xmx[u] = x[id[L]];
    ymn[u] = ymx[u] = y[id[L]];
    vec[u].push_back(z[id[L]]);
    return;
  }
  int ls = u << 1, rs = ls | 1, mid = L + R >> 1;
  if (dp)
    select(L, mid, R, x);
  else
    select(L, mid, R, y);
  dp ^= 1;
  build(ls, L, mid, dp);
  build(rs, mid, R, dp);
  for (int i = 0, j = 0, mn;;) {
    mn = i < vec[ls].size() ? vec[ls][i] : 100100;
    if (j < vec[rs].size() && mn >= vec[rs][j])
      vec[u].push_back(vec[rs][j++]);
    else if (mn < 100100)
      vec[u].push_back(vec[ls][i++]);
    else
      break;
  }
  xmn[u] = min(xmn[ls], xmn[rs]), xmx[u] = max(xmx[ls], xmx[rs]);
  ymn[u] = min(ymn[ls], ymn[rs]), ymx[u] = max(ymx[ls], ymx[rs]);
}
inline bool calc(int u) {
  if (xmx[u] < xx || xmn[u] > XX || ymx[u] < yy || ymn[u] > YY) return false;
  if (xx <= xmn[u] && xmx[u] <= XX && yy <= ymn[u] && ymx[u] <= YY) {
    return upper_bound(vec[u].begin(), vec[u].end(), ZZ) -
           lower_bound(vec[u].begin(), vec[u].end(), zz);
  }
  if (LL[u] + 1 == RR[u]) return false;
  int ls = u << 1;
  if (calc(ls)) return true;
  return calc(ls | 1);
}
inline bool in(int x, int y, int z) {
  return Xmn <= x && x <= Xmx && Ymn <= y && y <= Ymx && Zmn <= z && z <= Zmx;
}
int main() {
  srand(time(0));
  int n, m, k;
  for (int i = 2; i--;) gn(n), gn(m), gn(k);
  while (n--) {
    gn(xx), smin(Xmn, xx), smax(Xmx, xx);
    gn(yy), smin(Ymn, yy), smax(Ymx, yy);
    gn(zz), smin(Zmn, zz), smax(Zmx, zz);
  }
  for (int i = 0; i < m; i++) {
    gn(x[i]), gn(y[i]), gn(z[i]);
    if (in(x[i], y[i], z[i])) return puts("INCORRECT");
    id[i] = i;
  }
  if (m) build(1, 0, m);
  puts("CORRECT");
  while (k--) {
    int x, y, z;
    gn(x), gn(y), gn(z);
    if (in(x, y, z))
      puts("OPEN");
    else if (m) {
      xx = min(Xmn, x), XX = max(Xmx, x);
      yy = min(Ymn, y), YY = max(Ymx, y);
      zz = min(Zmn, z), ZZ = max(Zmx, z);
      if (calc(1))
        puts("CLOSED");
      else
        puts("UNKNOWN");
    } else
      puts("UNKNOWN");
  }
}
