#include <bits/stdc++.h>
using namespace std;
template <typename T>
ostream& operator<<(ostream& out, const vector<T>& vec) {
  out << "[";
  for (int x : vec) out << x << ", ";
  out << "]";
  return out;
}
struct RangeTree {
  vector<int> val;
  int n;
  RangeTree(int n) : val(4 * n, 0), n(n) {}
  RangeTree() {}
  void update(int x, int v) { update(1, 1, n, x, v); }
  int getmax(int a, int b) { return getmax(1, 1, n, a, b); }

 private:
  void update(int u, int l, int r, int x, int v) {
    if (r < x or l > x) return;
    if (l == r) {
      val[u] = v;
    } else {
      update(2 * u, l, (l + r) / 2, x, v);
      update(2 * u + 1, (l + r) / 2 + 1, r, x, v);
      val[u] = max(val[2 * u], val[2 * u + 1]);
    }
  }
  int getmax(int u, int l, int r, int a, int b) {
    if (r < a or b < l) return 0;
    if (a <= l and r <= b) return val[u];
    return max(getmax(2 * u, l, (l + r) / 2, a, b),
               getmax(2 * u + 1, (l + r) / 2 + 1, r, a, b));
  }
};
RangeTree rt[400000];
vector<int> coord[400000];
int getmax(int u, int l, int r, int x1, int x2, int y1, int y2) {
  if (r < y1 or y2 < l) return 0;
  if (y1 <= l and r <= y2) {
    if (coord[u].size() == 0) return 0;
    int a = lower_bound(coord[u].begin(), coord[u].end(), x1) -
            coord[u].begin() + 1;
    int b =
        upper_bound(coord[u].begin(), coord[u].end(), x2) - coord[u].begin();
    if (b < a) return 0;
    return rt[u].getmax(a, b);
  }
  return max(getmax(2 * u, l, (l + r) / 2, x1, x2, y1, y2),
             getmax(2 * u + 1, (l + r) / 2 + 1, r, x1, x2, y1, y2));
}
void update(int u, int l, int r, int x, int y, int v) {
  if (y < l or y > r) return;
  if (coord[u].size() == 0) return;
  int a =
      lower_bound(coord[u].begin(), coord[u].end(), x) - coord[u].begin() + 1;
  rt[u].update(a, v);
  if (l == r) return;
  update(2 * u, l, (l + r) / 2, x, y, v);
  update(2 * u + 1, (l + r) / 2 + 1, r, x, y, v);
}
void make_coord(int u, int l, int r, int x, int y) {
  if (y < l or y > r) return;
  coord[u].push_back(x);
  if (l == r) return;
  make_coord(2 * u, l, (l + r) / 2, x, y);
  make_coord(2 * u + 1, (l + r) / 2 + 1, r, x, y);
}
void build_rt(int u, int l, int r) {
  sort(coord[u].begin(), coord[u].end());
  int n = unique(coord[u].begin(), coord[u].end()) - coord[u].begin();
  coord[u].resize(n);
  rt[u] = RangeTree(n);
  if (l == r) return;
  build_rt(2 * u, l, (l + r) / 2);
  build_rt(2 * u + 1, (l + r) / 2 + 1, r);
}
struct Point {
  int x[3];
  bool operator<(const Point& other) const {
    for (int i = 2; i >= 0; i--) {
      if (x[2] < other.x[2]) return true;
      if (other.x[2] < x[2]) return false;
    }
    return false;
  }
};
struct PP {
  Point A, B;
  bool operator<(const PP& other) const {
    if (B < other.B) return true;
    if (other.B < B) return false;
    return A < other.A;
  }
};
struct Event {
  bool is_query;
  int id;
  int z;
  Event(bool is_query, int id, int z) : is_query(is_query), id(id), z(z) {}
  bool operator<(const Event& other) const {
    if (z < other.z) return true;
    if (other.z < z) return false;
    if (is_query and not other.is_query) return false;
    if (not is_query and other.is_query) return true;
    return id < other.id;
  }
};
int X[3];
int n, m, k;
Point store_closed[100000];
PP query[100000];
string answer[100000];
int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  cin >> X[0] >> X[1] >> X[2] >> n >> m >> k;
  int xmin[3], xmax[3];
  for (int i = 0; i < 3; i++) {
    xmin[i] = 1e5;
    xmax[i] = 0;
  }
  for (int j = 0; j < n; j++) {
    int x[3];
    for (int i = 0; i < 3; i++) cin >> x[i];
    for (int i = 0; i < 3; i++) {
      xmin[i] = min(xmin[i], x[i]);
      xmax[i] = max(xmax[i], x[i]);
    }
  }
  vector<Event> evs;
  for (int j = 0; j < m; j++) {
    for (int i = 0; i < 3; i++) cin >> store_closed[j].x[i];
    bool inside = true;
    for (int i = 0; i < 3; i++)
      if (store_closed[j].x[i] < xmin[i] or store_closed[j].x[i] > xmax[i])
        inside = false;
    if (inside) {
      cout << "INCORRECT\n";
      return 0;
    }
    evs.emplace_back(false, j, store_closed[j].x[2]);
    make_coord(1, 1, X[1], store_closed[j].x[0], store_closed[j].x[1]);
  }
  build_rt(1, 1, X[1]);
  for (int j = 0; j < k; j++) {
    Point P;
    for (int i = 0; i < 3; i++) cin >> P.x[i];
    for (int i = 0; i < 3; i++) query[j].A.x[i] = min(P.x[i], xmin[i]);
    for (int i = 0; i < 3; i++) query[j].B.x[i] = max(P.x[i], xmax[i]);
    bool inside = true;
    for (int i = 0; i < 3; i++)
      if (P.x[i] < xmin[i] or P.x[i] > xmax[i]) inside = false;
    if (inside)
      answer[j] = "OPEN";
    else
      evs.emplace_back(true, j, query[j].B.x[2]);
  }
  sort(evs.begin(), evs.end());
  for (Event e : evs) {
    if (e.is_query) {
      PP Q = query[e.id];
      int mm = getmax(1, 1, X[1], Q.A.x[0], Q.B.x[0], Q.A.x[1], Q.B.x[1]);
      if (mm < Q.A.x[2])
        answer[e.id] = "UNKNOWN";
      else
        answer[e.id] = "CLOSED";
    } else {
      Point P = store_closed[e.id];
      update(1, 1, X[1], P.x[0], P.x[1], P.x[2]);
    }
  }
  cout << "CORRECT\n";
  for (int j = 0; j < k; j++) cout << answer[j] << '\n';
  return 0;
}
