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

#define EPS (1e-10)
#define equals(a, b) (fabs((a) - (b)) < EPS)

class Point {
    public:
    double x, y;
    
    Point(double x = 0, double y = 0): x(x), y(y) {}

    Point operator + (Point p) { return Point(x + p.x, y + p.y); }
    Point operator - (Point p) { return Point(x - p.x, y - p.y); }
    Point operator * (double a) { return Point(a * x, a * y); }
    Point operator / (double a) { return Point(x / a, y / a); }

    double abs() {
        return sqrt(norm());
    }
    double norm() {
        return x * x + y * 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;
    }
};

typedef Point Vector;

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;

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

typedef vector<Point> Polygon;

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

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

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

bool isOrthogonal(Vector a, Vector b) {
    return equals(cross(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);
}

Point project(Segment s, Point p) {
    Vector base = s.p2 - s.p1;
    double r = dot(p - s.p1, base) / base.norm();
    return s.p1 + base * r;
}

Point reflect(Segment s, Point p) {
    Point projection = project(s, p);
    Vector toReflection = (projection - p) * 2.0;
    return p + toReflection; 
}

int ccw(Point p0, Point p1, Point p2) {
    Vector v1 = p1 - p0;
    Vector v2 = p2 - p0;

    // 反時計
    if (cross(v1, v2) > 0.0) return 1;
    // 時計
    if (cross(v1, v2) < 0.0) return -1;

    // p1, p2 が逆方向
    if (dot(v1, v2) < 0.0) return 2;

    // p1, p2 が同方向
    if (v1.abs() < v2.abs()) return -2;
    return 0;
}

bool intersect(Segment s1, Segment s2) {
    return (ccw(s1.p1, s1.p2, s2.p1) * ccw(s1.p1, s1.p2, s2.p2) <= 0
            && ccw(s2.p1, s2.p2, s1.p1) * ccw(s2.p1, s2.p2, s1.p2) <= 0);
}

double getDistanceLP(Line l, Point p) {
    return abs(cross(l.p2 - l.p1, p - l.p1)) / (l.p2 - l.p1).abs();
}

double getDistanceSP(Segment s, Point p) {
    if (dot(s.p2 - s.p1, p - s.p1) < 0) return (p - s.p1).abs();
    if (dot(s.p1 - s.p2, p) < 0) return (s.p2 - p).abs();

    return getDistanceLP(s, p);
}

double getDistanceSS(Segment s1, Segment s2) {
    if (intersect(s1, s2)) {
        return 0.0;
    }

    return min(
        min(getDistanceSP(s1, s2.p1), getDistanceSP(s1, s2.p2)),
        min(getDistanceSP(s2, s1.p1), getDistanceSP(s2, s1.p2))
    );
}

double getDistancePP(Point p1, Point p2) {
    return (p2 - p1).abs();
}

int main() {
    /*
    cout << fixed << setprecision(11);

    double x1, y1, x2, y2;
    cin >> x1 >> y1 >> x2 >> y2;
    Point p1 = {x1, y1};
    Point p2 = {x2, y2};
    Segment s1 = {p1, p2};

    double x3, y3, x4, y4;
    cin >> x3 >> y3 >> x4 >> y4;
    Point p3 = {x3, y3};
    Point p4 = {x4, y4};
    Segment s2 = {p3, p4};

    double dist = distanceBetweenSegments(s1, s2);
    */

    int q;
    cin >> q;
    double x0, y0, x1, y1, x2, y2, x3, y3;
    for (int i = 0; i < q; i++) {
        cin >> x0 >> y0 >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
        Point p0 = {x0, y0};
        Point p1 = {x1, y1};
        Point p2 = {x2, y2};
        Point p3 = {x3, y3};
        Segment s1 = {p0, p1};
        Segment s2 = {p2, p3};

        if (intersect(s1, s2)) {
            cout << "1" << endl;
        } else {
            cout << "0" << endl;
        }
    }

    return 0;
}



Measured memory_bytes: 3220