#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using u64 = uint_fast64_t; 
using pii =  pair<int, int>;
using pll =  pair<long long, long long>;
#define rep(i, n) for(int i = 0; i < (n); ++i)
#define all(x) (x).begin(),(x).end()
constexpr char ln =  '\n';
//////////////////////////////////////////////////////////////////////////////

using DD = double; // 精度が足りないときはlong double
constexpr DD EPS = 1e-11;
#define equals(a, b) (fabs((a) - (b)) < EPS)

inline int sgn(DD a) {return (a < -EPS) ? -1 : (a > EPS) ? 1 : 0;}

//点
struct Point {
    DD x, y;
    Point (DD x = 0, DD y = 0): x(x), y(y) {}

    Point operator+(const Point &p) const { return Point(*this) += p;}
    Point operator-(const Point &p) const { return Point(*this) -= p;}
    Point operator*(const Point &p) const { return Point(*this) *= p;}
    Point operator*(DD a) const { return Point(*this) *= a;}
    Point operator/(DD a) const { return Point(*this) /= a;}
    Point& operator+=(const Point &p) { x += p.x; y += p.y; return *this;}
    Point& operator-=(const Point &p) { x -= p.x; y -= p.y; return *this;}
    Point& operator*=(const Point &p) { DD u = x*p.x - y*p.y; DD v = x*p.y + y*p.x; x = u; y = v; return *this;}
    Point& operator*=(DD a) { x *= a; y *= a; return *this;}
    Point& operator/=(DD a) { x /= a; y /= a; return *this;}
    bool operator== (const Point &p) const { return !sgn(x - p.x) && !sgn(y - p.y);}
    bool operator!= (const Point &p) const { return sgn(x - p.x) || sgn(y - p.y);}
    bool operator< (const Point &p) const {
        if (sgn(x - p.x)) return sgn(x - p.x) < 0;
        return sgn(y - p.y) < 0;
    }
    friend istream& operator >>(istream& is, Point& p) { is >> p.x >> p.y; return is;}
    friend ostream& operator <<(ostream& os, const Point& p) { os << p.x << " " << p.y; return os;}

    DD norm() { return x*x + y*y;}
    DD abs() { return sqrt(norm());}
    DD arg() { return atan2(y,x);}
};

//ベクトル
using Vector = Point;

inline DD norm(const Vector &a) { return a.x * a.x + a.y * a.y;}
inline DD abs(const Vector &a) { return sqrt(norm(a));}
inline DD dot(const Vector &a, const Vector &b) { return a.x * b.x + a.y * b.y;}
inline DD cross(const Vector &a, const Vector &b) { return a.x * b.y - a.y * b.x;}
inline Point rot(const Point &p, DD arg) { return Point(cos(arg) * p.x - sin(arg) * p.y, sin(arg) * p.x + cos(arg) * p.y);}
inline Point rot90(const Point &p) { return Point(-p.y, p.x);}
inline DD arg(const Vector &p) { return atan2(p.y, p.x);}
//象限
int ort(const Point &a) {
    if (sgn(norm(a))) {
        if (sgn(a.y) > 0) return sgn(a.x) > 0 ? 1 : 2;
        return sgn(a.x) > 0 ? 4 : 3;
    }
    return 0;
}
bool xsort(const Point &a, const Point &b) {
    if (sgn(a.x - b.x)) return sgn(a.x - b.x) < 0;
    return sgn(a.y - b.y) < 0;
}
bool ysort(const Point &a, const Point &b) {
    if (sgn(a.y - b.y)) return sgn(a.y - b.y) < 0;
    return sgn(a.x - b.x) < 0;
}

bool argsortcross(const Point &a, const Point &b) {
    int ao = ort(a), bo = ort(b);
    if (ao != bo) return ao < bo;
    return sgn(cross(a,b)) > 0;
}

bool argsortatan2(const Point &a, const Point &b) {
    return sgn(atan2(b.y, b.x) - atan2(a.y, a.x)) > 0;
}

//線分
struct Segment {
    Point p1,p2;
    Segment() {};
    Segment(Point p1, Point p2) : p1(p1),p2(p2) {}
};

//直線
using Line = Segment;

// 円
struct Circle {
    Point c;
    DD r;
    Circle(){}
    Circle(Point c, DD r): c(c), r(r) {}
    friend istream& operator >>(istream& is, Circle& C) { is >> C.c >> C.r; return is;}
    friend ostream& operator <<(ostream& os, const Circle& C) { os << C.c << " " << C.r; return os;}
};

//多角形
using Polygon = vector<Point>;

int ccw(const Point &p0, const Point &p1, const Point &p2) {
    Vector a = p1 - p0;
    Vector b = p2 - p0;
    if (sgn(cross(a,b)) > 0) return 1; //p0,p1から見てp2は左側(反時計回り)
    if (sgn(cross(a,b)) < 0) return -1; //p0,p1から見てp2は右側(時計回り)
    if (sgn(dot(a,b)) < 0) return 2; //p2-p0-p1の順に一直線上
    if (sgn(norm(b) - norm(a)) > 0) return -2; //p0-p1-p2の順に一直線上
    return 0; //p0-p2-p1の順に一直線上
}

//射影
Point project(const Segment &s, const Point &p) {
    Vector base = s.p2 - s.p1;
    DD r = dot(p - s.p1, base) / norm(base);
    return s.p1 + base * r;
}

//線対称
inline Point reflect(const Segment &s, const Point &p) {return p + (project(s,p) - p) * 2;}

//線分p1,p2とp3,p4の交差判定
inline bool intersect(const Point &p1, const Point &p2, const Point &p3, const Point &p4) { return (ccw(p1, p2, p3) * ccw(p1, p2, p4) <= 0 && ccw(p3, p4, p1) * ccw(p3, p4, p2) <= 0);}
inline bool intersect(const Segment &s1, const Segment &s2) { return intersect(s1.p1, s1.p2, s2.p1, s2.p2);}

inline DD getDistanceLP(const Line &l, const Point &p) { return abs(cross(l.p2 - l.p1,p - l.p1) / abs(l.p2 - l.p1));}
DD getDistanceSP(const Segment &s, const Point &p) {
    if (dot(s.p2 - s.p1,p - s.p1) < 0.0) return abs(p - s.p1);
    if (dot(s.p1 - s.p2,p - s.p2) < 0.0) return abs(p - s.p2);
    return getDistanceLP(s, p);
}
DD getDistance(const Segment &s1, const Segment &s2) {
    if (intersect(s1, s2)) return (DD)0;
    return min({getDistanceSP(s1, s2.p1), getDistanceSP(s1, s2.p2), getDistanceSP(s2, s1.p1), getDistanceSP(s2, s1.p2)});
}

//線分と線分の交点
Point getCrossPoint(const Segment &s1, const Segment &s2) {
    Vector base = s2.p2 - s2.p1;
    DD d1 = abs(cross(base, s1.p1 - s2.p1));
    DD d2 = abs(cross(base, s1.p2 - s2.p1));
    DD t = d1 / (d1 + d2);
    return s1.p1 + (s1.p2 - s1.p1) * t;
}

//円と直線の交差判定
inline bool intersect(const Circle &c, const Line &l) { return getDistanceLP(l, c.c) - c.r < EPS;}
//円と円の交差判定
inline bool intersect(const Circle &c1, const Circle &c2) { return abs(c1.c - c2.c) - (c1.r + c2.r) < EPS && fabs(c1.r - c2.r) - abs(c1.c - c2.c) < EPS;}

//円と線分の交点
pair<Point, Point> getCrossPoints(const Circle &c, const Line &l) {
    assert(intersect(c,l));
    Vector pr = project(l, c.c);
    Vector e = (l.p2 - l.p1) / abs(l.p2 - l.p1);
    DD base = sqrt(c.r * c.r - norm(pr - c.c));
    return make_pair(pr + e * base, pr - e * base);
}

inline Vector polar(DD a, DD r) { return Point(cos(r) * a, sin(r) * a);}

//円と円の交点
pair<Point, Point> getCrossPoints(const Circle &c1, const Circle &c2) {
    assert(intersect(c1, c2));
    DD d = abs(c1.c - c2.c);
    DD a = acos((c1.r * c1.r + d * d - c2.r * c2.r) / (DD(2) * c1.r * d));
    DD t = arg(c2.c - c1.c);
    return make_pair(c1.c + polar(c1.r, t + a), c1.c + polar(c1.r, t - a));
}

//多角形の面積
DD area(const Polygon &g) {
    const int N = g.size();
    DD ret = 0;
    for (int i = 0; i < N; ++i) {
        ret += cross(g[i],g[(i+1)%N]);
    }
    return fabs(ret)/2;
}

// 多角形-点の包含判定
int containment(const Polygon &g, const Point &p) {
    const int N = g.size();
    int cnt = 0;
    for (int i = 0; i < N; ++i) {
        if (norm(g[i] - p) < EPS || norm(g[(i+1)%N] - p) < EPS || ccw(g[i], g[(i+1)%N], p) == 0) {
            return 1; // pがgの辺上に存在する
        }
        Point I = Point(2e9 + p.x, 2e9 + 574677631 + p.y);
        if (ccw(I, p, g[i]) == 0 || ccw(I, p, g[(i+1)%N]) == 0) continue;
        if (intersect(I, p, g[i], g[(i+1)%N])) ++cnt;
    }
    if (cnt&1) return 2; // pがgに含まれる
    else return 0; // pがgに含まれない
}

//凸包
Polygon andrewScan(Polygon s) {
    Polygon u,l;
    const int N = s.size();
    if (N < 3) return s;
    sort(s.begin(), s.end(), xsort);
    u.emplace_back(s[0]);
    u.emplace_back(s[1]);
    l.emplace_back(s[N-1]);
    l.emplace_back(s[N-2]);
    
    for (int i = 2; i < s.size(); ++i) {
        // 凸包上の点も含めるなら ccw() == 1
        for (int n = u.size(); n >= 2 && ccw(u[n-2],u[n-1],s[i]) != -1; --n) {
            u.pop_back();
        }
        u.emplace_back(s[i]);
    }

    for (int i = N - 3; i >= 0; --i) {
        // 凸包上の点も含めるなら ccw() == 1
        for (int n = l.size(); n >= 2 && ccw(l[n-2], l[n-1], s[i]) != -1; --n) {
            l.pop_back();
        }
        l.emplace_back(s[i]);
    }

    reverse(l.begin(), l.end());
    for (int i = u.size() - 2; i >= 1; --i) l.emplace_back(u[i]);

    return l;
}

//最遠点対
DD farthestpointpair(const Polygon &g) {
    const int N = g.size();
    if (N == 2) return abs(g[1] - g[0]);
    int i = 0, j = 0;
    for (int k = 0; k < N; ++k) {
        if (g[k].y > g[i].y) i = k;
        if (g[k].y < g[j].y) j = k;
    }

    DD ret = 0;
    int si = i, sj = j;
    while (i != sj || j != si) {
        ret = max(ret, abs(g[i]-g[j]));
        if (cross(g[(i+1)%N] - g[i], g[(j+1)%N] - g[j]) < -EPS) {
            i = (i+1)%N;
        } else {
            j = (j+1)%N;
        }
    }

    return ret;
}

/////////////////////////////////////////////////////////////////////////////////////////////

void CGL_1_A() {
    Point p1,p2; cin >> p1 >> p2;
    Line l(p1,p2);
    int Q; cin >> Q;
    while (Q--) {
        Point p; cin >> p;
        cout << project(l,p) << ln;
    }
}

void CGL_1_B() {
    Point p1,p2; cin >> p1 >> p2;
    Line l(p1,p2);
    int Q; cin >> Q;
    while (Q--) {
        Point p; cin >> p;
        cout << reflect(l,p) << ln;
    }
}

void CGL_1_C() {
    Point p0,p1; cin >> p0 >> p1;
    int Q; cin >> Q;
    while (Q--) {
        Point p2; cin >> p2;
        int v = ccw(p0,p1,p2);
        string ans;
        if (v==1) ans = "COUNTER_CLOCKWISE";
        if (v==-1) ans = "CLOCKWISE";
        if (v==2) ans = "ONLINE_BACK";
        if (v==-2) ans = "ONLINE_FRONT";
        if (v==0) ans = "ON_SEGMENT";
        cout << ans << ln;
    }
}

int main() {
    ios::sync_with_stdio(false); cin.tie(nullptr);
    cout << fixed << setprecision(20);
    //CGL_1_A();
    //CGL_1_B();
    CGL_1_C();
}


Measured memory_bytes: 3304