#include <iostream>
#include <vector>
#include <string>
#include <stack>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <algorithm>	// require sort next_permutation count __gcd reverse etc.
#include <cstdlib>	// require abs exit atof atoi 
#include <cstdio>		// require scanf printf
#include <functional>
#include <numeric>	// require accumulate
#include <cmath>		// require fabs
#include <climits>
#include <limits>
#include <cfloat>
#include <iomanip>	// require setw
#include <sstream>	// require stringstream 
#include <cstring>	// require memset
#include <cctype>		// require tolower, toupper
#include <fstream>	// require freopen
#include <ctime>		// require srand
#define rep(i,n) for(int i=0;i<(n);i++)
#define ALL(A) A.begin(), A.end()
#define EPS (1e-10)

using namespace std;

typedef long long ll;
typedef pair<int, int> P;

template<class T>
struct point{
	T x, y;
	point &operator+=(const point &a ){ x += a.x; y += a.y; }
	point &operator-=(const point &a ){ x -= a.x; y -= a.y; }
	point operator+(const point &a )const{ return (point){x+a.x, y+a.y }; }
	point operator-(const point &a )const{ return (point){x-a.x, y-a.y }; }
	operator point<double>()const{ return (point<double>){x, y }; }
};

template<class T>
point<T> operator*(T c, const point<T> &a ){ return (point<T>){c*a.x, c*a.y }; }
point<double> &operator/=(point<double> &a, double c ){ a.x /= c; a.y /= c; return a; }
template<class T>
point<double> operator/(const point<T> &a, double c ){ return (point<double>){ a.x/c, a.y/c }; }

//  for real number
bool operator<(const point<double> &a, const point<double> &b ){
	return (a.x + EPS < b.x || (abs (a.x - b.x ) < EPS && (a.y + EPS < b.y ) ) );
}

bool operator==(const point<double> &a, const point<double> &b ){
	return abs (a.x - b.x) < EPS && abs (a.y - b.y ) < EPS;
}

bool operator!=(const point<double> &a, const point<double> &b ){
	return abs (a.x - b.x ) > EPS || abs (a.y - b.y ) > EPS;
}

// inner product
template<class T>
T dot(const point<T> &a, const point<T> &b ){ return a.x*b.x + a.y*b.y; }

// outer product
template<class T>
T cross(const point<T> &a, const point<T> &b ){ return a.x*b.y - a.y*b.x; }

// distance between origin(0,0) to point a
template<class T>
double abs(const point<T> &a ){ return sqrt (a.x*a.x + a.y*a.y ); }

template<class T>
T abs2(const point<T> &a ){ return a.x*a.x + a.y*a.y; }


/*
	回転方向

	説明
		３点の位置関係を求める
		(A) 座標値が整数
		(B) 座標値が実数
	引数
		a : 点
		b : 点
		c : 点
	戻り値
		a-b-c の順に反時計回りに回転しているとき CCW
		a-b-c の順に時計回りに回転しているとき CW
		a-b-c が同一直線上にあるとき ON
	制約
		なし
	計算量
		O(1)
	備考
		2 点以上が同一の点であれば常に ON を返すことに注意

*/

// (A)
enum{CCW = 0, CW = 1, ON = 2 };
int ccw (const point<double> &a, const point<double> &b, const point<double> &c ){
	double rdir = cross (b-a, c-a );
	if (rdir > 0 ) return CCW;
	if (rdir < 0 ) return CW;
	return ON;
}

/*
	3点が同一直線上にあるときの処理

	説明
		３点の位置関係を求める
	引数
		a : 点
		b : 点
		c : 点
	戻り値
		ベクトル b - a とベクトル c - a が反対方向のとき ONLINE_BACK
		ベクトル b - a とベクトル c - a が同じ方向で
		ベクトル b - a の延長線上に点 c があるとき ONLINE_FRONT
		線分 ba の中に 点 c があるとき ON_SEGMENT
	制約
		3点が同一直線上にあるときに限る
	計算量
		O(1)
	備考
		3点 a, b, c の少なくも2点が同一の点であれば、常に ON_SEGMENT を返すことに注意
*/
enum{ONLINE_BACK = 0, ONLINE_FRONT = 1, ON_SEGMENT = 2 };
int on_line (const point<double> &a, const point<double> &b, const point<double> &c ){

	double rcos = dot (b-a, c-a );
	if (rcos < 0. ){
		return ONLINE_BACK;
	}else{		
		if (abs2 (b-a ) < abs2 (c - a ) )
			return ONLINE_FRONT;
		else
			return ON_SEGMENT;
	} // end if			

}
const string status[] = { "COUNTER_CLOCKWISE", "CLOCKWISE", "ONLINE_BACK", "ONLINE_FRONT", "ON_SEGMENT" };

int main()
{
	ios_base::sync_with_stdio(0);
	point<double> p0, p1;
	cin >> p0.x >> p0.y >> p1.x >> p1.y;

	int q; cin >> q;
	rep (i, q ){
		int res = -1;
		point<double> p2;
		cin >> p2.x >> p2.y;
		if ((res = ccw (p0, p1, p2 ) ) != ON ){
			cout << status[res] << endl;
		}else{
			res = on_line (p0, p1, p2 );
			cout << status[res+2] << endl;
		} // end if
	} // end rep

	return 0;
}

Measured memory_bytes: 1240