For given two sides of a triangle a and b and the angle C between them, calculate the following properties:

* S: Area of the triangle
* L: The length of the circumference of the triangle
* h: The height of the triangle with side a as a bottom edge



Input

The length of a, the length of b and the angle C are given in integers.

Output

Print S, L and h in a line respectively. The output should not contain an absolute error greater than 10-4.

Example

Input

4 3 90


Output

6.00000000
12.00000000
3.00000000

Difficulty: UNKNOWN_DIFFICULTY

Starter code:

Solutions:
import math
pi = math.pi
(a, b, si) = map(float, input().split())
S = 1 / 2 * a * b * math.sin(math.radians(si))
c2 = a * a + b * b - 2 * a * b * math.cos(math.radians(si))
L = a + b + math.sqrt(c2)
h = 2 * S / a
print(S)
print(L)
print(h)


from math import sin, cos, radians, sqrt
(a, b, C) = map(float, input().split())
rad = radians(C)
h = b * sin(rad)
print(a * h / 2)
print(a + b + sqrt(a ** 2 + b ** 2 - 2 * a * b * cos(rad)))
print(h)


import math
(a, b, c) = map(int, input().split())
Sin = math.sin(math.radians(c))
Cos = math.cos(math.radians(c))
S = a * b * Sin * 0.5
L = (a ** 2 + b ** 2 - 2 * a * b * Cos) ** 0.5 + a + b
h = S * 2 / a
print(S, L, h)


(a, b, c) = map(int, input().split())
import math
d = math.sin(math.radians(c))
print(a * b * d / 2)
e = math.cos(math.radians(c))
x = math.sqrt(a ** 2 + b ** 2 - 2 * a * b * e)
print(a + b + x)
print(2 * (a * b * d / 2) / a)


import math
(a, b, c) = map(int, input().split())
c = c / 180 * math.pi
print(0.5 * a * b * math.sin(c), a + b + (a ** 2 + b ** 2 - 2 * a * b * math.cos(c)) ** 0.5, b * math.sin(c))


import math
(A, B, DEGREE) = map(int, input().split())
rad = math.radians(DEGREE)
S = A * B * math.sin(rad) / 2.0
C = math.sqrt(A * A + B * B - 2 * A * B * math.cos(rad))
h = 2 * S / A
print('%.10f %.10f %.10f' % (S, A + B + C, h))


import math
(a, b, C) = map(int, input().split())
c = math.sqrt(a * a + b * b - 2 * a * b * math.cos(math.radians(C)))
s = (a + b + c) / 2
S = math.sqrt(s * (s - a) * (s - b) * (s - c))
L = a + b + c
h = 2 * S / a
print(f'{S:.5f}\n{L:.5f}\n{h:.5f}')


import math
(a, b, r) = [float(k) for k in input().split()]
S = a * b * math.sin(math.radians(r)) / 2
L = math.sqrt(a ** 2 + b ** 2 - 2 * math.cos(math.radians(r)) * a * b) + a + b
H = S * 2 / a
print(S, L, H, sep='\n')


import math
(a, b, C) = map(float, input().split())
S = 1 / 2 * a * b * math.sin(math.radians(C))
c = (a ** 2 + b ** 2 - 2 * a * b * math.cos(math.radians(C))) ** 0.5
L = a + b + c
h = S * 2 / a
print(S)
print(L)
print(h)


import math
(a, b, c) = map(int, input().split())
c = math.radians(c)
s = a * b * math.sin(c) / 2
cr = math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(c))
l = a + b + cr
h = b * math.sin(c)
print(s, l, h)


import math
(a, b, C) = map(float, input().split())
pi = math.pi
rad = C * pi / 180
c = math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(rad))
S = a * b * math.sin(rad) / 2
L = 2 * S / a
print(S, a + b + c, L)


import math
(a, b, C) = map(int, input().split())
C = math.radians(C)
S = 0.5 * a * b * math.sin(C)
L = a + b + math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(C))
h = 2 * S / a
print(S, L, h)


import math
(a, b, C) = (float(i) for i in input().split())
rad = math.radians(C)
S = a * b * 0.5 * math.sin(rad)
L = a + b + math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(rad))
H = b * math.sin(rad)
print(S)
print(L)
print(H)


from math import sin, cos, radians
(a, b, c) = map(int, input().split())
c = radians(c)
s = a * b * sin(c) * 0.5
for i in [s, a + b + (a * a + b * b - 2 * a * b * cos(c)) ** 0.5, s / a * 2]:
	print('%5f' % i)


(a, b, C) = map(float, input().split())
import math
r = C * math.pi / 180
S = 1 / 2 * a * b * math.sin(r)
c = (a ** 2 + b ** 2 - 2 * a * b * math.cos(r)) ** (1 / 2)
L = a + b + c
h = b * math.sin(r)
print(S)
print(L)
print(h)


import math
(a, b, c) = map(int, input().split())
K = a * b * math.sin(math.radians(c)) / 2
L = math.sqrt(a ** 2 + b ** 2 - 2 * (a * b) * math.cos(math.radians(c)))
S = a + b + L
print(K)
print(S)
P = 2 * K / a
print(P)


import math
(a, b, c) = map(int, input().split())
h = math.sin(math.radians(c)) * b
L = a + b + math.sqrt(a * a + b * b - 2 * a * b * math.cos(math.radians(c)))
S = h * a / 2
print(S)
print(L)
print(h)


import math
(a, b, c) = map(int, input().split())
c = c / 180 * math.pi
h = math.sin(c) * b
S = a * h / 2
L = a + b + abs(complex(a - math.cos(c) * b, h))
print(S, L, h)


import math
(a, b, c) = map(float, input().split())
rad = math.radians(c)
x = (a ** 2 + b ** 2 - 2 * a * b * math.cos(rad)) ** (1 / 2)
L = a + b + x
S = a * b * math.sin(rad) / 2
h = 2 * S / a
print('{:.8f}\n{:.8f}\n{:.8f}'.format(S, L, h))


from math import *
(a, b, C) = map(int, input().split())
C = C * pi / 180
S = a * b * sin(C) / 2
print(S, a + b + (a * a + b * b - 2 * a * b * cos(C)) ** 0.5, 2 * S / a, sep='\n')


import math
(a, b, c) = map(float, input().split())
print(0.5 * a * b * math.sin(c / 180 * math.pi))
print(a + b + math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(c / 180 * math.pi)))
print(b * math.sin(c / 180 * math.pi))


import math as m
(a, b, c) = input().split()
a = int(a)
b = int(b)
c = int(c)
c = m.radians(c)
S = 0.5 * a * b * m.sin(c)
L = a + b + m.sqrt(a * a + b * b - 2 * a * b * m.cos(c))
H = b * m.sin(c)
print(S)
print(L)
print(H)


import math
(a, b, c) = map(float, input().split())
c = math.radians(c)
print(a * b * math.sin(c) / 2)
print(a + b + math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(c)))
print(b * math.sin(c))


import math
(a, b, c) = map(int, input().split())
S = a * b * math.sin(math.radians(c)) / 2
L = (a ** 2 + b ** 2 - 2 * a * b * math.cos(math.radians(c))) ** 0.5 + a + b
h = 2 * S / a
print(S)
print(L)
print(h)


from math import pi, sin, cos
(a, b, C) = map(int, input().split())
C = C * pi / 180
S = a * b * sin(C) / 2
print(S, a + b + (a * a + b * b - 2 * a * b * cos(C)) ** 0.5, 2 * S / a, sep='\n')


import math
(a, b, c) = map(int, input().split())
s = a * b * math.sin(math.radians(c)) / 2
print(s)
c_l = math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(math.radians(c)))
print(a + b + c_l)
h = 2 * s / a
print(h)


import math
(a, b, c) = map(int, input().split())
sinc = math.sin(math.radians(c))
cosc = math.cos(math.radians(c))
s = 1 / 2 * a * b * sinc
l = math.sqrt(a ** 2 + b ** 2 - 2 * a * b * cosc) + a + b
h = s * 2 / a
print(s)
print(l)
print(h)


import math
(a, b, C) = map(int, input().split())
s = math.sin(math.radians(C))
S = a * b * s / 2
c = math.cos(math.radians(C))
x = a * a + b * b - 2 * a * b * c
d = math.sqrt(x)
L = a + b + d
h = 2 * S / a
print(S)
print(L)
print(h)


import math
(a, b, C) = map(int, input().split())
C = math.radians(C)
S = a * b * math.sin(C) / 2
L = a + b + math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(C))
h = b * math.sin(C)
print(f'{S:.8f}')
print(f'{L:.8f}')
print(f'{h:.8f}')


import math
(a, b, C) = map(float, input().split())
S = a * b * math.sin(math.radians(C)) / 2
L = a + b + math.sqrt(a * a + b * b - 2 * a * b * math.cos(math.radians(C)))
h = 2 * S / a
print(f'{S} {L} {h}')


import math
(a, b, C) = map(float, input().split())
C = math.radians(C)
S = a * b * math.sin(C) / 2
L = a + b + math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(C))
h = b * math.sin(C)
print(S)
print(L)
print(h)


import math
(a, b, C) = map(int, input().split())
S = a * b * math.sin(C / 180 * math.pi) / 2
L = a + b + math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(C / 180 * math.pi))
h = 2 * S / a
print(S)
print(L)
print(h)


import math
(a, b, c) = map(float, input().split())
d = a * a + b * b - 2 * a * b * math.cos(math.pi * c / 180)
print(0.5 * a * b * math.sin(math.pi * c / 180))
print(a + b + d ** 0.5)
print(b * math.sin(math.pi * c / 180))


from math import *
(a, b, C) = map(int, input().split())
C = C / 180 * pi
print(a * b / 2 * sin(C))
print(sqrt(a ** 2 + b ** 2 - 2 * a * b * cos(C)) + a + b)
print(b * sin(C))


from math import sin, cos, radians
(a, b, c) = map(int, input().split())
c = radians(c)
s = a * b * sin(c) * 0.5
l = a + b + (a * a + b * b - 2 * a * b * cos(c)) ** 0.5
h = s / a * 2
for i in [s, l, h]:
	print('%5f' % i)


import math
(a, b, c) = map(int, input().split())
s = a * b * math.sin(math.radians(c)) / 2
l = (a ** 2 + b ** 2 - 2 * a * b * math.cos(math.radians(c))) ** (1 / 2) + a + b
h = 2 * s / a
print(s)
print(l)
print(h)


import math
(a, b, C) = map(float, input().split())
Crad = C / 180 * math.pi
H = b * math.sin(Crad)
S = H * a / 2
L = math.sqrt((a - b * math.cos(Crad)) ** 2 + H ** 2) + a + b
print(S)
print(L)
print(H)


import math
(a, b, C) = map(int, input().split())
C = math.radians(C)
print(a * b * math.sin(C) / 2)
print(math.sqrt(a * a + b * b - 2 * a * b * math.cos(C)) + a + b)
print(b * math.sin(C))


import math as m
(a, b, C) = map(float, input().split(' '))
C = m.pi * C / 180
h = b * m.sin(C)
print(a * h * 0.5)
print((a ** 2 + b ** 2 - 2 * a * b * m.cos(C)) ** 0.5 + a + b)
print(h)


from math import radians, sin, cos, sqrt
(a, b, C) = map(float, input().split())
h = b * sin(radians(C))
c = sqrt(a * a + b * b - 2 * a * b * cos(radians(C)))
S = a * h / 2
L = a + b + c
print(S, L, h)


import math
(a, b, C) = map(float, input().split())
S = a * b * math.sin(math.pi * C / 180) / 2
c = math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(math.pi * C / 180))
L = a + b + c
h = 2 * S / a
print(f'{S:.5f}')
print(f'{L:.5f}')
print(f'{h:.5f}')


import math
(a, b, c) = map(float, input().split())
theta = c / 180 * math.pi
S = 0.5 * a * b * math.sin(theta)
h = b * math.sin(theta)
L = math.sqrt(a ** 2 + b ** 2 + -2 * a * b * math.cos(theta)) + a + b
print(S)
print(L)
print(h)


import math
(a, b, C) = map(float, input().split())
C = math.radians(C)
c = math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(C))
L = a + b + c
h = b * math.sin(C)
S = a * h / 2
print(S)
print(L)
print(h)


import math
(A, B, DEGREE) = map(int, input().split())
rad = math.radians(DEGREE)
S = A * B * math.sin(rad) / 2.0
C = math.sqrt(A ** 2 + B ** 2 - 2 * A * B * math.cos(rad))
h = 2 * S / A
print('%.10f %.10f %.10f' % (S, A + B + C, h))


import math
(a, b, C) = map(int, input().split())
C = C * math.pi / 180
S = a * b * math.sin(C) / 2
print(S, a + b + (a * a + b * b - 2 * a * b * math.cos(C)) ** 0.5, 2 * S / a, sep='\n')


import math
(a, b, c) = map(float, input().split())
c = math.radians(c)
h = b * math.sin(c)
s = a * h / 2
l = (b ** 2 + a ** 2 - 2 * a * b * math.cos(c)) ** 0.5 + a + b
print(s, l, h, sep='\n')


import math
(a, b, C) = map(float, input().split())
rad_C = C * math.pi / 180
c2 = a ** 2 + b ** 2 - 2 * a * b * math.cos(rad_C)
S = 0.5 * a * b * math.sin(rad_C)
L = a + b + math.sqrt(c2)
h = 2 * S / a
print(S)
print(L)
print(h)


from math import sin, cos, pi, sqrt
(a, b, c) = map(int, input().split())
s = a * b * sin(pi * c / 180) / 2
c = sqrt(a ** 2 + b ** 2 - a * b * 2 * cos(pi * c / 180))
h = 2 * s / a
print(s)
print(a + b + c)
print(h)


import math
(a, b, c) = map(int, input().split())
s = a * b * math.sin(math.radians(c)) / 2
l = a + b + math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(math.radians(c)))
h = s / a * 2
print(s, l, h)


import math
(a, b, C) = map(int, input().split())
S = a * b * (math.sin(math.radians(C)) / 2)
L = a + b + math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(math.radians(C)))
h = S * 2 / a
print(S)
print(L)
print(h)


import math
(a, b, deg) = map(float, input().split())
rad = math.radians(deg)
area = 0.5 * a * b * math.sin(rad)
c = math.sqrt(a * a + b * b - 2 * a * b * math.cos(rad))
h = area * 2 / a
print(area, a + b + c, h)


import math
(a, b, c) = map(int, input().split())
print(a * b * math.sin(math.radians(c)) / 2)
print(math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(math.radians(c))) + a + b)
print(b * math.sin(math.radians(c)))


import math
(a, b, c) = map(float, input().split())
sinc = math.sin(c * math.pi / 180)
cosc = math.cos(c * math.pi / 180)
c = math.sqrt(a ** 2 + b ** 2 - 2 * a * b * cosc)
s = a * b * sinc / 2.0
print(s)
print(a + b + c)
print(s / a * 2.0)


import math
(a, b, c) = map(int, input().split())
s = a * b * math.sin(math.radians(c)) / 2
l = math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(math.radians(c)))
l = l + a + b
h = 2 * s / a
print(s, l, h)


import math
(a, b, C) = map(int, input().split())
C = math.radians(C)
S = a * b * math.sin(C) / 2
l = a + b + math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(C))
h = b * math.sin(C)
print(S)
print(l)
print(h)


import math
(a, b, C) = map(float, input().split())
h = b * math.sin(math.radians(C))
c = math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(math.radians(C)))
r = a + b + c
print(a * h / 2)
print(r)
print(h)


import math
(a, b, c) = map(float, input().split())
c *= math.pi / 180
print(0.5 * a * b * math.sin(c))
print(a + b + math.sqrt(a * a + b * b - 2 * a * b * math.cos(c)))
print(b * math.sin(c))


import math
(a, b, c) = map(float, input().split())
c = math.radians(c)
L = a + b + math.sqrt(a * a + b * b - 2 * a * b * math.cos(c))
S = a * b * math.sin(c) / 2
H = 2 * S / a
print(f'{S}\n{L}\n{H}')


import math
(a, b, C) = map(int, input().split())
h = b * math.sin(math.radians(C))
S = a * h / 2
c = math.sqrt(h ** 2 + (a - b * math.cos(math.radians(C))) ** 2)
L = a + b + c
print(S)
print(L)
print(h)


import math
(a, b, c) = map(int, input().split())
s = a * b * (1 / 2) * math.sin(c * math.pi / 180)
x = a ** 2 + b ** 2 - 2 * a * b * math.cos(c * math.pi / 180)
x = math.sqrt(x)
L = a + b + x
h = b * math.sin(c * math.pi / 180)
print(s, L, h)


import math
(a, b, x) = map(float, input().split())
x = x * math.pi / 180
S = a * b * 0.5 * math.sin(x)
print(S)
print(a + b + math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(x)))
print(2 * S / a)


import math
(a, b, c) = map(float, input().split())
C_rad = math.pi * c / 180
print(math.sin(C_rad) * a * b / 2)
print(a + b + math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(C_rad)))
print(b * math.sin(C_rad))


import math
(a, b, c) = map(int, input().split())
rad = math.radians(c)
S = a * b * math.sin(rad) / 2.0
C = math.sqrt(a * a + b * b - 2 * a * b * math.cos(rad))
h = 2 * S / a
print('%.10f %.10f %.10f' % (S, a + b + C, h))


import math
(a, b, C) = map(int, input().split())
C = math.radians(C)
S = a * b * math.sin(C) * 0.5
c = math.sqrt(a * a + b * b - 2 * a * b * math.cos(C))
L = a + b + c
h = 2 * S / a
print(S, L, h)


import math
(a, b, c) = map(float, input().split())
s = 0.5 * a * b * math.sin(math.radians(c))
l = a + b + math.sqrt(a * a + b * b - 2 * a * b * math.cos(math.radians(c)))
h = 2 * s / a
print(s, l, h, sep='\n')


(a, b, c) = list(map(int, input().split()))
from math import pi, sin, cos
print(a * b * 0.5 * sin(c * pi / 180))
print(a + b + (a ** 2 + b ** 2 - 2 * a * b * cos(c * pi / 180)) ** 0.5)
print(b * sin(c * pi / 180))


import math
(a, b, C) = [float(s) for s in input().split(' ')]
C = math.radians(C)
h = b * math.sin(C)
S = a * h * 0.5
L = a + b + math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(C))
print(S)
print(L)
print(h)


import math
(a, b, c) = map(int, input().split())
S = 0.5 * math.sin(math.radians(c)) * a * b
L = (a ** 2 + b ** 2 - 2 * a * b * math.cos(math.radians(c))) ** 0.5 + a + b
h = 2 * S / a
print(S, L, h)


import math
(a, b, c) = map(float, input().split())
e = b * math.sin(math.radians(c))
print(a * e / 2)
print(((a - b * math.cos(math.radians(c))) ** 2 + e ** 2) ** 0.5 + a + b)
print(e)


import math
(a, b, d) = map(float, input().split())
h = b * math.sin(d * math.pi / 180)
s = a * h / 2
l = math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(d * math.pi / 180)) + a + b
print(s)
print(l)
print(h)


import math
(a, b, C) = map(int, input().split())
C = math.radians(C)
S = 1 / 2 * a * b * math.sin(C)
print(S)
c = math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(C))
L = a + b + c
print(L)
h = math.sin(C) * b
print(h)


import math
(a, b, C) = map(int, input().split())
S = a * b * math.sin(math.radians(C)) / 2
print(S)
c = math.sqrt(pow(a, 2) + pow(b, 2) - 2 * a * b * math.cos(math.radians(C)))
L = a + b + c
print(L)
h = 2 * S / a
print(h)


import math
(a, b, C) = map(int, input().split())
c = math.radians(C)
S = a * b * math.sin(c) / 2
d = math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(c))
L = a + b + d
h = 2 * S / a
print(S)
print(L)
print(h)


import math
(a, b, c) = map(int, input().split())
r = math.radians(c)
print(a * b * math.sin(r) / 2)
print(a + b + (a ** 2 + b ** 2 - 2 * a * b * math.cos(r)) ** 0.5)
print(b * math.sin(r))


import math
(a, b, c) = map(int, input().split())
S = 1 / 2 * a * b * math.sin(math.radians(c))
L = a + b + math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(math.radians(c)))
h = b * math.sin(math.radians(c))
print(S)
print(L)
print(h)


import math
(a, b, C) = map(int, input().split())
C = C / 180 * math.pi
S = a * b * math.sin(C) / 2
print(S)
print(a + b + math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(C)))
print(2 * S / a)


import math as m
(a, b, C) = map(int, input().split())
r = m.radians(C)
print(f'{a * b * m.sin(r) / 2:.5f}')
print(f'{a + b + m.sqrt(a ** 2 + b ** 2 - 2 * a * b * m.cos(r)):.5f}')
print(f'{b * m.sin(r):.5f}')


import math
(a, b, c) = map(int, input().split())
S = a * b * math.sin(math.radians(c)) / 2
L = a + b + math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(math.radians(c)))
h = 2 * S / a
print(S)
print(L)
print(h)


import math
(a, b, C) = map(int, input().split())
t = math.radians(C)
S = a * b * math.sin(t) / 2
c = math.sqrt(a * a + b * b - 2 * a * b * math.cos(t))
L = a + b + c
h = 2 * S / a
print(f'{S:.8f}')
print(f'{L:.8f}')
print(f'{h:.8f}')


import math
(a, b, C) = map(float, input().split())
C = math.pi * C / 180
area = a * b * math.sin(C) / 2
print(area)
print(a + b + math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(C)))
print(area * 2 / a)


from math import *
(a, b, C) = map(float, input().split())
C = radians(C)
print(sin(C) * a * b / 2, (a * a + b * b - 2 * a * b * cos(C)) ** 0.5 + a + b, sin(C) * b, sep='\n')


import math
(a, b, c) = map(float, input().split())
s = a * b * math.sin(math.pi * c / 180) / 2
l = math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(math.pi * c / 180)) + a + b
h = s * 2 / a
print(s)
print(l)
print(h)


import math
(a, b, c) = map(float, input().split())
s = a * b * math.sin(math.radians(c)) / 2
l = math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(math.radians(c))) + a + b
h = s * 2 / a
print(s)
print(l)
print(h)


import math
(a, b, C) = map(int, input().split())
S = float(a * b * math.sin(C / 180 * math.pi) / 2)
c = float(math.sqrt(pow(a, 2) + pow(b, 2) - 2 * a * b * math.cos(C / 180 * math.pi)))
L = a + b + c
h = S * 2 / a
print(S)
print(L)
print(h)


import math
(a, b, C) = map(float, input().split())
h = b * math.sin(math.pi * C / 180)
S = a * h / 2
L = a + b + (a ** 2 + b ** 2 - 2 * a * b * math.cos(math.pi * C / 180)) ** 0.5
print(S, L, h)


import math
(a, b, C) = map(int, input().split())
rad = C / 180 * math.pi
h = b * math.sin(rad)
S = a * h / 2
c = math.sqrt(h ** 2 + (a - b * math.cos(rad)) ** 2)
L = a + b + c
print(S, L, h)


import math
(a, b, c) = map(float, input().split())
print(a * b * math.sin(c * math.pi / 180) / 2)
print(math.sqrt(a * a + b * b - 2 * a * b * math.cos(c * math.pi / 180)) + a + b)
print(a * b * math.sin(c * math.pi / 180) / a)


from math import *
(a, b, C) = map(int, input().split())
C2 = radians(C)
S = float(a * b * sin(C2) / 2)
L = float(a + b + (a ** 2 + b ** 2 - 2 * a * b * cos(C2)) ** (1 / 2))
h = float(b * sin(C2))
print(S)
print(L)
print(h)


import math
(a, b, C) = map(float, input().split())
rad = C / 180 * math.pi
S = 0.5 * a * b * math.sin(rad)
print(S)
L = a + b + math.sqrt(a * a + b * b - 2 * a * b * math.cos(rad))
print(L)
h = S / a * 2
print(h)


import math
(a, b, t) = map(int, input().strip().split())
t = math.radians(t)
h = b * math.sin(t)
l = a + b + math.sqrt(a * a + b * b - 2 * a * b * math.cos(t))
s = a * h / 2
print(s)
print(l)
print(h)


from math import sin, cos, pi, sqrt
(a, b, d) = map(float, input().split())
S = a * b * sin(d * pi / 180) / 2
c = sqrt(a ** 2 + b ** 2 - 2 * a * b * cos(d * pi / 180))
h = 2 * S / a
print(S)
print(a + b + c)
print(h)


import math
(a, b, C) = map(float, input().split())
S = a * b * math.sin(math.radians(C)) / 2
L = a + b + (a ** 2 + b ** 2 - 2 * a * b * math.cos(math.radians(C))) ** 0.5
h = S * 2 / a
print(S)
print(L)
print(h)


import math
(a, b, C) = map(float, input().split())
rad = math.radians(C)
h = b * math.sin(rad)
S = a * h / 2
L = a + b + math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(rad))
print('%.5f\n%.5f\n%.5f' % (S, L, h))


from math import sin, cos, pi, sqrt
(a, b, C) = map(int, input().split())
S = a * b * sin(C * pi / 180) / 2
c = sqrt(a ** 2 + b ** 2 - 2 * a * b * cos(C * pi / 180))
h = 2 * S / a
print(S)
print(a + b + c)
print(h)


import math
(a, b, c) = map(int, input().split())
S = a * b * math.sin(math.radians(c)) / 2
L = a + b + math.sqrt(a * a + b * b - 2 * a * b * math.cos(math.radians(c)))
h = S / a * 2
print(S)
print(L)
print(h)


import math
(a, b, C) = map(int, input().split())
C = math.radians(C)
print(0.5 * a * b * math.sin(C))
print(a + b + math.sqrt(a * a + b * b - 2 * a * b * math.cos(C)))
print(b * math.sin(C))


import math
(a, b, c) = map(int, input().split())
c = c * math.pi / 180
h = b * math.sin(c)
d = math.sqrt(b ** 2 + a ** 2 - 2 * b * a * math.cos(c))
S = a * h / 2
print(S)
print(a + b + d)
print(h)


import math
(a, b, C) = map(int, input().split(' '))
h = b * math.sin(math.radians(C))
S = a * h / 2
c2 = a ** 2 + b ** 2 - 2 * a * b * math.cos(math.radians(C))
c = math.sqrt(c2)
L = a + b + c
print(S)
print(L)
print(h)


import math
(a, b, C) = map(float, input().split())
θ = math.radians(C)
h = b * math.sin(θ)
S = a * h / 2
c = math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(θ))
L = a + b + c
print(S, L, h, sep='\n')


import math
(a, b, C) = map(float, input().split())
C = math.radians(C)
c = math.sqrt(a * a + b * b - 2.0 * a * b * math.cos(C))
S = a * b * math.sin(C) / 2.0
L = a + b + c
h = b * math.sin(C)
print('{:.8f} {:.8f} {:.8f}'.format(S, L, h))


import math
(a, b, C) = map(float, input().split())
C = C / 180 * math.pi
c = math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(C))
h = b * math.sin(C)
print(a * h / 2)
print(a + b + c)
print(h)


from math import sin, sqrt, cos, pi
(a, b, C) = map(int, input().split())
C = C / 180 * pi
S = a * b * sin(C) / 2
L = a + b + sqrt(a * a + b * b - 2 * a * b * cos(C))
H = S * 2 / a
print(S)
print(L)
print(H)


import math
(a, b, C) = map(float, input().split())
S = a * b * 0.5 * math.sin(math.radians(C))
c = (a ** 2 + b ** 2 - 2 * a * b * math.cos(math.radians(C))) ** 0.5
h = S * 2 / a
print(S)
print(a + b + c)
print(h)


(a, b, C) = map(int, input().split())
import math
C = math.radians(C)
S = 1 / 2 * a * b * math.sin(C)
L = a + b + (a ** 2 + b ** 2 - 2 * a * b * math.cos(C)) ** 0.5
h = b * math.sin(C)
print(S, L, h)


import math
(a, b, c) = map(float, input().split(' '))
S = a * b * math.sin(c * math.pi / 180.0) / 2.0
print(S)
L = a + b + math.sqrt(a * a + b * b - 2 * a * b * math.cos(c * math.pi / 180.0))
print(L)
h = b * math.sin(c * math.pi / 180.0)
print(h)


(a, b, c) = map(int, input().split())
import math
C = math.radians(c)
k = (a ** 2 + b ** 2 - 2 * a * b * math.cos(C)) ** 0.5
S = 0.5 * a * b * math.sin(C)
L = a + b + k
h = S * 2 / a
print(S)
print(L)
print(h)


import math
(a, b, c) = map(float, input().split())
c = c * math.pi / 180
S = 0.5 * a * b * math.sin(c)
d = (a ** 2 + b ** 2 - 2 * b * a * math.cos(c)) ** 0.5
L = a + b + d
h = b * math.sin(c)
print(S, L, h, end='\n')


import math
(a, b, c) = map(int, input().split())
s = a * b * math.sin(math.radians(c)) / 2
d = math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(math.radians(c)))
l = a + b + d
h = 2 * s / a
print(s)
print(l)
print(h)


import math
(a, b, C) = map(int, input().split())
S = 1 / 2 * a * b * math.sin(math.radians(C))
L = (a ** 2 + b ** 2 - 2 * a * b * math.cos(math.radians(C))) ** (1 / 2) + a + b
h = 2 * S / a
print(S)
print(L)
print(h)


import math
(a, b, C) = map(float, input().split())
s = a * b * math.sin(math.radians(C)) / 2
print(s)
c = math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(math.radians(C)))
l = a + b + c
print(l)
h = s * 2 / a
print(h)


import math
(a, b, C) = map(float, input().split())
rad = C * math.pi / 180
c = math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(rad))
S = a * b * math.sin(rad) / 2
L = a + b + c
h = b * math.sin(rad)
print(S)
print(L)
print(h)


import math
(a, b, C) = map(int, input().split())
C = C * math.pi / 180
S = a * b * math.sin(C) / 2
print(S, a + b + (a * a + b * b - 2 * a * b * math.cos(C)) ** 0.5, 2 * S / a, sep='\n')


import math
(a, b, C) = map(float, input().split())
c = math.sqrt(a * a + b * b - 2 * a * b * math.cos(C / 180 * math.pi))
h = b * math.sin(C / 180 * math.pi)
print(h * a / 2)
print(a + b + c)
print(h)


import math
(a, b, C) = list(map(float, input().split()))
C = math.radians(C)
h = b * math.sin(C)
S = a * h / 2
c = math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(C))
L = a + b + c
print(S)
print(L)
print(h)


import math
(a, b, c) = map(int, input().split())
s = a * b / 2 * math.sin(math.radians(c))
l = a + b + math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(math.radians(c)))
h = b * math.sin(math.radians(c))
print(s)
print(l)
print(h)


import math
(a, b, c) = map(float, input().split())
c *= math.pi / 180
print('{:.10f}\n{:.10f}\n{:.10f}'.format(a * b * math.sin(c) / 2, a + b + math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(c)), b * math.sin(c)))


import math
(a, b, C) = map(int, input().split())
s = a * b * math.sin(math.radians(C)) / 2
print(s)
print(a + b + math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(math.radians(C))))
print(2 * s / a)


import math
(a, b, C) = map(int, input().split(' '))
S = a * b * math.sin(math.radians(C)) * 0.5
L = a + b + math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(math.radians(C)))
h = 2 * S / a
print(S)
print(L)
print(h)


import math
(a, b, deg) = map(float, input().split())
rad = math.radians(deg)
s = a * b * math.sin(rad) / 2
c = math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(rad))
h = 2 * s / a
print('%.10f %.10f %.10f' % (s, a + b + c, h))


import math
(a, b, k) = map(int, input().split())
kr = math.radians(k)
c2 = a ** 2 + b ** 2 - 2 * a * b * math.cos(kr)
c = c2 ** (1 / 2)
S = 1 / 2 * a * b * math.sin(kr)
L = a + b + c
h = b * math.sin(kr)
print(S)
print(L)
print(h)


import math
(a, b, C) = list(map(int, input().split()))
s = a * b * math.sin(math.radians(C)) / 2
L = a + b + math.sqrt(a * a + b * b - 2 * a * b * math.cos(math.radians(C)))
H = b * math.sin(math.radians(C))
print(s)
print(L)
print(H)


import math
(a, b, C) = map(int, input().split())
C = math.radians(C)
S = a * b * math.sin(C) / 2
L = math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(C)) + a + b
h = b * math.sin(C)
print(S)
print(L)
print(h)


import math
(a, b, c) = map(float, input().split())
h = b * math.sin(math.radians(c))
s = 0.5 * a * h
l = a + b + (a ** 2 + b ** 2 - 2 * a * b * math.cos(math.radians(c))) ** 0.5
print(s)
print(l)
print(h)


import math
(a, b, C) = map(float, input().split())
s = math.radians(C)
h = b * math.sin(s)
S = a * h / 2
c = math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(s))
L = a + b + c
print(S, L, h, sep='\n')


import math
(A, B, R) = map(int, input().split())
rad = math.radians(R)
S = A * B * math.sin(rad) / 2
C = math.sqrt(A ** 2 + B ** 2 - 2 * A * B * math.cos(rad))
h = S / (0.5 * A)
print(S)
print(A + B + C)
print(h)


import math
(a, b, C) = map(float, input().split())
c = math.radians(C)
print(math.sin(c) * a * b / 2, a + b + math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(c)), b * math.sin(c))


import math
(a, b, c) = map(int, input().split())
print(a * b * math.sin(math.radians(c)) / 2)
print((a ** 2 + b ** 2 - 2 * a * b * math.cos(math.radians(c))) ** (1 / 2) + a + b)
print(a * b * math.sin(math.radians(c)) / a)


import math
(a, b, c) = map(int, input().split())
c = math.radians(c)
print(0.5 * a * b * math.sin(c))
print(a + b + math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(c)))
print(b * math.sin(c))


import math
from math import cos, sin
(a, b, C) = map(float, input().split())
C = math.radians(C)
S = 0.5 * a * b * sin(C)
L = math.sqrt(b ** 2 + a ** 2 - 2 * a * b * cos(C)) + a + b
h = 2 * S / a
print(S)
print(L)
print(h)


import math
(a, b, c) = map(int, input().split())
d = math.radians(c)
print(0.5 * a * b * math.sin(d))
e = math.sqrt(a * a + b * b - 2 * a * b * math.cos(d))
print(a + b + e)
print(b * math.sin(d))


import math
(a, b, c) = map(float, input().split())
C = math.radians(c)
S = a * b * math.sin(C) * 0.5
L = (a ** 2 + b ** 2 - 2.0 * a * b * math.cos(C)) ** 0.5 + a + b
h = 2 * S / a
print(S)
print(L)
print(h)


import math
(a, b, c) = map(int, input().split())
h = b * math.sin(math.radians(c))
s = a * h / 2
l = a + b + (a ** 2 + b ** 2 - 2 * a * b * math.cos(math.radians(c))) ** (1 / 2)
print(s)
print(l)
print(h)


from math import sin, cos, pi, sqrt
(a, b, C) = map(int, input().split())
h = b * sin(pi * C / 180)
S = a * h * 1 / 2
L = sqrt(a ** 2 + b ** 2 - 2 * a * b * cos(pi * C / 180)) + a + b
print(S)
print(L)
print(h)


from math import *
(a, b, c) = map(int, input().split())
theta = radians(c)
S = 0.5 * a * b * sin(theta)
H = 2 * S / a
L = sqrt(a * a + b * b - 2 * a * b * cos(theta)) + a + b
print('%f %f %f' % (S, L, H))


(a, b, c) = list(map(float, input().split()))
import math
print(math.sin(2 * c * math.pi / 360) * a * b * (1 / 2))
print(math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(2 * c * math.pi / 360)) + a + b)
print(math.sin(2 * c * math.pi / 360) * b)


import math
(a, b, c) = map(int, input().split())
h = b * math.sin(math.radians(c))
print(a * h / 2)
print(a + b + math.sqrt((a - b * math.cos(math.radians(c))) ** 2 + h ** 2))
print(h)


import math
(a, b, t) = map(int, input().split())
t = math.radians(t)
h = b * math.sin(t)
s = a * h / 2
c = math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(t))
l = a + b + c
print(s)
print(l)
print(h)


from math import sqrt, sin, cos, pi
(a, b, C) = map(int, input().split())
C *= pi / 180
print(a * b * sin(C) / 2)
print(sqrt(a ** 2 + b ** 2 - a * b * cos(C) * 2) + a + b)
print(b * sin(C))


import math
(a, b, C) = map(float, input().split())
C_rad = C / 180 * math.pi
H = b * math.sin(C_rad)
S = H * a / 2
L = math.sqrt((a - b * math.cos(C_rad)) ** 2 + H ** 2) + a + b
print(S)
print(L)
print(H)


import math
(a, b, c) = map(int, input().split())
S = 0.5 * a * b * math.sin(math.radians(c))
print(S)
print(a + b + math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(math.radians(c))))
print(2 * S / a)


import math
(a, b, c) = map(int, input().split())
c = math.radians(c)
S = 1 / 2 * (a * b * math.sin(c))
c2 = math.sqrt(a * a + b * b - 2 * a * b * math.cos(c))
H = a + b + c2
h = b * math.sin(c)
print(S, H, h)


from math import sin, radians, sqrt, cos
(a, b, C) = list(map(int, input().split()))
S = a * b * sin(radians(C)) / 2
print(S)
c = sqrt(a ** 2 + b ** 2 - 2 * a * b * cos(radians(C)))
print(a + b + c)
print(b * sin(radians(C)))


import math
(a, b, c) = map(int, input().split())
s = 0.5 * a * b * math.sin(math.radians(c))
l = a + b + math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(math.radians(c)))
h = b * math.sin(math.radians(c))
print('%.6f %.6f %.6f' % (s, l, h))


import math
(a, b, C) = map(int, input().split())
S = a * b * math.sin(C * math.pi / 180) / 2
L = a + b + (a ** 2 + b ** 2 - 2 * a * b * math.cos(C * math.pi / 180)) ** 0.5
h = 2 * S / a
print(S)
print(L)
print(h)


from math import *
(a, b, C) = map(int, input().split())
C = C * pi / 180
S = a * b * sin(C) / 2
print(S, a + b + (a * a + b * b - 2 * a * b * cos(C)) ** 0.5, 2 * S / a, sep='\n')


import math
(a, b, c) = map(int, input().split())
S = []
S += (a * b * math.sin(math.radians(c)) / 2,)
S += (math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(math.radians(c))) + a + b,)
S += (2 * S[0] / a,)
print(*S, sep='\n')


import math
(a, b, C) = map(int, input().split())
C = math.radians(C)
S = a * b * math.sin(C) / 2
c = math.sqrt(a * a + b * b - 2 * a * b * math.cos(C))
L = a + b + c
h = S * 2 / a
print(f'{S:.8f}')
print(f'{L:.8f}')
print(f'{h:.8f}')


import math
(a, b, c) = map(float, input().split())
c = math.radians(c)
h = b * math.sin(c)
s = a * h / 2
d = math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(c))
l = a + b + d
print(s, l, h)


import math
(a, b, C) = map(int, input().split())
S = 1 / 2 * a * b * math.sin(math.radians(C))
h = S * 2 / a
L = math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(math.radians(C))) + a + b
print(S)
print(L)
print(h)


import math
(a, b, C) = map(int, input().split())
θ = math.radians(C)
h = b * math.sin(θ)
S = a * h / 2
c = (a ** 2 + b ** 2 - 2 * a * b * math.cos(θ)) ** 0.5
L = a + b + c
print(S)
print(L)
print(h)


import math
(a, b, c) = map(float, input().split())
h = math.sin(math.radians(c))
cosA = math.cos(math.radians(c))
S = 0.5 * a * b * h
yogen = (a ** 2 + b ** 2 - 2 * a * b * cosA) ** 0.5
print(S)
print(a + b + yogen)
print(b * h)


import math
(a, b, x) = map(float, input().split())
h = b * math.sin(math.radians(x))
S = a * h / 2
L = a + b + math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(math.radians(x)))
print(S)
print(L)
print(h)


import math
(a, b, cdeg) = map(float, input().strip().split())
crad = cdeg * math.pi / 180
print(a * b / 2 * math.sin(crad))
print(a + b + math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(crad)))
print(b * math.sin(crad))


(a, b, C) = map(float, input().split())
import math
sinC = math.sin(math.radians(C))
S = a * b * sinC * 0.5
c = (a ** 2 + b ** 2 - 2 * a * b * math.cos(math.radians(C))) ** 0.5
L = a + b + c
h = S * 2 / a
print(S)
print(L)
print(h)


import math
(a, b, C) = map(float, input().split())
C = math.radians(C)
print(1 / 2 * a * b * math.sin(C))
c = (a ** 2 + b ** 2 - 2 * a * b * math.cos(C)) ** 0.5
print(a + b + c)
print(b * math.sin(C))


import math
(a, b, c) = map(float, input().split())
h = b * math.sin(math.pi * c / 180)
s = a * h / 2
l = a + b + math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(math.pi * c / 180))
print(s)
print(l)
print(h)


import math
(a, b, C) = list(map(int, input().split()))
C_radian = math.radians(C)
S = a * b * math.sin(C_radian) / 2
L = a + b + (a ** 2 + b ** 2 - 2 * a * b * math.cos(C_radian)) ** 0.5
h = b * math.sin(C_radian)
print(S)
print(L)
print(h)


import math
(a, b, C) = map(int, input().split())
c = (a ** 2 + b ** 2 - 2 * b * a * math.cos(math.radians(C))) ** 0.5
L = a + b + c
s = (a + b + c) / 2
S = (s * (s - a) * (s - b) * (s - c)) ** 0.5
h = 2 * S / a
print(S, L, h, sep='\n')


import math
(a, b, C) = map(float, input().split())
θ = math.radians(C)
h = b * math.sin(θ)
S = a * h / 2
c = math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(θ))
L = a + b + c
print(S, L, h)


import math
(a, b, C) = map(int, input().split())
S = a * b * math.sin(math.radians(C)) / 2
L = a + b + math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(math.radians(C)))
h = 2 * S / a
print(S)
print(L)
print(h)


import math
(a, b, c) = map(float, input().split())
print(0.5 * a * b * math.sin(math.radians(c)))
print(math.sqrt(a * a + b * b - 2 * a * b * math.cos(math.radians(c))) + a + b)
print(b * math.sin(math.radians(c)))


import math
(A, B, degree) = map(int, input().split())
C = math.sqrt(A * A + B * B - 2 * A * B * math.cos(math.radians(degree)))
S = A * B * math.sin(math.radians(degree)) / 2
h = S * 2 / A
print(S)
print(A + B + C)
print(h)


import math
(a, b, C) = map(float, input().split())
C *= math.pi / 180
print('%.8f' % (a * b * math.sin(C) / 2))
print('%.8f' % (a + b + (a * a + b * b - 2 * a * b * math.cos(C)) ** 0.5))
print('%.8f' % (b * math.sin(C)))


import math
(a, b, C) = map(float, input().split())
S = a * b * math.sin(math.radians(C)) / 2
r = (a ** 2 + b ** 2 - 2 * a * b * math.cos(math.radians(C))) ** (1 / 2)
L = a + b + r
h = 2 * S / a
print(S, L, h, sep='\n')


import math
(a, b, R) = map(int, input().split())
C = R * math.pi / 180
S = 0.5 * a * b * math.sin(C)
c = math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(C))
L = a + b + c
h = 2 * S / a
print(S)
print(L)
print(h)


import math
(a, b, c) = map(int, input().split())
c = math.radians(c)
S = a * b * math.sin(c) / 2
L = a + b + (a * a + b * b - 2 * a * b * math.cos(c)) ** 0.5
h = b * math.sin(c)
print(S)
print(L)
print(h)


import math
(a, b, c) = map(float, input().split())
n = math.radians(c)
d = (a ** 2 + b ** 2 - 2 * b * a * math.cos(n)) ** 0.5
h = b * math.sin(n)
l = a + b + d
s = a * h / 2
print(s)
print(l)
print(h)


import math
(a, b, c) = map(int, input().split())
rad = math.radians(c)
s = a * b * math.sin(rad) / 2
print(s)
edge = math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(rad))
print(a + b + edge)
print(s * 2 / a)


from math import *
(a, b, c) = map(int, input().split())
c = radians(c)
S = a * b * sin(c) / 2
print('%.10f %.10f %.10f' % (S, a + b + sqrt(a * a + b * b - 2 * a * b * cos(c)), 2 * S / a))


import math
(a, b, C) = map(int, input().split())
print(a * b * math.sin(math.radians(C)) / 2)
print(a + b + (a ** 2 + b ** 2 - 2 * a * b * math.cos(math.radians(C))) ** (1 / 2))
print(b * math.sin(math.radians(C)))


import math
(a, b, A) = map(float, input().split())
h = b * math.sin(math.radians(A))
S = a * h * 0.5
L = a + b + math.sqrt(pow(a, 2) + pow(b, 2) - 2 * a * b * math.cos(math.radians(A)))
print(S)
print(L)
print(h)


import math
(a, b, C) = map(float, input().split())
c = math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(math.radians(C)))
l = a + b + c
s = (a + b + c) / 2
S = s * (s - a) * (s - b) * (s - c)
S = math.sqrt(S)
h = S / a * 2
print(S)
print(l)
print(h)


import math
(a, b, c) = map(float, input().split())
r = c * (math.pi / 180)
h = b * math.sin(r)
S = 0.5 * a * h
L = a + b + math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(r))
print(S)
print(L)
print(h)


import math
(a, b, C) = map(int, input().split())
c = math.radians(C)
print(1 / 2 * a * b * math.sin(c))
print(a + b + math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(c)))
print(b * math.sin(c))


import math
(a, b, C) = [int(x) for x in input().split()]
C = math.radians(C)
l = a + b + math.sqrt(a * a + b * b - 2 * a * b * math.cos(C))
h = b * math.sin(C)
s = a * h / 2
print(s)
print(l)
print(h)


import math
(a, b, T) = map(float, input().split())
t = math.radians(T)
h = b * math.sin(t)
s = h * a / 2
c = ((a - b * math.cos(t)) ** 2 + h ** 2) ** 0.5
l = a + b + c
print(s, l, h)


import math
(a, b, C) = map(int, input().split())
C = C * math.pi / 180.0
c = math.sqrt(a ** 2 + b ** 2 - 2.0 * a * b * math.cos(C))
h = b * math.sin(C)
S = 0.5 * a * h
L = a + b + c
print(S)
print(L)
print(h)


import math
(a, b, c) = map(int, input().split())
print(0.5 * a * b * math.sin(math.radians(c)))
print(a + b + (a ** 2 + b ** 2 - 2 * a * b * math.cos(math.radians(c))) ** 0.5)
print(b * math.sin(math.radians(c)))


import math
(a, b, C) = map(float, input().split())
C = 2 * math.pi / 360 * C
S = 0.5 * a * b * math.sin(C)
L = a + b + math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(C))
h = b * math.sin(C)
print(S, L, h)


import math
(a, b, C) = map(int, input().split(' '))
sin = math.sin(math.radians(C))
cos = math.cos(math.radians(C))
print(a * b * sin / 2)
print(a + b + (a ** 2 + b ** 2 - 2 * a * b * cos) ** 0.5)
print(b * sin)


import math
(a, b, c) = map(float, input().split())
S = 0.5 * a * b * math.sin(c * math.pi / 180)
L = a + b + (a * a + b * b - 2 * a * b * math.cos(c * math.pi / 180)) ** 0.5
print(S, L, b * math.sin(c * math.pi / 180))


import math
(a, b, C) = map(float, input().split(' '))
S = a * b * math.sin(math.radians(C)) / 2.0
c = math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(math.radians(C)))
h = 2 * S / a
print(S)
print(a + b + c)
print(h)


import math
(a, b, c) = map(int, input().split())
s = a * b * math.sin(math.radians(c)) * 0.5
x = pow(a ** 2 + b ** 2 - 2 * a * b * math.cos(math.radians(c)), 0.5)
l = a + b + x
h = 2 * s / a
print(s, l, h)


import math
(a, b, Cdeg) = map(int, input().split())
Crad = math.radians(Cdeg)
c = (a ** 2 + b ** 2 - 2 * a * b * math.cos(Crad)) ** 0.5
h = b * math.sin(Crad)
print(0.5 * a * h)
print(a + b + c)
print(h)


import math
(a, b, C) = map(int, input().split())
h = math.sin(math.radians(C)) * b
S = a * h / 2
c = math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(math.radians(C)))
print(S)
print(a + b + c)
print(h)


from math import sin, cos, sqrt, pi
(a, b, c) = map(float, input().split())
h = b * sin(pi * c / 180)
print(a * h / 2)
print(a + b + sqrt(a * a + b * b - 2 * a * b * cos(pi * c / 180)))
print(h)


from math import sin, cos, pi, sqrt
(a, b, C) = map(int, input().split())
S = a * b * sin(C * pi / 180) / 2
c = sqrt(a ** 2 + b ** 2 - 2 * a * b * cos(C * pi / 180))
h = S * 2 / a
print(S)
print(a + b + c)
print(h)


import math
(a, b, C) = map(int, input().split())
rad = C / 180 * math.pi
h = b * math.sin(rad)
L = math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(rad)) + a + b
S = h * a / 2
print(S)
print(L)
print(h)


from math import sin, cos, pi
(a, b, C) = map(int, input().split())
Cr = C * pi / 180
print(0.5 * a * b * sin(Cr))
print(a + b + (a ** 2 + b ** 2 - 2 * a * b * cos(Cr)) ** 0.5)
print(b * sin(Cr))


import math
(a, b, c) = map(int, input().split())
r = c * (math.pi / 180)
h = b * math.sin(r)
S = a * h / 2
L = a + b + math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(r))
print(S)
print(L)
print(h)


import math
(a, b, x) = map(float, input().split())
h = b * math.sin(math.pi * x / 180)
c = (a ** 2 + b ** 2 - 2 * a * b * math.cos(math.pi * x / 180)) ** 0.5
print(a * h * 0.5)
print(a + b + c)
print(h)


from math import *
(a, b, c) = map(int, input().split())
c = c / 180 * pi
S = 0.5 * a * b * sin(c)
L = a + b + sqrt(a ** 2 + b ** 2 - 2 * a * b * cos(c))
h = S * 2 / a
print('{}'.format(S))
print('{}'.format(L))
print('{}'.format(h))


import math
(a, b, C) = map(float, input().split())
c1 = math.sin(math.radians(C))
c2 = math.cos(math.radians(C))
s = 1 / 2 * a * b * c1
d = (a * a + b * b - 2 * a * b * c2) ** (1 / 2)
L = a + b + d
h = b * c1
print(s)
print(L)
print(h)


import math as mp
(a, b, C) = map(int, input().split())
C = mp.radians(C)
print(0.5 * a * b * mp.sin(C))
print(a + b + mp.sqrt(a ** 2 + b ** 2 - 2 * a * b * mp.cos(C)))
print(b * mp.sin(C))


import math
(a, b, c) = map(float, input().split())
print(a * b * math.sin(math.radians(c)) / 2)
print(a + b + math.sqrt(pow(a, 2) + pow(b, 2) - 2 * a * b * math.cos(math.radians(c))))
print(a * b * math.sin(math.radians(c)) / a)


import math
n = list(map(int, input().split()))
a = n[0]
b = n[1]
c = n[2] * (math.pi / 180)
print(0.5 * a * b * math.sin(c))
print(a + b + math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(c)))
print(b * math.sin(c))


import math
(a, b, c) = map(int, input().split())
C = c / 180 * math.pi
S = a * b * math.sin(C) / 2
L = a + b + (a ** 2 + b ** 2 - 2 * a * b * math.cos(C)) ** 0.5
h = b * math.sin(C)
print('%.5f\n%.5f\n%.5f\n' % (S, L, h))


import math
(a, b, C) = map(int, input().split())
C = math.radians(C)
S = 1 / 2 * a * b * math.sin(C)
c = math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(C))
h = 2 * S / a
L = a + b + c
print(S, L, h)


import math
(a, b, c) = map(int, input().split())
radc = c * math.pi / 180
C = (a ** 2 + b ** 2 - 2 * a * b * math.cos(radc)) ** 0.5
S = a * b * math.sin(radc) * 0.5
h = 2 * S / a
print(S, a + b + C, h, sep='\n')


import math
(a, b, C) = map(int, input().split())
s = a * b * math.sin(math.radians(C)) / 2
c = (a ** 2 + b ** 2 - 2 * a * b * math.cos(math.radians(C))) ** (1 / 2)
h = s * 2 / a
print(f'{s:4f}')
print(f'{a + b + c:4f}')
print(f'{h:4f}')