Go: package main

import (
        "fmt"
)

func main() {
        var x1, y1, x2, y2, x3, y3, px, py float64
        var oax, oay, obx, oby, opx, opy float64
        var det float64
        var s, t float64

        for {
                _, err := fmt.Scanf("%f %f %f %f %f %f %f %f", &x1, &y1, &x2, &y2, &x3, &y3, &px, &py)
                if err != nil {
                        break
                }
                oax = x2 - x1
                oay = y2 - y1
                obx = x3 - x1
                oby = y3 - y1
                opx = px - x1
                opy = py - y1
                det = oax*oby - obx*oay

                if det == 0 {
                        fmt.Printf("NO\n")
                } else {
                        s = (oby*opx - obx*opy) / det
                        t = (oax*opy - oay*opx) / det

                        if (s+t < 1 && s > 0 && t > 0) {
                                fmt.Printf("YES\n")
                        } else {
                                fmt.Printf("NO\n")
                        }
                }
        }
}

Python: import math

def tri(x1, y1, x2, y2, x3, y3):
    return math.fabs((x2-x1)*(y3-y1) - (y2-y1)*(x3-x1)) / 2

while True:
    try:
        x1, y1, x2, y2, x3, y3, xp, yp = map(float, input().split())
    except:
        break
    abc = tri(x1, y1, x2, y2, x3, y3)
    abp = tri(x1, y1, x2, y2, xp, yp)
    acp = tri(x1, y1, x3, y3, xp, yp)
    bcp = tri(x2, y2, x3, y3, xp, yp)
    x, y = int(abc*pow(10, 5)), int((abp+acp+bcp)*pow(10, 5))
    print("YES" if x >= y else "NO")

Python: while True:
  try:
    x1, y1, x2, y2, x3, y3, xp, yp = map(float, input().split())
  except EOFError:
    break
  vec_b = [x2-x1, y2-y1]
  vec_c = [x3-x1, y3-y1]
  vec_p = [xp-x1, yp-y1]
  a = (vec_p[0]*vec_c[1] - vec_p[1]*vec_c[0]) / (vec_b[0]*vec_c[1] - vec_b[1]*vec_c[0])
  b = (vec_p[0]*vec_b[1] - vec_p[1]*vec_b[0]) / (vec_b[1]*vec_c[0] - vec_b[0]*vec_c[1])
  if ((a > 0) and (b > 0) and (a+b < 1)):
    print("YES")
  else:
    print("NO")

Python: # -*- coding:utf-8 -*-
import sys
import math

def norm(x1,y1,x2,y2):
    r = math.sqrt((x2 - x1)**2 + (y2 - y1)**2)
    return r

def judge(x1,y1,x2,y2,x3,y3,xp,yp):
    r1 = norm(x1,y1,x2,y2)
    r2 = norm(x2,y2,x3,y3)
    r3 = norm(x3,y3,x1,y1)

    d1 = norm(xp,yp,x1,y1)
    d2 = norm(xp,yp,x2,y2)
    d3 = norm(xp,yp,x3,y3)

    if d1 > r1 or d1 > r3:
        print('NO')
    elif d2 > r1 or d2 > r2:
        print('NO')
    elif d3 > r3 or d3 > r2:
        print('NO')
    else:
        print('YES')

array = []
for i in sys.stdin:
    array.append(i)

for i in range(len(array)):
    tmp = array[i]
    x1,y1,x2,y2,x3,y3,xp,yp = map(float,tmp.split(' '))
    judge(x1,y1,x2,y2,x3,y3,xp,yp)

Python: def r(a, b, c, d, e, f):
    return a * (d-f) + c * (f-b) + e * (b-d) > 0

while True:
    try: line = list(map(float, input().split()))
    except: break
    
    x1, y1, x2, y2, x3, y3, xp, yp = line
    abc = r(x1, y1, x2, y2, x3, y3)
    pab = r(xp, yp, x1, y1, x2, y2)
    pbc = r(xp, yp, x2, y2, x3, y3)
    pca = r(xp, yp, x3, y3, x1, y1)

    print('YES' if abc == pab == pbc == pca else 'NO')

Python: while True:
  x1,y1,x2,y2,x3,y3,xp,yp=map(float,input().split())
  if xp<0 or yp<0:
    print('No')
  else:
    print('Yes')

Python: def checker(x1,y1,x2,y2,xp,yp):
	vec = (x2 - x1) * (yp - y1) - (y2 - y1) * (xp - x1)
	if vec > 0:
		return 1
	elif vec < 0:
		return -1

while True:
	try:
		x1,y1,x2,y2,x3,y3,xp,yp = map(float,raw_input().split())
	except EOFError:
		break
	r = checker(x1,y1,x2,y2,xp,yp)
	r += checker(x2, y2, x3, y3, xp, yp)
	r += checker(x3, y3, x1, y1, xp, yp)
	if r == 3 or r == -3:
		print("YES")
	else:
		print("NO")

Python: def r(x1, y1, x2, y2, x3, y3):
    return x1*(y2-y3)+x2*(y3-y1)+x3*(y1-y2) > 0

while True:
    try:
        line = input()
    except:
        break

    x1, y1, x2, y2, x3, y3, xp, yp = map(float, line.strip().split())

    abc = r(x1, y1, x2, y2, x3, y3)
    pab = r(xp, yp, x1, y1, x2, y2)
    pbc = r(xp, yp, x2, y2, x3, y3)
    pca = r(xp, yp, x3, y3, x1, y1)

    print('YES' if abc == pab == pbc == pca else 'NO')

Python: # AOJ 0012 A Point in a Triangle
# Python3 2018.6.17 bal4u

EPS = 0.0001

# a, b, はラインの同一側にあるか
def is_atSameSide(a, b, line):
	sa = (line[1].real-line[0].real)*(a.imag-line[0].imag) \
		 + (line[1].imag-line[0].imag)*(line[0].real-a.real);
	sb = (line[1].real-line[0].real)*(b.imag-line[0].imag) \
		 + (line[1].imag-line[0].imag)*(line[0].real-b.real);
	if -EPS <= sa and sa <= EPS: return False 		 # a in line
	if -EPS <= sb and sb <= EPS: return False 		 # b in line
	if sa*sb >= 0: return True           # a,b at same side
	return False  # -1;
	
while True:
	try: p = list(map(float, input().split()))
	except: break
	
	p1 = complex(p[0], p[1])
	p2 = complex(p[2], p[3])
	p3 = complex(p[4], p[5])
	pp = complex(p[6], p[7])
	if is_atSameSide(p3, pp, [p1,p2]) and \
	   is_atSameSide(p1, pp, [p2,p3]) and \
	   is_atSameSide(p2, pp, [p3,p1]): print('YES')
	else: print('NO')

Python: while 1:
    try:
        x1,y1,x2,y2,x3,y3,xp,yp=map(float,input().split())
        a=((x1-x2)**2+(y1-y2)**2)**0.5
        b=((x2-x3)**2+(y2-y3)**2)**0.5
        c=((x3-x1)**2+(y3-y1)**2)**0.5
        s=(a+b+c)/2
        S=(s*(s-a)*(s-b)*(s-c))**0.5
        d=((x1-xp)**2+(y1-yp)**2)**0.5
        e=((x2-xp)**2+(y2-yp)**2)**0.5
        f=((x3-xp)**2+(y3-yp)**2)**0.5
        sa=(a+d+e)/2
        sb=(b+e+f)/2
        sc=(c+f+d)/2
        Sa=(sa*(sa-a)*(sa-d)*(sa-e))**0.5
        Sb=(sb*(sb-b)*(sb-e)*(sb-f))**0.5
        Sc=(sc*(sc-c)*(sc-f)*(sc-d))**0.5
        Sp=Sa+Sb+Sc
        if abs(S-Sp)<=0.001**2:
            print("YES")
        else:
            print("NO")
    except:break

Python: import sys
def f(h,i,j,k):z=(j-h)*(y-k)-(k-i)*(x-j);return([-1,1][z>0],0)[z==0]
for e in sys.stdin:
 p,q,r,s,t,u,x,y=map(float,e.split())
 print(['NO','YES'][f(p,q,r,s)==f(r,s,t,u)==f(t,u,p,q)])

Python: import math
while True:
    try:
        x1, y1, x2, y2, x3, y3, xp, yp = map(float, input().split())
    except:
        break
    x = [x1, x3, x3, x1]
    y = [y1, y2, y3, y1]
    x = list(map(lambda x: x - xp, x))
    y = list(map(lambda y: y - yp, y))
    s = lambda a1, a2, b1, b2: abs(a1 * b2 - a2 * b1)
    if abs(sum(s(x[i], y[i], x[i + 1], y[i + 1]) for i in range(3)) - s(x[1] - x[0], y[1] - y[0], x[2] - x[0], y[2] - y[0])) < 1e-10:
        print('YES')
    else:
        print('NO')

Python: #!/usr/bin/env python
#-*- coding:utf-8 -*-

import sys
import math

for data in sys.stdin:
    x1, y1, x2, y2, x3, y3, xp, yp = list(map(float, data.split()))

    abV = (x1 - x2, y1 - y2)
    bpV = (x2 - xp, y2 - yp)

    bcV = (x2 - x3, y2 - y3)
    cpV = (x3 - xp, y3 - yp)

    caV = (x3 - x1, y3 - y1)
    apV = (x1 - xp, y1 - yp)

    c1 = abV[0] * bpV[1] - abV[1] * bpV[0]
    c2 = bcV[0] * cpV[1] - bcV[1] * cpV[0]
    c3 = caV[0] * apV[1] - caV[1] * apV[0]

    if (c1 < 0 and c2 < 0 and c3 < 0) or (c1 > 0 and c2 > 0 and c3 > 0):
        print("YES")
    else:
        print("NO")

Python: import sys
def side(p1, p2, p3): return (p3[1]-p1[1])*(p2[0]-p1[0])-(p2[1]-p1[1])*(p3[0]-p1[0])>0
 
for s in sys.stdin:
  x = map(float, raw_input().split())
  p1 = x[0:2]
  p2 = x[2:4]
  p3 = x[4:6]
  p0 = x[6:]
  print ["NO","YES"][(side(p1, p2, p0)==side(p2, p3, p0) and side(p2, p3, p0)==side(p3, p1, p0))]

Python: import sys
def f(h,i,j,k):
 z=(j-h)*(y-k)-(k-i)*(x-j);return([-1,1][z>0],0)[z==0]
for e in sys.stdin:
 p,q,r,s,t,u,x,y=map(float,e.split())
 g=[p,q,r,s,t,u]
 print(['NO','YES'][f(*g[:4])==f(*g[2:6])==f(*g[4:],*g[:2])])