/************************************************

* Author        :Running_Time

* Created Time  :2015/10/23 星期五 17:00:08

* File Name     :POJ_3304.cpp

 ************************************************/

#include <cstdio>

#include <algorithm>

#include <iostream>

#include <sstream>

#include <cstring>

#include <cmath>

#include <string>

#include <vector>

#include <queue>

#include <deque>

#include <stack>

#include <list>

#include <map>

#include <set>

#include <bitset>

#include <cstdlib>

#include <ctime>

using namespace std;

#define lson l, mid, rt << 1

#define rson mid + 1, r, rt << 1 | 1

typedef long long ll;

const int N = 1e2 + 10;

const int INF = 0x3f3f3f3f;

const int MOD = 1e9 + 7;

const double EPS = 1e-8;

struct Point    {       //点的定义

    double x, y;

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

};

typedef Point Vector;       //向量的定义

Point read_point(void)   {      //点的读入

    double x, y;

    scanf ("%lf%lf", &x, &y);

    return Point (x, y);

}

double polar_angle(Vector A)  {     //向量极角

    return atan2 (A.y, A.x);

}

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;

}

int dcmp(double x)  {       //三态函数，减少精度问题

    if (fabs (x) < EPS) return 0;

    else    return x < 0 ? -1 : 1;

}

Vector operator + (Vector A, Vector B)  {       //向量加法

    return Vector (A.x + B.x, A.y + B.y);

}

Vector operator - (Vector A, Vector B)  {       //向量减法

    return Vector (A.x - B.x, A.y - B.y);

}

Vector operator * (Vector A, double p)  {       //向量乘以标量

    return Vector (A.x * p, A.y * p);

}

Vector operator / (Vector A, double p)  {       //向量除以标量

    return Vector (A.x / p, A.y / p);

}

bool operator < (const Point &a, const Point &b)    {       //点的坐标排序

    return a.x < b.x || (a.x == b.x && a.y < b.y);

}

bool operator == (const Point &a, const Point &b)   {       //判断同一个点

    return dcmp (a.x - b.x) == 0 && dcmp (a.y - b.y) == 0;

}

double length(Vector A) {       //向量长度，点积

    return sqrt (dot (A, A));

}

double angle(Vector A, Vector B)    {       //向量转角，逆时针，点积

    return acos (dot (A, B) / length (A) / length (B));

}

double area_triangle(Point a, Point b, Point c) {       //三角形面积，叉积

    return fabs (cross (b - a, c - a)) / 2.0;

}

Vector rotate(Vector A, double rad) {       //向量旋转，逆时针

    return Vector (A.x * cos (rad) - A.y * sin (rad), A.x * sin (rad) + A.y * cos (rad));

}

Vector nomal(Vector A)  {       //向量的单位法向量

    double len = length (A);

    return Vector (-A.y / len, A.x / len);

}

Point point_inter(Point p, Vector V, Point q, Vector W)    {        //两直线交点，参数方程

    Vector U = p - q;

    double t = cross (W, U) / cross (V, W);

    return p + V * t;

}

double dis_to_line(Point p, Point a, Point b)   {       //点到直线的距离，两点式

    Vector V1 = b - a, V2 = p - a;

    return fabs (cross (V1, V2)) / length (V1);

}

double dis_to_seg(Point p, Point a, Point b)    {       //点到线段的距离，两点式

    if (a == b) return length (p - a);

    Vector V1 = b - a, V2 = p - a, V3 = p - b;

    if (dcmp (dot (V1, V2)) < 0)    return length (V2);

    else if (dcmp (dot (V1, V3)) > 0)   return length (V3);

    else    return fabs (cross (V1, V2)) / length (V1);

}

Point point_proj(Point p, Point a, Point b)   {     //点在直线上的投影，两点式

    Vector V = b - a;

    return a + V * (dot (V, p - a) / dot (V, V));

}

bool inter(Point a1, Point a2, Point b1, Point b2)  {       //判断线段相交，两点式

    double c1 = cross (a2 - a1, b1 - a1), c2 = cross (a2 - a1, b2 - a1),

           c3 = cross (b2 - b1, a1 - b1), c4 = cross (b2 - b1, a2 - b1);

    return dcmp (c1) * dcmp (c2) < 0 && dcmp (c3) * dcmp (c4) < 0;

}

bool on_seg(Point p, Point a1, Point a2)    {       //判断点在线段上，两点式

    return dcmp (cross (a1 - p, a2 - p)) == 0 && dcmp (dot (a1 - p, a2 - p)) < 0;

}

double area_poly(Point *p, int n)   {       //多边形面积

    double ret = 0;

    for (int i=1; i<n-1; ++i)   {

        ret += fabs (cross (p[i] - p[0], p[i+1] - p[0]));

    }

    return ret / 2;

}

/*

    点集凸包，输入点集会被修改

*/

vector<Point> convex_hull(vector<Point> &P) {

    sort (P.begin (), P.end ());

    P.erase (unique (P.begin (), P.end ()), P.end ());      //预处理，删除重复点

    int n = P.size (), m = 0;

    vector<Point> ret (n + 1);

    for (int i=0; i<n; ++i) {

        while (m > 1 && cross (ret[m-1]-ret[m-2], P[i]-ret[m-2]) < 0)   m--;

        ret[m++] = P[i];

    }

    int k = m;

    for (int i=n-2; i>=0; --i)  {

        while (m > k && cross (ret[m-1]-ret[m-2], P[i]-ret[m-2]) < 0)   m--;

        ret[m++] = P[i];

    }

    if (n > 1)  m--;

    ret.resize (m);

    return ret;

}

struct Line {

    Point s, e;

    Line () {}

    Line (Point s, Point e) : s (s), e (e) {}

};

Line L[N];

int n;

bool judge(Point a, Point b)    {

    if (a == b) return false;

    for (int i=0; i<n; ++i) {

        if (cross (a - L[i].s, b - L[i].s) * cross (a - L[i].e, b - L[i].e) > 0)   return false;

    }

    return true;

}

int main(void)    {

    int T;  scanf ("%d", &T);

    while (T--) {

        scanf ("%d", &n);

        for (int i=0; i<n; ++i) {

            L[i] = Line (read_point (), read_point ());

        }

        if (n == 1) {

            puts ("Yes!");  continue;

        }

        bool flag = false;

        for (int i=0; i<n && !flag; ++i) {

            for (int j=i+1; j<n; ++j)   {

                if (judge (L[i].s, L[j].s) || judge (L[i].s, L[j].e)

                    || judge (L[i].e, L[j].s) || judge (L[i].e, L[j].e))   {

                    flag = true;    break;

                }

            }

        }

        if (flag)   puts ("Yes!");

        else    puts ("No!");

    }

    return 0;

}