// Original C++ solution (slower):
#include<iostream>

#include<algorithm>

#include<map>

#include<set>

#include<array>

#include<vector>

using namespace std;

long conv(int a,int b,int c,int d){return 1000000000L*a+1000000L*b+1000L*c+d;}

long rotate(long a){return a%1000000000L*1000+a/1000000000L;}

bool same(long a,long b)

{

	if(a==b)return true;

	a=rotate(a);

	if(a==b)return true;

	a=rotate(a);

	if(a==b)return true;

	a=rotate(a);

	if(a==b)return true;

	return false;

}

int N;

map<long,array<array<long,15>,4> >M;

int a[400],b[400],c[400],d[400];

map<long,int>COUNT[400];

set<long>S;

main()

{

	cin>>N;

	for(int i=0;i<N;i++)

	{

		cin>>a[i]>>b[i]>>c[i]>>d[i];

		long C=conv(a[i],b[i],c[i],d[i]);

		for(int r=0;r<4;r++)

		{

			COUNT[i][C]++;

			S.insert(C);

			C=rotate(C);

		}

	}

	for(long it:S)

	{

		array<array<long,15>,4>&A=M[it];

		long sum=0;

		int ct[5]={};

		for(int i=0;i<N;i++)

		{

			int c=COUNT[i][it];

			sum+=c;

			ct[c]++;

		}

		for(int j=0;j<5;j++)for(int k=0;k<=j;k++)

		{

			if(j&&ct[j]==0||k&&ct[k]==0)continue;

			ct[j]--;

			ct[k]--;

			A[0][j*(j+1)/2+k]=sum-j-k;

			A[1][j*(j+1)/2+k]=(sum-j-k)*(sum-j-k-1)-ct[2]*2-ct[3]*6-ct[4]*12;

			A[2][j*(j+1)/2+k]=(sum-j-k)*(sum-j-k-1)*(sum-j-k-2)

				-(sum-j-k-2)*ct[2]*6

				-(sum-j-k-3)*ct[3]*3*6-ct[3]*6

				-(sum-j-k-4)*ct[4]*6*6-ct[4]*24;

			A[3][j*(j+1)/2+k]=(sum-j-k)*(sum-j-k-1)*(sum-j-k-2)*(sum-j-k-3)

				-(sum-j-k-2)*(sum-j-k-2-1)/2*ct[2]*24

				-(sum-j-k-3)*(sum-j-k-3-1)/2*ct[3]*3*24-(sum-j-k-3)*ct[3]*24

				-(sum-j-k-4)*(sum-j-k-4-1)/2*ct[4]*6*24-(sum-j-k-4)*ct[4]*4*24-ct[4]*24

				+ct[2]*(ct[2]-1)/2*24

				+ct[2]*ct[3]*3*24

				+ct[2]*ct[4]*6*24

				+ct[3]*3*(ct[3]-1)*3/2*24

				+ct[3]*3*ct[4]*6*24

				+ct[4]*6*(ct[4]-1)*6/2*24;

			ct[j]++;

			ct[k]++;

		}

	}

	long ans=0;

	for(int i=0;i<N;i++)

	{

		for(int j=i+1;j<N;j++)

		{

			for(int ccc=0;ccc<4;ccc++)

			{

				int tmp=a[j];

				a[j]=b[j];

				b[j]=c[j];

				c[j]=d[j];

				d[j]=tmp;

				long t[4]={

					conv(b[i],a[i],b[j],a[j]),

					conv(a[i],d[i],c[j],b[j]),

					conv(d[i],c[i],d[j],c[j]),

					conv(c[i],b[i],a[j],d[j]),

				};

				int cc[4]={1,1,1,1};

				for(int I=0;I<4;I++)for(int J=I+1;J<4;J++)

				{

					if(cc[J]==0)continue;

					if(same(t[I],t[J]))cc[I]+=cc[J],cc[J]=0;

				}

				long now=1;

				for(int k=0;k<4;k++)

				{

					if(cc[k]==0)continue;

					int a=COUNT[i][t[k]];

					int b=COUNT[j][t[k]];

					if(a<b)a^=b^=a^=b;

					now*=M.find(t[k])==M.end()?0:M[t[k]][cc[k]-1][a*(a+1)/2+b];

				}

				ans+=now;

			}

		}

	}

	cout<<ans/3<<endl;

}

// Optimized solution to the same problem (faster):
#include<iostream>

#include<set>

#include<map>

#include<algorithm>

using namespace std;

long get(int a,int b,int c,int d)

{

	long ret=a*1000000000L+b*1000000L+c*1000L+d;

	ret=min(ret,b*1000000000L+c*1000000L+d*1000L+a);

	ret=min(ret,c*1000000000L+d*1000000L+a*1000L+b);

	ret=min(ret,d*1000000000L+a*1000000L+b*1000L+c);

	return ret;

}

map<long,set<int> >M;

int a[400],b[400],c[400],d[400];

int N;

main()

{

	cin>>N;

	for(int i=0;i<N;i++)

	{

		cin>>a[i]>>b[i]>>c[i]>>d[i];

		M[get(a[i],b[i],c[i],d[i])].insert(i);

	}

	long ans=0;

	for(int i=0;i<N;i++)

	{

		for(int j=i+1;j<N;j++)

		{

			for(int r=0;r<4;r++)

			{

				swap(a[j],b[j]);

				swap(b[j],c[j]);

				swap(c[j],d[j]);

				long t[4]={

					get(b[i],a[i],b[j],a[j]),

					get(a[i],d[i],c[j],b[j]),

					get(d[i],c[i],d[j],c[j]),

					get(c[i],b[i],a[j],d[j]),

				};

				int cc[4]={1,1,1,1};

				for(int I=0;I<4;I++)for(int J=I+1;J<4;J++)

				{

					if(t[I]==t[J])cc[I]+=cc[J],cc[J]=0;

				}

				long now=1;

				for(int k=0;k<4;k++)

				{

					if(cc[k]==0)continue;

					if(M.find(t[k])==M.end())

					{

						now=0;

						break;

					}

					int C=M[t[k]].size();

					if(M[t[k]].find(i)!=M[t[k]].end())C--;

					if(M[t[k]].find(j)!=M[t[k]].end())C--;

					int L=1;

					if(t[k]==t[k]%1000*1001001001L)L=4;

					else if(t[k]==t[k]%1000000*1000001L)L=2;

					for(int l=0;l<cc[k];l++)

					{

						now=now*(C-l)*L;

					}

				}

				ans+=now;

			}

		}

	}

	cout<<ans/3<<endl;

}


// Fastest known solution for this problem: