#include <bits/stdc++.h>
using namespace std;

#define rep(i, a, b) for(int i = a; i < (b); ++i)
#define all(x) begin(x), end(x)
#define sz(x) (int)(x).size()
typedef __int128_t ll;
typedef pair<int, int> pii;
typedef vector<int> vi;


template <class T> int sgn(T x) { return (x > 0) - (x < 0); }
template<class T>
struct Point {
	typedef Point P;
	T x, y;
	explicit Point(T x=0, T y=0) : x(x), y(y) {}
	bool operator<(P p) const { return tie(x,y) < tie(p.x,p.y); }
	bool operator==(P p) const { return tie(x,y)==tie(p.x,p.y); }
	P operator+(P p) const { return P(x+p.x, y+p.y); }
	P operator-(P p) const { return P(x-p.x, y-p.y); }
	P operator*(T d) const { return P(x*d, y*d); }
	P operator/(T d) const { return P(x/d, y/d); }
	T dot(P p) const { return x*p.x + y*p.y; }
	T cross(P p) const { return x*p.y - y*p.x; }
	T cross(P a, P b) const { return (a-*this).cross(b-*this); }
	T dist2() const { return x*x + y*y; }
	double dist() const { return sqrt((double)dist2()); }
	// angle to x-axis in interval [-pi, pi]
	double angle() const { return atan2(y, x); }
	P unit() const { return *this/dist(); } // makes dist()=1
	P perp() const { return P(-y, x); } // rotates +90 degrees
	P normal() const { return perp().unit(); }
	// returns point rotated 'a' radians ccw around the origin
	P rotate(double a) const {
		return P(x*cos(a)-y*sin(a),x*sin(a)+y*cos(a)); }
	friend ostream& operator<<(ostream& os, P p) {
		return os << "(" << p.x << "," << p.y << ")"; }
};
template<class P> bool onSegment(P s, P e, P p) {
	return p.cross(s, e) == 0 && (s - p).dot(e - p) <= 0;
}

template<class P> vector<P> segInter(P a, P b, P c, P d) {
	auto oa = c.cross(d, a), ob = c.cross(d, b),
	     oc = a.cross(b, c), od = a.cross(b, d);
	// Checks if intersection is single non-endpoint point.
	if (sgn(oa) * sgn(ob) < 0 && sgn(oc) * sgn(od) < 0)
		return {(a * ob - b * oa) / (ob - oa)};
	set<P> s;
	if (onSegment(c, d, a)) s.insert(a);
	if (onSegment(c, d, b)) s.insert(b);
	if (onSegment(a, b, c)) s.insert(c);
	if (onSegment(a, b, d)) s.insert(d);
	return {all(s)};
}

typedef Point<ll> P;

const P d(998244353,2000000001),orig(0,0);

template<class P>
int sideOf(P s, P e, P p) { return sgn(s.cross(e, p)); }

bool half(P x) {return d.cross(x)>0;}

bool cm(P a, P b){
	bool A = half(a), B = half(b);
	return A == B ? a.cross(b) > 0 : A<B;
}
bool cmp(pair<P, pii> a, pair<P, pii> b){
	return cm(a.first, b.first);
}

vector< pair<P, pii> > V;

void insert(P A, P B, int a){
	bool ha = half(A), hb = half(B);
	if(ha == hb){
		if(A.cross(B) < 0) swap(A,B);
	}else{
		int ch = segInter(orig, d, A, B).size();
		if(ha > hb) swap(A,B);
		if(!ch) swap(A,B);
	}
	//cout<<1<<' '<<A<<endl;

	//cout<<-1<<' '<<B<<endl;
	V.push_back(make_pair(A,make_pair(a,1)));
	V.push_back(make_pair(B,make_pair(a,-1)));
}

int solve(){
	V.clear();
	P A,B,C,D,E,F;
	int x,y;
	cin>>x>>y;A.x = x;A.y = y;
	cin>>x>>y;B.x = x;B.y = y;
	cin>>x>>y;C.x = x;C.y = y;
	cin>>x>>y;D.x = x;D.y = y;
	cin>>x>>y;E.x = x;E.y = y;
	cin>>x>>y;F.x = x;F.y = y;
	if(segInter(A,B,C,D).size() == 0 && segInter(A,B,E,F).size() == 0){
		return 0;
	}
	
	insert(C-A, D-A, 0);
	insert(E-A, F-A, 0);
	insert(C-B, D-B, 1);
	insert(E-B, F-B, 1);

	sort(all(V), cmp);
	int cnt[2] = {0,0};

	if(segInter(A,A-d,C,D).size() != 0) cnt[0]+=1;
	if(segInter(A,A-d,E,F).size() != 0) cnt[0]+=1;
	if(segInter(B,B-d,C,D).size() != 0) cnt[1]+=1;
	if(segInter(B,B-d,E,F).size() != 0) cnt[1]+=1;

		//cout<<cnt[0]<<' '<<cnt[1]<<endl;
	if(!cnt[0] && !cnt[1]) return 1;
	int n = V.size();
	for(int i=0;i<n;i++){
		//cout<<V[i].first<<endl;
		//cout<<cnt[0]<<' '<<cnt[1]<<endl;
		pii c = V[i].second;
		cnt[c.first]+=c.second;
		if(V[(i+1)%n].first.cross(V[i].first) == 0 && V[(i+1)%n].first.dot(V[i].first) > 0) continue;
		if(!cnt[0] && !cnt[1]) return 1;
	}
	return 2;
}

int main() {
	cin.tie(0)->sync_with_stdio(0);
	cin.exceptions(cin.failbit);
	int T;
	cin>>T;
	while(T--){
		cout<<solve()<<'\n';
	}
}