package main

import (
	"bufio"
	"fmt"
	"os"
)

type Point struct {
	x, y int64
}

func min(a, b int64) int64 {
	if a < b {
		return a
	}
	return b
}

func max(a, b int64) int64 {
	if a > b {
		return a
	}
	return b
}

func onSeg(P, V, A Point) bool {
	cross := (A.x-V.x)*(P.y-V.y) - (A.y-V.y)*(P.x-V.x)
	if cross != 0 {
		return false
	}
	if P.x < min(V.x, A.x) || P.x > max(V.x, A.x) {
		return false
	}
	if P.y < min(V.y, A.y) || P.y > max(V.y, A.y) {
		return false
	}
	return true
}

func checkProp(P, V, A Point) bool {
	vp2 := (P.x-V.x)*(P.x-V.x) + (P.y-V.y)*(P.y-V.y)
	va2 := (A.x-V.x)*(A.x-V.x) + (A.y-V.y)*(A.y-V.y)
	if 25*vp2 >= va2 && 25*vp2 <= 16*va2 {
		return true
	}
	return false
}

func main() {
	in := bufio.NewReader(os.Stdin)
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	var t int
	if _, err := fmt.Fscan(in, &t); err != nil {
		return
	}

	for tc := 0; tc < t; tc++ {
		segs := make([][2]Point, 3)
		for i := 0; i < 3; i++ {
			fmt.Fscan(in, &segs[i][0].x, &segs[i][0].y, &segs[i][1].x, &segs[i][1].y)
		}

		found := false
		for i := 0; i < 3 && !found; i++ {
			s3 := segs[i]
			s1 := segs[(i+1)%3]
			s2 := segs[(i+2)%3]

			for j := 0; j < 2 && !found; j++ {
				for k := 0; k < 2 && !found; k++ {
					V1 := s1[j]
					A := s1[1-j]
					V2 := s2[k]
					B := s2[1-k]

					if V1.x == V2.x && V1.y == V2.y {
						V := V1
						dx1, dy1 := A.x-V.x, A.y-V.y
						dx2, dy2 := B.x-V.x, B.y-V.y
						cross := dx1*dy2 - dy1*dx2
						dot := dx1*dx2 + dy1*dy2

						if cross != 0 && dot >= 0 {
							P := s3[0]
							Q := s3[1]

							valid := false
							if onSeg(P, V, A) && onSeg(Q, V, B) && checkProp(P, V, A) && checkProp(Q, V, B) {
								valid = true
							} else if onSeg(Q, V, A) && onSeg(P, V, B) && checkProp(Q, V, A) && checkProp(P, V, B) {
								valid = true
							}

							if valid {
								fmt.Fprintln(out, "YES")
								found = true
							}
						}
					}
				}
			}
		}
		if !found {
			fmt.Fprintln(out, "NO")
		}
	}
}