Go: package main
// 三角形の形は辺の長さで決まる． 順番に３つの正整数が与えられたとき， 辺の長さがそれらの値と一致する三角形が存在するかどうかを調べ,
//  存在するなら鋭角三角形，直角三角形，鈍角三角形のいずれかを判定し， 次の入力へ進む． 三角形が存在しないとき， それまでに入力された，
// 三角形，直角三角形，鋭角三角形，鈍角三角形の 個数を空白で区切って出力し， それ以降の入力は無視して終了する
// 入力の中には必ず三角形が存在しないようなものがある と仮定してよい. 入力の行数は判らないが各行には３つの正整数が空白で区切って書かれている．
//  ただし，各整数は100 以下とする.

// return
// 三角形 直角三角形　鈍角三角形 鈍角三角形
import (
	"os"
	"fmt"
	"bufio"
)


var sc = bufio.NewScanner(os.Stdin)

func max(a, b, c int) (int, int, int) {
	if a > b {
		if b > c {
			return a, b, c
		} else {
			return a, c, b
		}
	} else {
		if a > c {
			return b, a, c
		} else {
			return b, c, a
		}
	}
}

func find_trianges(a, b, c int) string {
	a, b, c = max(a, b, c)
	r := b*b + c*c
	if a*a > r {
		return "obtuse_triangle"
	} else if a*a < r {
		return "sharped_triangle"
	} else {
		return "right_triangle"
	}
}

func main() {
	s := bufio.NewScanner(os.Stdin)
	var t, r_t, s_t, o_t int = 0, 0, 0, 0
	for s.Scan() {
		var a, b, c int
		fmt.Sscan(s.Text(), &a, &b, &c)
			a, b, c = max(a, b, c)
			if (a < b + c) {
				r := find_trianges(a, b, c)
				switch r {
				case "right_triangle":
					r_t++
				case "sharped_triangle":
					s_t++
				case "obtuse_triangle":
					r_t++
				}
				t++
			}	else {
				break
			}
			
	}
	fmt.Println(t, r_t, s_t, o_t)
}

Python: import math

flag = 0
ans = [0] * 4

while 1:
    try:
        side = list(map(int, input().split()))
    except EOFError:
        print(' '.join(str(a) for a in ans))
        break

    side.sort(reverse=True)
    a, b, c = side

    if flag:
        continue

    if a >= b + c:
        flag = 1
        continue
    else:
        ans[0] += 1
        bc = math.sqrt(b**2 + c**2)
        if a == bc:
            ans[1] += 1
        elif a < bc:
            ans[2] += 1
        else:
            ans[3] += 1

Python: result = [0] * 3
while 1:
    a = input()
#print(sum(result), *result)

Python: num = 0
triangle = {"chokkaku":0,"eikaku":0,"donkaku":0}
while True:
    hen = list(map(int,input().split()))
    hen.sort()
    if hen[0] + hen[1] <= hen[2]:
        break
    else:
        num += 1
        if hen[0]**2 + hen[1] ** 2 == hen[2] **2:
            triangle["chokkaku"] += 1
        elif hen[0] ** 2 + hen[1] ** 2 < hen[2] **2:
            triangle["donkaku"] += 1
        else:
            triangle["eikaku"] += 1

kotae = str(num)+" "+" ".join(list(map(str,triangle.values())))
print(kotae)

Python: f = True
cnt = 0
l = [0,0,0]
while f:
    t = []
    t.append(int(input()))
    t.append(int(input()))
    t.append(int(input()))
    t.sort()
    if t[0]+t[1] <= t[2]:
        f = False
        continue
    if t[0]**2+t[1]**2 > t[2]**2:
        l[0]+=1
    elif t[0]**2+t[1]**2 == t[2]**2:
        l[1]+=1
    else:
        l[2]+=1
print(sum(l),[s for s in l])

Python: A =[] 
while True:
    try:
        A.append(sorted(list(map(int,input().split())),reverse=True))

    except:
        break
        #または、quit(),os.exit()をして止める。


def triangle_types(X):
    print(X)
    num_of_acute = 0
    num_of_right = 0
    num_of_obtuse = 0
    num_of_normal = 0
    for i in range(len(X)):
        a,b,c = [j for j in X[i]]
        ans = b**2 + c**2 - a**2
        print("a:{},b+c:{}".format(a,b+c))
        if (a < b + c and b < a + c and c < a + b):
            num_of_normal+=1
            if (ans > 0):
                num_of_acute+=1
            elif (ans == 0):
                num_of_right+=1
            elif (ans < 0):
                num_of_obtuse+=1
            else:
                print("{} {} {} {}".format(num_of_normal,num_of_right,num_of_acute,num_of_obtuse))
                return
        else:
            print("{} {} {} {}".format(num_of_normal,num_of_right,num_of_acute,num_of_obtuse))
            return
    print("{} {} {} {}".format(num_of_normal,num_of_right,num_of_acute,num_of_obtuse))
    return

if __name__ == '__main__':
    triangle_types(A)

Python: result = [0]*3
while True:
    a, b, c = sorted(map(int, input().split()))
    if a + b <= c:
        print(sum(result),*result)
    flag = a ** 2 + b ** 2 - c*c
    if flag == 0:
        result[0] +=1
    elif flag >0:
        result[1] += 1
    else:
        result[2] += 1

Python: lista=[]
t=0
ch=0
e=0
d=0
while True:
    try:
        lista.append(list(map(int,input().split())))
    except:
        break;

def func01(a,b,c):
    global t
    global ch
    global e
    global d
    if a+b>c:
        t+=1
        if a**2+b**2==c**2:
            ch+=1
        elif a**2+b**2>c**2:
            e+=1
        elif a**2+b**2<c**2:
            d+=1
for i in range(len(lista)):
    x=sorted(lista[i])
    func01(x[0],x[1],x[2])
print(t,ch,e,d)

Python: # coding=utf-8
import math


def is_triangle(sides_list):
    if sides_list[0] >= sides_list[1] + sides_list[2]:
        return False
    if sides_list[0] <= math.fabs(sides_list[1] - sides_list[2]):
        return False
    return True


def is_right_triangle(sides_list):
    sides_list.sort()
    if sides_list[2]**2 > sides_list[1]**2 + sides_list[0]**2:
        return 3
    if sides_list[2]**2 < sides_list[1]**2 + sides_list[0]**2:
        return 2
    if sides_list[2] ** 2 == sides_list[1] ** 2 + sides_list[0] ** 2:
        return 1


if __name__ == '__main__':
    counter = [0, 0, 0, 0]
    while True:
        sides = list(map(int, input().split()))
        if not is_triangle(sides):
            break
        counter[0] += 1
        counter[is_right_triangle(sides)] += 1

    print(' '.join(map(str, counter)))

Python: acute, right, obtuse = 0, 0, 0
while True:
    a, b, c = sorted(map(int, input().split()))
    if a + b <= c:
        print(acute + right + obtuse, right, acute, obtuse)
        break
    d = a ** 2 + b ** 2
    e = c ** 2
    if d == e:
        right += 1
    elif d < e:
        obtuse += 1
    else:
        acute += 1

Python: a,b,c = map(int,input().split())

Python: ans=[0]*4
while True:
    a,b,c=sorted(list(map(int,input().split(" "))))
    if a+b<=c:break
    d=a*a+b*b-c*c
    ans[0]+=1
    ans[1]+=d==0
    ans[2]+=d>0
    ans[3]+=d<0
print(*ans)

Python: def run():
    judge = [0, 0, 0, 0]
    while True:
        a, b, c = (int(x) for x in sorted(input().split()))
        if a + b <= c or min([a, b, c]) <= 0:
            print(' '.join(map(str, judge)))
            break
        else:
            S = a ** 2 + b ** 2 - c ** 2
            judge[0] += 1
            if S == 0:
                judge[1] += 1
            elif S < 0:
                judge[2] += 1
            else:
                judge[3] += 1





if __name__ == '__main__':
    run()

Python: aa= 0; ab= 0; ac=0
while True :
    edge = map(int, input().split())
    sEdge = sorted(edge)
    a = sEdge[0]
    b = sEdge[1]
    c = sEdge[2]
    if c >= a + b :
        break
    jud = c ** 2 - a ** 2 - b ** 2
    if jud == 0 :
        aa += 1
    elif jud < 0 :
        ab += 1
    else :
        ac += 1
print("{} {} {} {}".format(aa + ab + ac, aa, ab, ac))

Python: lista=[]
t=0
ch=0
e=0
d=0
tflag=1
while True:
    try:
        lista.append(list(map(int,input().split())))
    except:
        break;

def func01(a,b,c):
    global t
    global ch
    global e
    global d
    if a+b>c:
        t+=1
        if a**2+b**2==c**2:
            ch+=1
        elif a**2+b**2>c**2:
            e+=1
        elif a**2+b**2<c**2:
            d+=1
    else:
        tflag=0
while(tflag==1):
    for i in range(len(lista)):
        x=sorted(lista[i])
        func01(x[0],x[1],x[2])
    break
print(t,ch,e,d)

Python: print(1)