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":
					o_t++
				}
				t++
			}	else {
				break
			}
			
	}
	fmt.Println(t, r_t, s_t, o_t)
}

Python: A, B, C = 0, 0, 0  # A直角, B鋭角, C鈍角
while True:
	i = list(map(int, input().split()))
	i.sort()
	a, b, c = i[0], i[1], i[2]
	if c >= a + b:  # 三角形ではない
		break
	a2, b2, c2 = a ** 2, b ** 2, c ** 2
	if c2 == b2 + a2:  # 直角
		A = A + 1
	elif c2 < b2 + a2:  # 鈍角
		B = B + 1
	elif c2 > b2 + a2:  # 鋭角
		C = C + 1

print('{0} {1} {2} {3}'.format(A + B + C, A, B, C))

Python: ss = input()

Python: ans = [0 for i in range(4)]
while True:
  sides = sorted([int(inp) for inp in input().split()])
  if sides[2] >= sides[1] + sides[0]:
    print(ans[0], ans[1], ans[2], ans[3])
    break
  if sides[2]**2 > sides[1]**2 + sides[0]**2:
    ans[3]+=1
  elif sides[2]**2 == sides[1]**2 + sides[0]**2:
    ans[2]+=1
  else:
    ans[1]+=1
  ans[0]+=1

Python: f = True
cnt = 0
l = [0,0,0]
while f:
    t = [int(s) for s in input().split()]
    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: count = 0 #三角形の数
right = 0 #直角三角形の数
acute = 0 #鋭角三角形の数
obtuse = 0 #鈍角三角形の数
while True:
    try:
        n = input().split()
    except EOFError: #すべて三角形だった時のため(この問いでは不要)
        print(str(count) + " " + str(right) + " " + str(acute) + " " + str(obtuse))
        break
    m = [float(i) for i in n]
    m.sort() #三角形の各辺を小さい順にｍにリスト化
    MaxArgCos = (m[0] ** 2 + m[1] ** 2 - m[2] ** 2) / (2 * m[0] * m[1]) #三角形の最大角のcosを調べる
    count += 1 #三角形の数のカウント
    if -1 < MaxArgCos < 0:
        obtuse += 1 #鈍角
    elif 0 < MaxArgCos < 1:
        acute += 1 #鋭角
    elif MaxArgCos == 0:
        right += 1 #直角
    else:
        count -= 1 #三角形ではないのでカウントを減らす
        print(str(count) + " " + str(right) + " " + str(acute) + " " + str(obtuse))
        break

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

Python: def check(lst):
  c, b, a = lst
  if a >= b + c:
    return -1
  elif a ** 2 > b ** 2 + c ** 2:
    return 3
  elif a ** 2 == b ** 2 + c ** 2:
    return 1
  else:
    return 2

dic = [0] * 4
while True:
  lst = list(map(int,input().split()))
  lst.sort()
  f = check(lst)
  if f == -1:
    print(" ".join(map(str,dic)))
    break
  dic[f] += 1
  dic[0] += 1

Python: tri=0
sh=0
rec=0
dul=0

while True:
    L=input().split( )
    E=[int(L[i]) for i in range(3)]
    mx=max(E)
    sm=sum(E)
    quad_sum=E[0]**2+E[1]**2+E[2]**2

    if mx*2>=sm:
        print(tri,rec,sh,dul)
        break
    else:
        tri+=1
        if mx**2*2>quad_sum:
            dul+=1
        elif mx**2*2==quad_sum:
            rec+=1
        else:
            sh+=1

Python: import sys
num = 0
triangle = {"chokkaku":0,"eikaku":0,"donkaku":0}
for i in sys.stdin:
    hen = list(map(int,i.split()))
    hen.sort()
    if (hen[0] + hen[1] <= hen[2]) or (hen[1] + hen[2] <= hen[0]) or (hen[2] + hen[0] <= hen[1]):
        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: import sys
from math import *
ans = [0] * 4
for li in sys.stdin:
    ans[0] += 1
    a = sorted(map(int, li.split()))
    if a[0] + a[1] >= a[2]:
        t = hypot(a[0], a[1])
        if t == a[2] ** 2:
            ans[2] += 1
        elif t < a[2] ** 2:
            ans[1] += 1
        else:
            ans[3] += 1
print(*ans)

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

    except:
        break

def triangle_types(X):
    num_of_normal = 0
    num_of_right = 0
    num_of_acute = 0
    num_of_obtuse = 0

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


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

Python: cho,ei,don = 0,0,0
while(True):
    tmp = list(map(int, input().split()))
    tmp.sort()
    a,b,c = tmp[0],tmp[1],tmp[2]
    if a + b <= c:
        break
    else:
        a2 , b2 , c2 = a ** 2, b ** 2, c ** 2
        if a2 + b2 == c2:
            cho += 1
        elif a2 + b2 < c2:
            don += 1
        else:
            ei += 1
print(cho+ei+don,cho,ei,don)

Python: import sys

a = []
for line in sys.stdin:
    a.append(list(map(int,line.split())))
t = [0 for i in range(3)]
for i in range(len(a)):
    a[i].sort()
    if a[i][2] >= a[i][0] + a[i][1]:
        break
    b = a[i][2] ** 2
    c = a[i][0] ** 2 + a[i][1] ** 2
    if b > c:
        t[2] += 1
    elif b < c:
        t[1] += 1
    else:
        t[0] += 1
print("{0} {1} {2} {3}".format(sum(t), t[0], t[1], t[2]))

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

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

    except:
        break

def triangle_types(X):
    num_of_normal = 0
    num_of_right = 0
    num_of_acute = 0
    num_of_obtuse = 0

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


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)
        break
    flag = a ** 2 + b ** 2 - c*c
    if flag == 0:
        result[0] +=1
    elif flag >0:
        result[1] += 1
    else:
        result[2] += 1