#define _USE_MATH_DEFINES
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<climits>
#include<string>
#include<vector>
#include<list>
#include<map>
#include<set>
#include<cmath>
#include<queue>
#include<cstring>
#include<stack>
using namespace std;
#define EPS 1e-8
#define INF 1e10

#define COUNTER_CLOCKWISE +1
#define CLOCKWISE -1
#define C_A_B +2
#define A_B_C -2
#define A_C_B 0
 
struct Point{
    double x, y;

    Point(){}

    Point(double _x, double _y)
	{
        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 d) const
	{
        return Point(x*d,y*d);
    }
    bool operator < (const Point &p) const
	{
        if(x==p.x) return y < p.y;
        return x < p.x;
    }
	bool operator == (const Point &p) const
	{
		return abs(x - p.x) < EPS && abs(y - p.y) < EPS;
	}
    double Norm()
	{
        return x*x + y*y;
    }
	bool Input()
	{
		if(cin >> x >> y) return true;
		return false;
	}
};

struct Line{
    Point a, b;

    Line(){}

    Line(Point _a, Point _b)
	{
        a = _a; b = _b;
    }
	bool Input()
	{
		if( a.Input() && b.Input() ) return true;
		return false;
	}
};

struct Circle{
    Point c;
    double r;

    Circle(){}

    Circle(Point _c, double _r)
	{
        c = _c; r = _r;
    }
};

typedef Point Vector;
typedef vector<Point> Polygon;
typedef Line Segment;

double Dot(Vector p, Vector q)
{
    return p.x*q.x + p.y*q.y;
}

double Cross(Vector p, Vector q)
{
    return p.x*q.y - q.x*p.y;
}

int CCW(Point a, Point b, Point c){ //a,b,c,?????¨?????°??????
	Vector v1 = b-a;
	Vector v2 = c-a;
    if(Cross(v1, v2) > EPS) return +1; //a->b->c ??????????¨???????
    if(Cross(v1, v2) <- EPS) return -1; //a->b->c ???????¨???????
	if(Dot(v1, v2) <- EPS) return +2; //c???a-b???????????? c<-a->b
	if(v2.Norm() - v1.Norm() > EPS) return -2; //c???a-b????????? a->b->c
    return 0; //c???a-b??? a->c->b
}

Point GetProject(Segment s, Point p){
	Vector v1 = s.b - s.a;
	Vector v2 = p - s.a;
	double r = Dot(v1,v2)/v1.Norm();
	return s.a + v1*r;
}

Point GetReflect(Segment s, Point p){
	return p + (GetProject(s, p) - p)*2.0;
}

bool IntersectsSS(Segment l, Segment m){
	return CCW(l.a, l.b, m.a)*CCW(l.a, l.b, m.b) <= 0 && CCW(m.a, m.b, l.a)*CCW(m.a, m.b, l.b) <= 0;
}

bool GetIntersectionSS(Segment s, Segment t, Point &p){
    Vector a1, a2, b1, b2;
    a1 = s.b - s.a;
	a2 = t.b - t.a;
    b1 = t.a - s.a;
	b2 = s.a - t.b;
    double s1, s2;
    s1 = Cross(a1, b1)/2;
	s2 = Cross(a1, b2)/2;
    //if(s1 + s2 < EPS) return false; //??????
    p = Point( t.a.x + a2.x*s1/(s1 + s2), t.a.y + a2.y*s1/(s1 + s2) );
    return true;
}

int GetIntersectionLL(Line l, Line m, Point &p){
    if(GetIntersectionSS(l,m,p) == true) return 1;
	return -1; //??????????????????(??????????????????)
}

int GetIntersectionCC(Circle c1, Circle c2, Point &p1, Point &p2){
    double d, a, t;
    d = sqrt( (c2.c - c1.c).Norm() );
	if(abs(c1.c.x - c2.c.x) < EPS && abs(c1.c.y - c2.c.y) < EPS && abs(c1.r - c2.r) < EPS)
		return -1; //2????????????????????£?????????
    if(d < abs(c1.r - c2.r) || c1.r + c2.r < d) return 0; //??¢?????????????????????
    a = acos( (c1.r*c1.r + d*d - c2.r*c2.r)/(2*c1.r*d) );
    t = atan2(c2.c.y - c1.c.y, c2.c.x - c1.c.x);
    p1 = Point(c1.c.x + c1.r*cos(t + a),c1.c.y + c1.r*sin(t + a));
    p2 = Point(c1.c.x + c1.r*cos(t - a),c1.c.y + c1.r*sin(t - a));
    if(abs(p1.x - p2.x) < EPS && abs(p1.y - p2.y) < EPS) return 1; //?????????1???
    return 2; //?????????2???
}

//????§???¢???????????????
int ContainsGP(Polygon g, Point p){
	Line l = Line( p, Point(INF, p.y) );
	int cnt = 0, n = g.size();
	for(int i = 0; i < n; i++){
		Vector a = g[i] - p;
		Vector b = g[(i+1)%n] - p;
		if(CCW(g[i],g[(i+1)%n], p) == 0) return 1; //?????????
		if(a.y > b.y) swap(a, b);
		if(a.y <= EPS && EPS < b.y && Cross(a, b) > EPS) cnt++;
	}
	if((cnt&1) == 1) return 2; //??????????????????
	return 0; //?????????????????????
}

Polygon AndrewScan(Polygon s){
	if(s.size() <= 2) return s;
	sort(s.begin(), s.end());
	Polygon g;
	for(int i = 0; i < s.size(); i++){
		for(int n = g.size(); n >= 2 && CCW(g[n-2], g[n-1], s[i]) != -1; n--){
			g.pop_back();
		}
		g.push_back(s[i]);
	}
	int upper_n = g.size();
	for(int i = s.size()-2; i >= 0;i--){
		for(int n = g.size(); n > upper_n && CCW(g[n-2], g[n-1], s[i]) != -1; n--){
			g.pop_back();
		}
		g.push_back(s[i]);
	}
	reverse(g.begin(), g.end());
	g.pop_back();
	return g;
}

int main(){
	int N;
	cin >> N;
	for(int i = 0; i < N; i++)
	{
		Segment l, m;
		l.a.Input();
		l.b.Input();
		m.a.Input();
		m.b.Input();
		printf("%d\n", IntersectsSS(l, m) );
	}
}

Measured memory_bytes: 1212