#include <iostream>
#include <vector>
#include <math.h>

using namespace std;
using ll = long long;
using ld = long double;

ld eps = 1e-15L;

const int N = 12;



struct point {
	ld x;
	ld y;
	point() {}

	point(ld x0, ld y0) {
		x = x0;
		y = y0;
	}

};


struct line {
	ld A;
	ld B;
	ld C;
	line() {}

	line(ld A, ld B, ld C) {
		this->A = A;
		this->B = B;
		this->C = C;
	}

	line(point D, point E) {
		this->A = D.y - E.y;
		this->B = E.x - D.x;
		this->C = -(A * D.x + B * D.y);
	}

};

bool is_intersect(line l, line k) {
	return abs(l.A * k.B - l.B * k.A) > eps;
}


point intersect(line l, line k) {
	ld q = l.A * k.B - l.B * k.A;
	ld y = (l.C * k.A - l.A * k.C) / q;
	ld x = (l.B * k.C - l.C * k.B) / q;
	return point(x, y);
}


point inter[N][N];
bool is_inter[N][N];
bool mem[N][N][N][N][N][N];
bool lol[N][N][N];


bool is_on_segment(point A, point B, point Z) {
	bool f1 = (A.x - Z.x) < eps;
	bool f2 = (Z.x - B.x) < eps;

	if (f1 ^ f2)
		return false;

	bool f3 = (A.y - Z.y) < eps;
	bool f4 = (Z.y - B.y) < eps;

	if (f3 ^ f4)
		return false;
	return true;

}


bool segment_intersec(point A, point B, point C, point D, line l, line k) {
	if (!is_intersect(l, k))
		return false;
	point E = intersect(l, k);
	return (is_on_segment(A, B, E) && is_on_segment(C, D, E));
}


ld dist(point A, point B) {
	return abs(A.x - B.x) + abs(A.y - B.y);
}


line all_lines[N];
int lines[N];
int lines_len = 0;
int points_len = 0;
point points[N];

ll kek(ll mask, int n) {
	if (mask == 0) {

		if (!lol[lines[n - 2]][lines[n - 1]][lines[0]])
			return 0;

		for (int i = 0; i + 2 <= n - 2; i++)
			if (mem[lines[n - 2]][lines[n - 1]][lines[0]][lines[i]]
				[lines[i + 1]][lines[i + 2]])
				return 0;

		if (!lol[lines[n - 1]][lines[0]][lines[1]])
			return 0;

		for (int i = 1; i + 2 <= n - 1; i++)
			if (mem[lines[n - 1]][lines[0]][lines[1]][lines[i]]
				[lines[i + 1]][lines[i + 2]])
				return 0;

		return 1;

		
	}
	else {
		ll sum = 0;
		int k = lines_len;
		point A(-1, -1);
		
		for (int i = 0; i < n; i++) {
			if ((1 << i) & mask) {
				bool f = 1;
				if (k >= 2 && !lol[lines[k - 2]][lines[k - 1]][i])
					f = 0;

				if (k >= 1 && !is_inter[lines[k - 1]][i])
					f = 0;

				for (int j = 0; j <= k - 4 && f; j++) {
					if (mem[lines[j]][lines[j + 1]][lines[j + 2]][lines[k - 2]][lines[k - 1]][i])
						f = 0;
				}
				if (f) {
					lines[lines_len] = i;
					lines_len++;
					
					sum += kek(mask - (1 << i), n);
					lines_len--;
				}
			}
		}
		
		return sum;
	}
}


int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	int n;
	cin >> n;
	for (int i = 0; i < n; i++) {
		ll a, b, c, d;
		cin >> a >> b >> c >> d;
		point A = point(a, b);
		point B = point(c, d);
		line l = line(A, B);
		all_lines[i] = l;
	}
	

	for (int i = 0; i < n; i++) {
		for (int j = 0; j < n; j++) {
			if (i != j) {
				is_inter[i][j] = is_intersect(all_lines[i], all_lines[j]);
				if (is_inter[i][j])
					inter[i][j] = intersect(all_lines[i], all_lines[j]);
			}

		}
	}

	for (int i = 0; i < n * n * n * n * n * n; i++) {
		vector<int> id(6);
		int cur = i;
		for (int j = 0; j < 6; j++) {
			id[j] = cur % n;
			cur /= n;
		}

		if (!is_inter[id[0]][id[1]] || !is_inter[id[2]][id[1]]
			|| !is_inter[id[3]][id[4]] || !is_inter[id[4]][id[5]])
			mem[id[0]][id[1]][id[2]][id[3]][id[4]][id[5]] = 1;
		else {
			mem[id[0]][id[1]][id[2]][id[3]][id[4]][id[5]] =
				segment_intersec(inter[id[0]][id[1]], inter[id[2]][id[1]],
					inter[id[3]][id[4]], inter[id[4]][id[5]], all_lines[id[1]], all_lines[id[4]]);
		}
	}

	for (int i = 0; i < n; i++)
		for (int j = 0; j < n; j++)
			for (int k = 0; k < n; k++) {
				if (!is_inter[i][j] || !is_inter[j][k])
					lol[i][j][k] = 0;
				else
					lol[i][j][k] = (dist(inter[i][j], inter[j][k]) > eps);
			}

	lines[0] = 0;
	lines_len = 1;

	ll mask = (1 << n) - 1 - 1;
	ll ans = kek(mask, n);
	cout << ans  / 2<< '\n';
}

/*
5
0 0 1 0
1 0 3 1
3 1 0 4
0 4 -1 3
-1 3 0 0
*/