#include<iostream>
#include<iomanip>
#include<cmath>
#include<vector>
#include<algorithm>

using namespace std;

const double EPS = 1e-10;
bool equals(double a, double b){ return (fabs(a) - fabs(b)) < EPS;};

static const int COUNTER_CLOCKWISE = 1;
static const int CLOCKWISE = -1;
static const int ONLINE_BACK = 2;
static const int ONLINE_FRONT = -2;
static const int ON_SEGMENT = 0;

class Point{
public:
	double x, y;
	
	Point(double x = 0, double y = 0): x(x), y(y) {}
	Point(const Point &p) { x = p.x; y = p.y;};
	
	Point operator + (const Point &p) { return Point(x + p.x, y + p.y); }
	Point operator - (const Point &p) { return Point(x - p.x, y - p.y); }
	Point operator * (const double &a) { return Point(x * a, y * a); }
	Point operator / (const double &a) { return Point(x / a, y / a); }
	
	Point & operator = (const Point& p) {x = p.x; y = p.y; return *this;};
	Point & operator += (const Point& p) {x += p.x; y += p.y; return *this;};
	Point & operator -= (const Point& p) {x -= p.x; y -= p.y; return *this;};
	Point & operator *= (const Point& p) {x *= p.x; y *= p.y; return *this;};
	Point & operator /= (const Point& p) {x /= p.x; y /= p.y; return *this;};
	
	bool operator < (const Point &p) const {
		return x != p.x ? x < p.x : y < p.y;
	}
	
	bool operator > (const Point &p) const {
		return x != p.x ? x > p.x : y > p.y;
	}
	
	bool operator == (const Point &p) const {
		return fabs(x - p.x) < EPS && fabs(y - p.y) < EPS;
	}
	
	double abs() { return sqrt(norm()); };
	double norm() { return x * x + y * y;};
};

typedef Point Vector;


double norm(Vector a){
	return a.x * a.x + a.y * a.y;
}

double abs(Vector a){
	return sqrt(norm(a));
}

double dot(Vector a, Vector b){
	return a.x * b.x + a.y * b.y;
}

double cross(Vector a, Vector b){
	return a.x * b.y - a.y * b.x;
}

struct Segment{
	Point p1, p2;
};

typedef Segment Line;




bool isOrthogonal(Vector a, Vector b){
	return equals(dot(a,b), 0.0);
}

bool isOrthogonal(Point a1, Point a2, Point b1, Point b2){
	return isOrthogonal(a1 - a2, b1 - b2);
}

bool isOrthogonal(Segment s1, Segment s2){
	return equals(dot(s1.p2 - s1.p1, s2.p2 - s2.p1), 0.0);
}


bool isParallel(Vector a, Vector b){
	return equals(cross(a, b), 0.0);
}

bool isParallel(Point a1, Point a2, Point b1, Point b2){
	return isParallel(a1 - a2, b1 - b2);
}

bool isPrallel(Segment s1, Segment s2){
	return equals(cross(s1.p2 - s1.p1, s2.p2 - s2.p1), 0.0);
}


int ccw(Point p0, Point p1, Point p2){
	Vector a = p1 - p0;
	Vector b = p2 - p0;
	if(cross(a, b) > EPS) return COUNTER_CLOCKWISE;
	if(cross(a, b) < -EPS) return CLOCKWISE;
	if(dot(a, b) < - EPS) return ONLINE_BACK;
	if(a.norm() < b.norm()) return ONLINE_FRONT;
	
	return ON_SEGMENT;
}

bool intersect(Point p1, Point p2, Point p3, Point p4){
	return (ccw(p1, p2, p3) * ccw(p1, p2, p4) <= 0 && ccw(p3, p4, p1) * ccw(p3, p4, p2) <= 0);
}

bool intersect(Segment s1, Segment s2){
	return intersect(s1.p1, s1.p2, s2.p1, s2.p2);
}

class Circle {
public:
	Point c;
	double r;
	Circle(Point c = Point(), double r = 0.0): c(c), r(r) {}
};

typedef vector<Point> Polygon;

signed main(){
	cin.tie(0);
	ios::sync_with_stdio(false);
	cout<<fixed<<setprecision(10);
	
	int q;
	
	cin>>q;
	
	for(int i = 0; i < q; i++){
		Segment s1, s2;
		cin>>s1.p1.x>>s1.p1.y>>s1.p2.x>>s1.p2.y;
		cin>>s2.p1.x>>s2.p1.y>>s2.p2.x>>s2.p2.y;
		
		cout<<intersect(s1, s2)<<endl;
	}
	
	
	return 0;
}


Measured memory_bytes: 3260