using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Numerics;
using System.Runtime.CompilerServices;
using System.Text;
using static System.Convert;
using static System.Math;
using static Extensions;
using static MathExtensions;

public static class Program
{
    public static void Solve()
    {
        void Yes() => Console.WriteLine("YES");
        void No() => Console.WriteLine("NO");
        var n = I;
        Repeat(n, () =>
        {
            var (b1, b2, b3, a1, a2, a3) = (I, I, I, I, I, I);
            if (IsKado(b1, b2, b3)) { Yes(); return; }
            if (b1 == b2 && b2 == b3)
            {
                if (a1 > a2 && a2 > a3 || a1 < a2 && a2 < a3) { Yes(); return; }
                else { No(); return; }
            }
            if (b1 == b3 && a1 != a3) { Yes(); return; }

            var cross12 = a1 != a2;
            var (x12, y12) = GetIntersection(a1, b1, a2, b2);
            if (cross12) cross12 &= x12 >= 0;

            var cross23 = a2 != a3;
            var (x23, y23) = GetIntersection(a2, b2, a3, b3);
            if (cross23) cross23 &= x23 >= 0;

            if (!cross12 && !cross23) { No(); return; }
            else if (cross12 && cross23 && x12 == x23 && y12 == y23) { No(); return; }
            else { Yes(); return; }
        });
    }

    #region Scanners
    static TextScanner _ts;
    static char C => char.Parse(_ts.Next());
    static string S => _ts.Next();
    static int I => int.Parse(_ts.Next());
    static long L => long.Parse(_ts.Next());
    static BigInteger B => BigInteger.Parse(_ts.Next());
    static double D => double.Parse(_ts.Next());
    static decimal M => decimal.Parse(_ts.Next());
    #endregion

    public static void Main()
    {
        var sw = new StreamWriter(Console.OpenStandardOutput());
        sw.NewLine = "\n";
#if DEBUG
        sw.AutoFlush = true;
#else
        sw.AutoFlush = false;
#endif
        Console.SetOut(sw);
        _ts = new TextScanner(Console.In);
        Solve();
        Console.Out.Flush();
    }
}

public static partial class Extensions
{
    public static bool IsKado(int a, int b, int c)
    {
        var c1 = a != b && b != c && c != a;
        var c2 = b < a && b < c || b > a && b > c;
        return c1 && c2;
    }

    public static (BigRational, BigRational) GetIntersection
        (BigRational a1, BigRational b1, BigRational a2, BigRational b2)
    {
        if (a1 == a2) return default((BigRational, BigRational));
        return ((b2 - b1) / (a1 - a2), (a1 * b2 - b1 * a2) / (a1 - a2));
    }
}

#region Library
#pragma warning disable
public class TextScanner
{
    private readonly TextReader _tr;

    public TextScanner(TextReader tr)
    {
        _tr = tr;
    }

    public string Next()
    {
        var sb = new StringBuilder();
        int i;
        do
        {
            i = _tr.Read();
            if (i == -1) throw new EndOfStreamException();
        }
        while (char.IsWhiteSpace((char)i));
        while (i != -1 && !char.IsWhiteSpace((char)i))
        {
            sb.Append((char)i);
            i = _tr.Read();
        }
        return sb.ToString();
    }
}

public struct BigRational : IComparable<BigRational>, IEquatable<BigRational>
{
    public BigRational(BigInteger numer, BigInteger denom)
    {
        if (denom == 0) throw new ArgumentException();
        this.Numer = numer;
        this.Denom = denom;
        this.Reduce();
    }

    public BigRational(BigRational numer, BigRational denom)
    {
        this = numer / denom;
    }

    public BigInteger Numer { get; private set; }

    public BigInteger Denom { get; private set; }

    private void Reduce()
    {
        if (this.Numer == 0) { this.Denom = 1; return; }
        var gcd = Gcd(this.Numer, this.Denom);
        this.Numer /= gcd; this.Denom /= gcd;
        if (this.Denom < 0) { this.Numer *= -1; this.Denom *= -1; }
    }

    public BigRational Invert()
    {
        if (this.Numer == 0) throw new InvalidOperationException();
        return new BigRational(this.Denom, this.Numer);
    }

    public static BigRational operator -(BigRational value)
        => new BigRational(-value.Numer, value.Denom);

    public static BigRational operator +(BigRational left, BigRational right)
    {
        var d = Lcm(left.Denom, right.Denom);
        var n = left.Numer * (d / left.Denom) + right.Numer * (d / right.Denom);
        return new BigRational(n, d);
    }

    public static BigRational operator *(BigRational left, BigRational right)
    {
        var n = left.Numer * right.Numer;
        var d = left.Denom * right.Denom;
        return new BigRational(n, d);
    }

    public static BigRational operator -(BigRational left, BigRational right)
        => left + -right;

    public static BigRational operator /(BigRational left, BigRational right)
        => left * right.Invert();

    public static BigRational operator %(BigRational left, BigRational right)
        => left - (BigInteger)(left / right) * right;

    public static bool operator ==(BigRational left, BigRational right)
        => left.Equals(right);

    public static bool operator !=(BigRational left, BigRational right)
        => !left.Equals(right);

    public static bool operator <(BigRational left, BigRational right)
        => left.CompareTo(right) < 0;

    public static bool operator >(BigRational left, BigRational right)
        => left.CompareTo(right) > 0;

    public static bool operator <=(BigRational left, BigRational right)
        => left.CompareTo(right) <= 0;

    public static bool operator >=(BigRational left, BigRational right)
        => left.CompareTo(right) >= 0;

    public static implicit operator BigRational(int value)
        => new BigRational(value, 1);

    public static implicit operator BigRational(long value)
        => new BigRational(value, 1);

    public static implicit operator BigRational(BigInteger value)
        => new BigRational(value, 1);

    public static explicit operator BigInteger(BigRational value)
        => value.Numer / value.Denom;

    public static explicit operator double(BigRational value)
        => (double)value.Numer / (double)value.Denom;

    public int CompareTo(BigRational other)
        => (this - other).Numer.CompareTo(0);

    public bool Equals(BigRational other)
    {
        if (other.Numer == 0) return this.Numer == 0; // hotfix
        var r = this / other;
        return r.Numer == r.Denom;
    }

    public override bool Equals(object obj)
        => obj is BigRational ? this.Equals((BigRational)obj) : false;

    public override int GetHashCode()
        => this.Numer.GetHashCode() ^ this.Denom.GetHashCode();

    public override string ToString()
        => $"{this.Numer}/{this.Denom}";
}

[DebuggerStepThrough]
public static partial class Extensions
{
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void Assert(bool condition)
    {
        if (!condition) throw new Exception("Assertion failed");
    }

    public static string AsString(this IEnumerable<char> source) => new string(source.ToArray());

    public static Dictionary<T, int> Bucket<T>(this IEnumerable<T> source) where T : IEquatable<T>
    {
        var dict = new Dictionary<T, int>();
        foreach (var item in source) if (dict.ContainsKey(item)) dict[item]++; else dict[item] = 1;
        return dict;
    }

    public static int[] Bucket<T>(this IEnumerable<T> source, int maxValue, Func<T, int> selector)
    {
        var arr = new int[maxValue + 1];
        foreach (var item in source) arr[selector(item)]++;
        return arr;
    }

    public static IEnumerable<int> CumSum(this IEnumerable<int> source)
    {
        var sum = 0;
        foreach (var item in source) yield return sum += item;
    }

    public static IEnumerable<long> CumSum(this IEnumerable<long> source)
    {
        var sum = 0L;
        foreach (var item in source) yield return sum += item;
    }

    public static void Exit(int exitCode)
    {
        Console.Out.Flush();
        Environment.Exit(exitCode);
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void ForEach<T>(this IEnumerable<T> source, Action<T> action)
    {
        foreach (var item in source) action(item);
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void ForEach<T, _>(this IEnumerable<T> source, Func<T, _> func)
    {
        foreach (var item in source) func(item);
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void ForEach<T>(this IEnumerable<T> source, Action<T, int> action)
    {
        var i = 0;
        foreach (var item in source) action(item, i++);
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void ForEach<T, _>(this IEnumerable<T> source, Func<T, int, _> func)
    {
        var i = 0;
        foreach (var item in source) func(item, i++);
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void Repeat(int count, Action action)
    {
        for (var i = 0; i < count; i++) action();
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void Repeat(int count, Action<int> action)
    {
        for (var i = 0; i < count; i++) action(i);
    }

    public static IEnumerable<T> Repeat<T>(int count, Func<T> func)
    {
        for (var i = 0; i < count; i++) yield return func();
    }

    public static IEnumerable<T> Repeat<T>(int count, Func<int, T> func)
    {
        for (var i = 0; i < count; i++) yield return func(i);
    }

    public static void Swap<T>(ref T x, ref T y)
    {
        var tmp = x; x = y; y = tmp;
    }

    public static (T1[], T2[]) Unzip<T1, T2>(this ICollection<(T1, T2)> source)
    {
        var ts1 = new T1[source.Count];
        var ts2 = new T2[source.Count];
        var i = 0;
        foreach (var (t1, t2) in source) { ts1[i] = t1; ts2[i] = t2; i++; }
        return (ts1, ts2);
    }

    public static (T1[], T2[], T3[]) Unzip<T1, T2, T3>(this ICollection<(T1, T2, T3)> source)
    {
        var ts1 = new T1[source.Count];
        var ts2 = new T2[source.Count];
        var ts3 = new T3[source.Count];
        var i = 0;
        foreach (var (t1, t2, t3) in source) { ts1[i] = t1; ts2[i] = t2; ts3[i] = t3; i++; }
        return (ts1, ts2, ts3);
    }

    public static (T1[], T2[], T3[], T4[]) Unzip<T1, T2, T3, T4>(this ICollection<(T1, T2, T3, T4)> source)
    {
        var ts1 = new T1[source.Count];
        var ts2 = new T2[source.Count];
        var ts3 = new T3[source.Count];
        var ts4 = new T4[source.Count];
        var i = 0;
        foreach (var (t1, t2, t3, t4) in source) { ts1[i] = t1; ts2[i] = t2; ts3[i] = t3; ts4[i] = t4; i++; }
        return (ts1, ts2, ts3, ts4);
    }

    public static IEnumerable<T> Zip<T1, T2, T3, T>(this IEnumerable<T1> first, IEnumerable<T2> second, IEnumerable<T3> thrid, Func<T1, T2, T3, T> resultSelector)
    {
        using (var e1 = first.GetEnumerator())
        using (var e2 = second.GetEnumerator())
        using (var e3 = thrid.GetEnumerator())
        {
            while (e1.MoveNext() && e2.MoveNext() && e3.MoveNext())
                yield return resultSelector(e1.Current, e2.Current, e3.Current);
        }
    }

    public static IEnumerable<T> Zip<T1, T2, T3, T4, T>(this IEnumerable<T1> first, IEnumerable<T2> second, IEnumerable<T3> thrid, IEnumerable<T4> fourth, Func<T1, T2, T3, T4, T> resultSelector)
    {
        using (var e1 = first.GetEnumerator())
        using (var e2 = second.GetEnumerator())
        using (var e3 = thrid.GetEnumerator())
        using (var e4 = fourth.GetEnumerator())
        {
            while (e1.MoveNext() && e2.MoveNext() && e3.MoveNext() && e4.MoveNext())
                yield return resultSelector(e1.Current, e2.Current, e3.Current, e4.Current);
        }
    }
}

[DebuggerStepThrough]
public static class MathExtensions
{
    public static int DivCeil(int left, int right)
        => left / right + (left % right == 0 ? 0 : 1);

    public static long DivCeil(long left, long right)
        => left / right + (left % right == 0L ? 0L : 1L);

    public static int Gcd(int left, int right)
    {
        int r;
        while ((r = left % right) != 0) { left = right; right = r; }
        return right;
    }

    public static long Gcd(long left, long right)
    {
        long r;
        while ((r = left % right) != 0L) { left = right; right = r; }
        return right;
    }

    public static BigInteger Gcd(BigInteger left, BigInteger right)
        => BigInteger.GreatestCommonDivisor(left, right);

    public static int HighestOneBit(int x)
    {
        x |= x >> 01;
        x |= x >> 02;
        x |= x >> 04;
        x |= x >> 08;
        x |= x >> 16;
        return x - (x >> 1);
    }

    public static long HighestOneBit(long x)
    {
        x |= x >> 01;
        x |= x >> 02;
        x |= x >> 04;
        x |= x >> 08;
        x |= x >> 16;
        x |= x >> 32;
        return x - (x >> 1);
    }

    public static int Lcm(int left, int right) => left / Gcd(left, right) * right;

    public static long Lcm(long left, long right) => left / Gcd(left, right) * right;

    public static BigInteger Lcm(BigInteger left, BigInteger right)
        => left / Gcd(left, right) * right;

    public static int Pow(int value, int exponent)
    {
        var r = 1;
        while (exponent > 0)
        {
            if ((exponent & 1) == 1) r *= value;
            value *= value;
            exponent >>= 1;
        }
        return r;
    }

    public static long Pow(long value, int exponent)
    {
        var r = 1L;
        while (exponent > 0)
        {
            if ((exponent & 1) == 1) r *= value;
            value *= value;
            exponent >>= 1;
        }
        return r;
    }

    public static long Fact(int value)
    {
        var r = 1L;
        for (var i = 2; i <= value; i++) r *= i;
        return r;
    }
}
#pragma warning restore
#endregion