#include <bits/stdc++.h>
using namespace std;
struct Point {
  int x, y, z;
  Point() {}
  Point(int x, int y, int z) : x(x), y(y), z(z) {}
};
const int N = 100000;
int n, m, k;
Point mn, mx, lo, hi;
struct Octree {
  vector<Point> p;
  Octree *ch[8];
};
inline int octant_id(Point tl, Point th, Point p) {
  Point tm((tl.x + th.x) / 2, (tl.y + th.y) / 2, (tl.z + th.z) / 2);
  int d = 0;
  if (p.x > tm.x) d += 4;
  if (p.y > tm.y) d += 2;
  if (p.z > tm.z) d += 1;
  return d;
}
inline pair<Point, Point> octant_box(Point tl, Point th, int i) {
  Point ll, hh, tm((tl.x + th.x) / 2, (tl.y + th.y) / 2, (tl.z + th.z) / 2);
  if (i & 4) {
    ll.x = tm.x + 1;
    hh.x = th.x;
  } else {
    ll.x = tl.x;
    hh.x = tm.x;
  }
  if (i & 2) {
    ll.y = tm.y + 1;
    hh.y = th.y;
  } else {
    ll.y = tl.y;
    hh.y = tm.y;
  }
  if (i & 1) {
    ll.z = tm.z + 1;
    hh.z = th.z;
  } else {
    ll.z = tl.z;
    hh.z = tm.z;
  }
  return {ll, hh};
}
const int LEAF_SIZE = 10;
Octree *build(Point tl, Point th, vector<Point> ps) {
  Octree *tree = new Octree();
  tree->p = ps;
  if (ps.size() <= LEAF_SIZE ||
      (tl.x == th.x && tl.y == th.y && tl.z == th.z)) {
    fill(tree->ch, tree->ch + 8, nullptr);
    return tree;
  }
  vector<Point> chs[8];
  for (Point &p : ps) chs[octant_id(tl, th, p)].push_back(p);
  for (int i = 0; i < 8; i++) {
    auto box = octant_box(tl, th, i);
    if (!chs[i].empty())
      tree->ch[i] = build(box.first, box.second, chs[i]);
    else
      tree->ch[i] = nullptr;
  }
  return tree;
}
inline bool in_box(Point tl, Point th, Point p) {
  return tl.x <= p.x && tl.y <= p.y && tl.z <= p.z && th.x >= p.x &&
         th.y >= p.y && th.z >= p.z;
}
bool has(Octree *tree, Point tl, Point th, Point ql, Point qh) {
  if (in_box(ql, qh, tl) && in_box(ql, qh, th)) return tree->p.size() > 0;
  if (tree->p.size() <= LEAF_SIZE ||
      (tl.x == th.x && tl.y == th.y && tl.z == th.z)) {
    for (Point &p : tree->p)
      if (in_box(ql, qh, p)) return true;
    return false;
  }
  for (int i = 0; i < 8; i++) {
    if (!tree->ch[i]) continue;
    auto box = octant_box(tl, th, i);
    Point bl = box.first, bh = box.second;
    if (bh.x < ql.x || qh.x < bl.x || bh.y < ql.y || qh.y < bl.y ||
        bh.z < ql.z || qh.z < bl.z)
      continue;
    if (has(tree->ch[i], bl, bh, ql, qh)) return true;
  }
  return false;
}
int main() {
  mn = Point(1, 1, 1);
  scanf("%d%d%d%d%d%d", &mx.x, &mx.y, &mx.z, &n, &m, &k);
  lo = mx;
  hi.x = hi.y = hi.z = 1;
  int xt, yt, zt;
  for (int i = 0; i < n; i++) {
    scanf("%d%d%d", &xt, &yt, &zt);
    lo.x = min(lo.x, xt);
    hi.x = max(hi.x, xt);
    lo.y = min(lo.y, yt);
    hi.y = max(hi.y, yt);
    lo.z = min(lo.z, zt);
    hi.z = max(hi.z, zt);
  }
  vector<Point> bad;
  for (int i = 0; i < m; i++) {
    scanf("%d%d%d", &xt, &yt, &zt);
    bad.push_back(Point(xt, yt, zt));
  }
  Octree *tree = build(mn, mx, bad);
  if (has(tree, mn, mx, lo, hi)) {
    printf("INCORRECT\n");
    return 0;
  }
  printf("CORRECT\n");
  for (int i = 0; i < k; i++) {
    scanf("%d%d%d", &xt, &yt, &zt);
    Point q(xt, yt, zt);
    if (in_box(lo, hi, q)) {
      printf("OPEN\n");
      continue;
    }
    Point ql(min(lo.x, xt), min(lo.y, yt), min(lo.z, zt)),
        qh(max(hi.x, xt), max(hi.y, yt), max(hi.z, zt));
    if (has(tree, mn, mx, ql, qh))
      printf("CLOSED\n");
    else
      printf("UNKNOWN\n");
  }
}
