#include <iostream>
#include <limits>
#include <cmath>
#include <cstdio>

using namespace std;

#define EPS (numeric_limits<double>::epsilon())
#define equals(a, b) (fabs((a) - (b)) < EPS)

class Point {
public:
    double x, y;

    Point(double x = 0, double y = 0) : x(x), y(y) {}

    Point operator+(const Point &p) const
    {
        return Point(x + p.x, y + p.y);
    }

    Point operator-(const Point &p) const
    {
        return Point(x - p.x, y - p.y);
    }

    Point operator*(const double &a) const
    {
        return Point(a * x, a * y);
    }

    Point operator/(const double &a) const
    {
        return Point(x / a, y / a);
    }

    double abs()
    {
        return sqrt(norm());
    }

    double norm()
    {
        return x * x + y * y;
    }

    bool operator<(const Point &p) const
    {
        return x != p.x ? x < p.x : y < p.y;
    }

    bool operator==(const Point &p) const
    {
        return equals(x, p.x) && equals(y, p.y);
    }
};

typedef Point Vector;

struct Segment {
    Point p1, p2;
};
typedef Segment Line;


double dot(Vector a, Vector b)
{
    return a.x * b.x + a.y * b.y;
}

double cross(Vector a, Vector b)
{
    return a.x * b.y - a.y * b.x;
}

bool isParallel(Vector a, Vector b)
{
    return equals(cross(a, b), 0.0);
}

bool isParallel(Point a1, Point a2, Point b1, Point b2)
{
    return equals(cross(a2 - a1, b2 - b1), 0.0);
}

bool isOrthogonal(Vector a, Vector b)
{
    return equals(dot(a, b), 0.0);
}

bool isOrthogonal(Point a1, Point a2, Point b1, Point b2)
{
    return equals(dot(a2 - a1, b2 - b1), 0.0);
}

Point project(Segment s, Point p)
{
    Vector hypo = p - s.p1;
    Vector base = s.p2 - s.p1;
    return base * (dot(hypo, base) / base.norm()) + s.p1;
}

Point reflect(Segment s, Point p)
{
    return (project(s, p) - p) * 2.0 + p;
}

double getDistance(Point a, Point b)
{
    return (a - b).abs();
}

double getDistanceLP(Line l, Point p)
{
    return abs(cross(l.p2 - l.p1, p - l.p1)) / (l.p2 - l.p1).abs();
}

double getDistanceSP(Segment s, Point p)
{
    if (dot(s.p2 - s.p1, p - s.p1) < 0.0)
        return getDistance(p, s.p1);
    else if (dot(s.p1 - s.p2, p - s.p2) < 0.0)
        return getDistance(p, s.p2);
    else
        return getDistanceLP(s, p);
}

static const int COUNTER_CLOCKWISE = 1;
static const int CLOCKWISE = -1;
static const int ONLINE_BACK = 2;
static const int ONLINE_FRONT = -2;
static const int ON_SEGMENT = 0;

int ccw(Point p0, Point p1, Point p2)
{
    Vector a = p1 - p0;
    Vector b = p2 - p0;
    if (cross(a, b) > 0.0)
        return COUNTER_CLOCKWISE;
    else if (cross(a, b) < 0.0)
        return CLOCKWISE;
    else if (dot(a, b) < 0.0)
        return ONLINE_BACK;
    else if (a.norm() < b.norm())
        return ONLINE_FRONT;
    else
        return ON_SEGMENT;
}

int main()
{
    Point p0, p1;
    cin >> p0.x >> p0.y >> p1.x >> p1.y;
    int query;
    cin >> query;
    Point p2;
    for (int q = 0; q < query; q++)
    {
        cin >> p2.x >> p2.y;
        int ans = ccw(p0, p1, p2);
        if(ans == COUNTER_CLOCKWISE)
            cout << "COUNTER_CLOCKWISE" << endl;
        else if(ans == CLOCKWISE)
            cout << "CLOCKWISE" << endl;
        else if(ans == ONLINE_BACK)
            cout << "ONLINE_BACK" << endl;
        else if(ans == ONLINE_FRONT)
            cout << "ONLINE_FRONT" << endl;
        else
            cout << "ON_SEGMENT" << endl;
    }
}


Measured memory_bytes: 3224