The Department of economic development of IT City created a model of city development till year 2100.

To prepare report about growth perspectives it is required to get growth estimates from the model.

To get the growth estimates it is required to solve a quadratic equation. Since the Department of economic development of IT City creates realistic models only, that quadratic equation has a solution, moreover there are exactly two different real roots.

The greater of these roots corresponds to the optimistic scenario, the smaller one corresponds to the pessimistic one. Help to get these estimates, first the optimistic, then the pessimistic one.


-----Input-----

The only line of the input contains three integers a, b, c ( - 1000 ≤ a, b, c ≤ 1000) — the coefficients of ax^2 + bx + c = 0 equation.


-----Output-----

In the first line output the greater of the equation roots, in the second line output the smaller one. Absolute or relative error should not be greater than 10^{ - 6}.


-----Examples-----
Input
1 30 200

Output
-10.000000000000000
-20.000000000000000

Difficulty: EASY
Tags: Mathematics

Starter code:

Solutions:
(a, b, c) = map(int, input().split())
d = b ** 2 - 4 * a * c
ans2 = []
if a == 0 and c == 0:
	print('%.6f' % 0)
elif a == 0:
	ans = -1 * c / b
	print('%.6f' % ans)
elif d == 0:
	ans = -1 * b / (2 * a)
	print('%.6f' % ans)
else:
	ans = (-b + d ** 0.5) / (2 * a)
	ans1 = (-b - d ** 0.5) / (2 * a)
	ans2.append(ans)
	ans2.append(ans1)
	ans2.sort()
	print('%.6f' % ans2[1])
	print('%.6f' % ans2[0])


(a, b, c) = map(int, input().split())
d = b ** 2 - 4 * a * c
ans = [(-b + d ** 0.5) / (2 * a), (-b - d ** 0.5) / (2 * a)]
print('%.6f' % max(ans), '\n%.6f' % min(ans))


p = input().rstrip().split(' ')
a = int(p[0])
b = int(p[1])
c = int(p[2])
discriminant = (b ** 2 - 4 * a * c) ** 0.5
realroot1 = (-b + discriminant) / (2 * a)
realroot2 = (-b - discriminant) / (2 * a)
if realroot1 > realroot2:
	print(realroot1)
	print(realroot2)
else:
	print(realroot2)
	print(realroot1)


import math
l = input().split(' ')
a = int(l[0])
b = int(l[1])
c = int(l[2])
root1 = (-b + math.sqrt(b ** 2 - 4 * a * c)) / (2 * a)
root2 = (-b - math.sqrt(b ** 2 - 4 * a * c)) / (2 * a)
if root1 > root2:
	print(root1)
	print(root2)
else:
	print(root2)
	print(root1)


import math
(a, b, c) = map(int, input().split(' '))
plus = (-b + math.sqrt(b ** 2 - 4 * a * c)) / (2 * a)
minus = (-b - math.sqrt(b ** 2 - 4 * a * c)) / (2 * a)
print(max(plus, minus))
print(min(plus, minus))


import math
(a, b, c) = map(int, input().split())
d = math.sqrt(b * b - 4 * a * c)
x1 = (-b + d) / (2 * a)
x2 = (-b - d) / (2 * a)
print(max(x1, x2))
print(min(x1, x2))


import math
(a, b, c) = map(int, input().split())
o = (b * -1 + math.sqrt(b ** 2 - 4 * a * c)) / (2 * a)
p = (b * -1 - math.sqrt(b ** 2 - 4 * a * c)) / (2 * a)
print(max(o, p))
print(min(o, p))


(a, b, c) = map(int, input().split())
if a < 0:
	(a, b, c) = (-a, -b, -c)
d = (b * b - 4 * a * c) ** 0.5
x = (-b + d) / 2 / a
print(x)
print(-b / a - x)


(a, b, c) = input().split(' ')
a = int(a)
b = int(b)
c = int(c)
d = (b * b - 4 * a * c) ** 0.5
print('{:.15f}'.format(max((-b + d) / (2 * a), (-b - d) / (2 * a))))
print('{:.15f}'.format(min((-b + d) / (2 * a), (-b - d) / (2 * a))))


from math import *
(a, b, c) = map(int, input().split())
d = b ** 2 - 4 * a * c
r1 = (-b + sqrt(d)) / (2 * a)
r2 = (-b - sqrt(d)) / (2 * a)
print(max(r1, r2))
print(min(r1, r2))


from sys import stdin
line = stdin.readline().strip().split(' ')
a = int(line[0])
b = int(line[1])
c = int(line[2])
rt = (b * b - 4 * a * c) ** 0.5
denom = 2 * a
a1 = (-b + rt) / denom
a2 = (-b - rt) / denom
print(max(a1, a2))
print(min(a1, a2))


import math
line = input()
parts = line.split(' ')
a = int(parts[0])
b = int(parts[1])
c = int(parts[2])
root1 = (-b + math.sqrt(b ** 2 - 4 * a * c)) / (2 * a)
root2 = (-b - math.sqrt(b ** 2 - 4 * a * c)) / (2 * a)
print(max(root1, root2))
print(min(root1, root2))


from math import sqrt
(a, b, c) = map(int, input().split())
a1 = (-b + sqrt(b ** 2 - 4 * a * c)) / (2 * a)
a2 = (-b - sqrt(b ** 2 - 4 * a * c)) / (2 * a)
if a1 < a2:
	(a1, a2) = (a2, a1)
print(a1)
print(a2)


import sys
input = sys.stdin.readline

def ceil(x):
	if x != int(x):
		x = int(x) + 1
	return x

def factorial(x, m):
	val = 1
	while x > 0:
		val = val * x % m
		x -= 1
	return val

def fact(x):
	val = 1
	while x > 0:
		val *= x
		x -= 1
	return val

def swaparr(arr, a, b):
	temp = arr[a]
	arr[a] = arr[b]
	arr[b] = temp

def gcd(a, b):
	if b == 0:
		return a
	return gcd(b, a % b)

def lcm(a, b):
	return a * b // gcd(a, b)

def nCr(n, k):
	if k > n:
		return 0
	if k > n - k:
		k = n - k
	res = 1
	for i in range(k):
		res = res * (n - i)
		res = res / (i + 1)
	return int(res)

def upper_bound(a, x, lo=0, hi=None):
	if hi == None:
		hi = len(a)
	while lo < hi:
		mid = (lo + hi) // 2
		if a[mid] < x:
			lo = mid + 1
		else:
			hi = mid
	return lo

def primefs(n):
	primes = {}
	while n % 2 == 0 and n > 0:
		primes[2] = primes.get(2, 0) + 1
		n = n // 2
	for i in range(3, int(n ** 0.5) + 2, 2):
		while n % i == 0 and n > 0:
			primes[i] = primes.get(i, 0) + 1
			n = n // i
	if n > 2:
		primes[n] = primes.get(n, 0) + 1
	return primes

def power(x, y, p):
	res = 1
	x = x % p
	if x == 0:
		return 0
	while y > 0:
		if y & 1 == 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

def swap(a, b):
	temp = a
	a = b
	b = temp
	return (a, b)

def find(x, link):
	p = x
	while p != link[p]:
		p = link[p]
	while x != p:
		nex = link[x]
		link[x] = p
		x = nex
	return p

def union(x, y, link, size):
	x = find(x, link)
	y = find(y, link)
	if size[x] < size[y]:
		(x, y) = swap(x, y)
	if x != y:
		size[x] += size[y]
		link[y] = x

def sieve(n):
	prime = [True for i in range(n + 1)]
	(prime[0], prime[1]) = (False, False)
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	return prime
MAXN = int(100000.0 + 5)

def spf_sieve():
	spf[1] = 1
	for i in range(2, MAXN):
		spf[i] = i
	for i in range(4, MAXN, 2):
		spf[i] = 2
	for i in range(3, ceil(MAXN ** 0.5), 2):
		if spf[i] == i:
			for j in range(i * i, MAXN, i):
				if spf[j] == j:
					spf[j] = i
spf = [0 for i in range(MAXN)]

def factoriazation(x):
	res = []
	for i in range(2, int(x ** 0.5) + 1):
		while x % i == 0:
			res.append(i)
			x //= i
	if x != 1:
		res.append(x)
	return res

def int_array():
	return list(map(int, input().strip().split()))

def float_array():
	return list(map(float, input().strip().split()))

def str_array():
	return input().strip().split()
MOD = int(1000000000.0) + 7
CMOD = 998244353
INF = float('inf')
NINF = -float('inf')
from itertools import permutations
import math
from bisect import bisect_left

def solve():
	(a, b, c) = map(int, input().split())
	d1 = (-b + (b ** 2 - 4 * a * c) ** 0.5) / (2 * a)
	d2 = (-b - (b ** 2 - 4 * a * c) ** 0.5) / (2 * a)
	ans = sorted((d1, d2))
	print('{:.9f}'.format(ans[1]))
	print('{:.9f}'.format(ans[0]))
for _ in range(1):
	solve()


from math import sqrt
s = input()
(a, b, c) = map(int, s.split(' '))
D = b * b - 4 * a * c
x1 = (-b + sqrt(D)) / (2 * a)
x2 = (-b - sqrt(D)) / (2 * a)
if x1 < x2:
	print(x2, x1, sep='\n')
else:
	print(x1, x2, sep='\n')


from math import sqrt
(a, b, c) = map(int, input().split())
x = -b + sqrt(b * b - 4 * a * c)
x = x / a * 2
w = -b - sqrt(b * b - 4 * a * c)
w = w / a * 2
z = max(w, x)
q = min(w, x)
print(z / 4)
print(q / 4)


import math
(a, b, c) = list(map(int, input().split()))
delta = b * b - 4 * a * c
x1 = (-b + math.sqrt(delta)) / (2 * a)
x2 = (-b - math.sqrt(delta)) / (2 * a)
if x1 > x2:
	print(x1)
	print(x2)
else:
	print(x2)
	print(x1)


(a, b, c) = input().split()
(a, b, c) = (int(a), int(b), int(c))
d = (b ** 2 - 4 * a * c) ** 0.5
print((-b + (d if a >= 0 else -d)) / 2 / a, (-b - (d if a >= 0 else -d)) / 2 / a, sep='\n')


(a, b, c) = map(int, input().split())
d = b ** 2 - 4 * a * c
x = (-b + d ** 0.5) / (2 * a)
y = (-b - d ** 0.5) / (2 * a)
print(max(x, y), min(x, y), sep='\n')


from decimal import Decimal
(a, b, c) = map(Decimal, input().split())
d = (b * b - Decimal('4') * a * c).sqrt()
if a >= 0:
	print((-b + d) / (Decimal('2') * a))
	print((-b - d) / (Decimal('2') * a))
else:
	print((-b - d) / (Decimal('2') * a))
	print((-b + d) / (Decimal('2') * a))


import math
l = [int(s) for s in input().split(' ')]
(a, b, c) = (l[0], l[1], l[2])
delta = b * b - 4 * a * c
x1 = (-b - math.sqrt(delta)) / (2 * a)
x2 = (-b + math.sqrt(delta)) / (2 * a)
print(max(x1, x2))
print(min(x1, x2))


import math

def eq(s):
	a = s[0]
	b = s[1]
	c = s[2]
	det = math.sqrt(b * b - 4 * (a * c))
	sol1 = (-b + det) / (2 * a)
	sol2 = (-b - det) / (2 * a)
	print(max(sol1, sol2))
	print(min(sol1, sol2))
	return 0
eq(list(map(int, input().split())))


(a, b, c) = map(int, input().split())
(x, y) = ((-b - pow(b * b - 4 * a * c, 0.5)) / (2 * a), (-b + pow(b * b - 4 * a * c, 0.5)) / (2 * a))
print(max(x, y))
print(min(x, y))


from math import sqrt
(a, b, c) = map(int, input().split())
x = [(-b + sqrt(b ** 2 - 4 * a * c)) / (2.0 * a), (-b - sqrt(b ** 2 - 4 * a * c)) / (2.0 * a)]
x.sort(key=None, reverse=True)
print(x[0])
print(x[1])


import math
from math import *
(a, b, c) = map(float, input().split(' '))
d = float(b * b - 4 * a * c)
if round((-b + sqrt(d)) / (2 * a), 15) >= round((-b - sqrt(d)) / (2 * a), 15):
	print(round((-b + sqrt(d)) / (2 * a), 15))
	print(round((-b - sqrt(d)) / (2 * a), 15))
else:
	print(round((-b - sqrt(d)) / (2 * a), 15))
	print(round((-b + sqrt(d)) / (2 * a), 15))


(a, b, c) = map(int, input().split(' '))
delta = b * b - 4 * a * c
x1 = (-b + delta ** 0.5) / a / 2
x2 = (-b - delta ** 0.5) / a / 2
output = '{:.15f}\n{:.15f}'
if x1 > x2:
	print(output.format(x1, x2))
else:
	print(output.format(x2, x1))


import math
(a, b, c) = list(map(int, input().split()))
D = math.sqrt(b * b - 4 * a * c)
x1 = (-b + D) / (2 * a)
x2 = (-b - D) / (2 * a)
if D == 0:
	print(max(x1, x2))
else:
	print(max(x1, x2))
	print(min(x1, x2))


import time
import math
(a, b, c) = (int(i) for i in input().split())
start = time.time()
if a < 0:
	a = -a
	b = -b
	c = -c
D = b * b - 4 * a * c
print((-b + math.sqrt(D)) / (2 * a))
print((-b - math.sqrt(D)) / (2 * a))
finish = time.time()


from math import *
(a, b, c) = [int(t) for t in input().split()]
d = b * b - 4 * a * c
l = (-b + sqrt(d)) / (2 * a)
r = (-b - sqrt(d)) / (2 * a)
print(max(l, r), min(l, r), sep='\n')


import math
from operator import add, sub
(a, b, c) = map(int, input().split())
ops = [add, sub]
for op in ops if a > 0 else ops[::-1]:
	print(op(-b, math.sqrt(b * b - 4 * a * c)) / (2 * a))


(a, b, c) = map(int, input().split())
d = b ** 2 - 4 * a * c
r1 = (-b - d ** 0.5) / (2 * a)
r2 = (-b + d ** 0.5) / (2 * a)
print(max(r1, r2))
print(min(r1, r2))


import math as ma
(a, b, c) = [int(x) for x in input().split()]
print(max((-b + ma.sqrt(b ** 2 - 4 * a * c)) / (2 * a), (-b - ma.sqrt(b ** 2 - 4 * a * c)) / (2 * a)))
print(min((-b + ma.sqrt(b ** 2 - 4 * a * c)) / (2 * a), (-b - ma.sqrt(b ** 2 - 4 * a * c)) / (2 * a)))


import math

def main():
	(a, b, c) = map(int, input().split())
	D = b * b - 4 * a * c
	x1 = (-b + math.sqrt(D)) / (2 * a)
	x2 = (-b - math.sqrt(D)) / (2 * a)
	print(max(x1, x2))
	print(min(x1, x2))
main()


(a, b, c) = map(int, input().split())
D = b ** 2 - 4 * a * c
x1 = (-b + D ** 0.5) / (2 * a)
x2 = (-b - D ** 0.5) / (2 * a)
print(max(x1, x2))
print(min(x1, x2))


(a, b, c) = map(int, input().split(' '))
sqrt = (b ** 2 - 4 * a * c) ** 0.5
ans1 = (-b + sqrt) / (2 * a)
ans2 = (-b - sqrt) / (2 * a)
print(max(ans1, ans2))
print(min(ans1, ans2))


(a, b, c) = map(int, input().split())
t = (b ** 2 - 4 * a * c) ** 0.5
x = (-b + t) / 2 / a
y = (-b - t) / 2 / a
if x < y:
	(x, y) = (y, x)
print(x)
print(y)


import math
(a, b, c) = map(int, input().split())
d = b ** 2 - 4 * a * c
(e, f) = ((-b - math.sqrt(d)) / (2 * a), (-b + math.sqrt(d)) / (2 * a))
print(max(e, f))
print(min(e, f))


import math
arr = [int(x) for x in input().split()]
a = arr[0]
b = arr[1]
c = arr[2]
num = -1 * b + math.sqrt(b * b - 4 * a * c)
den = 2 * a
ans1 = num / den
num = -1 * b - math.sqrt(b * b - 4 * a * c)
den = 2 * a
ans2 = num / den
if ans1 >= ans2:
	print('%.9f' % ans1)
	print('%.9f' % ans2)
else:
	print('%.9f' % ans2)
	print('%.9f' % ans1)


(a, b, c) = map(int, input().split())
if a + b + c == 0:
	print(max(1, c / a))
	print(min(1, c / a))
elif a - b + c == 0:
	print(max(-1, -c / a))
	print(min(-1, -c / a))
else:
	d = b ** 2 - 4 * a * c
	x1 = (-b + d ** 0.5) / (2 * a)
	x2 = (-b - d ** 0.5) / (2 * a)
	print(max(x1, x2))
	print(min(x1, x2))


from math import sqrt
(a, b, c) = [int(i) for i in input().split()]
x1 = (b * -1 - sqrt(b ** 2 - 4 * a * c)) / (2 * a)
x2 = (b * -1 + sqrt(b ** 2 - 4 * a * c)) / (2 * a)
print(max(x1, x2), min(x1, x2), sep='\n')


import math
import sys
(a, b, c) = map(int, sys.stdin.readline().split())
d = b ** 2 - 4 * a * c
sol1 = (-b - math.sqrt(d)) / (2 * a)
sol2 = (-b + math.sqrt(d)) / (2 * a)
if sol1 > sol2:
	print(sol1)
	print(sol2)
else:
	print(sol2)
	print(sol1)


(a, b, c) = map(int, input().split())
print(max((-b - (b ** 2 - 4 * a * c) ** 0.5) / (2 * a), (-b + (b ** 2 - 4 * a * c) ** 0.5) / (2 * a)))
print(min((-b - (b ** 2 - 4 * a * c) ** 0.5) / (2 * a), (-b + (b ** 2 - 4 * a * c) ** 0.5) / (2 * a)))


(a, b, c) = map(int, input().split())
x1 = (-b + (b ** 2 - 4 * a * c) ** 0.5) / (2 * a)
x2 = (-b - (b ** 2 - 4 * a * c) ** 0.5) / (2 * a)
print(max(x1, x2), min(x1, x2), sep='\n')


(a, b, c) = list(map(int, input().split()))
val = []
val.append((-b + (b ** 2 - 4 * a * c) ** 0.5) / (2 * a))
val.append((-b - (b ** 2 - 4 * a * c) ** 0.5) / (2 * a))
print(max(val), min(val))


from math import sqrt
(a, b, c) = map(int, input().split())
d = b ** 2 - 4 * a * c
x1 = (-b + sqrt(d)) / (2 * a)
x2 = (-b - sqrt(d)) / (2 * a)
if x1 > x2:
	print(x1)
	print(x2)
else:
	print(x2)
	print(x1)


import math
(a, b, c) = [int(i) for i in input().split()]
disc = math.sqrt(b * b - 4 * a * c)
neg = (-b - disc) / (2 * a)
pos = (-b + disc) / (2 * a)
print(max(neg, pos))
print(min(neg, pos))


from decimal import *
from math import sqrt

def __starting_point():
	getcontext().prec = 50
	(a, b, c) = map(Decimal, input().split())
	d = Decimal(sqrt(b * b - 4 * a * c))
	res1 = (d - b) / (2 * a)
	res2 = (-d - b) / (2 * a)
	print(max(res1, res2))
	print(min(res1, res2))
__starting_point()


import math
entrada = input().split(' ')
a = int(entrada[0])
b = int(entrada[1])
c = int(entrada[2])
x1 = (-b + math.sqrt(b ** 2 - 4 * a * c)) / (2 * a)
x2 = (-b - math.sqrt(b ** 2 - 4 * a * c)) / (2 * a)
if x1 > x2:
	print(str('%8.16f' % x1))
	print(str('%8.16f' % x2))
else:
	print(str('%8.16f' % x2))
	print(str('%8.16f' % x1))


from math import factorial as f
(a, b, c) = map(int, input().split())
d = (b * b - 4 * a * c) ** 0.5
t = [(-b - d) / 2 / a, (-b + d) / 2 / a]
for i in reversed(sorted(t)):
	print(i)


import math
s = input().split()
a = float(s[0])
b = float(s[1])
c = float(s[2])
d = math.sqrt(b * b - 4 * a * c)
print(max((-b + d) / (2 * a), (-b - d) / (2 * a)))
print(min((-b + d) / (2 * a), (-b - d) / (2 * a)))


from functools import reduce
from math import factorial
(a, b, c) = [int(x) for x in input().split()]
sq = (b ** 2 - 4 * a * c) ** 0.5
(x, y) = ((-b + sq) / (2 * a), (-b - sq) / (2 * a))
if a < 0:
	(x, y) = (y, x)
print(x)
print(y)


abc = [int(i) for i in input().split()]
a = abc[0]
b = abc[1]
c = abc[2]
x = (-b + (b ** 2 - 4 * a * c) ** 0.5) / (2 * a)
y = (-b - (b ** 2 - 4 * a * c) ** 0.5) / (2 * a)
print(max(x, y))
print(min(x, y))


from math import sqrt
(a, b, c) = map(int, input().split())
x = (-b + sqrt(b ** 2 - 4 * a * c)) / (2 * a)
y = (-b - sqrt(b ** 2 - 4 * a * c)) / (2 * a)
print(max(x, y))
print(min(x, y))


(a, b, c) = list(map(int, input().split()))
di = (b ** 2 - 4 * a * c) ** (1 / 2)
if a > 0:
	print((-b + di) / (2 * a))
	print((-b - di) / (2 * a))
else:
	print((-b - di) / (2 * a))
	print((-b + di) / (2 * a))


(a, b, c) = map(int, input().split())
delta = (b ** 2 - 4 * a * c) ** 0.5
x = (-b + delta) / (2 * a)
x_ = (-b - delta) / (2 * a)
print(max(x, x_), min(x, x_), sep='\n')


import sys

def fact(k):
	return k ** 2 * (k - 1) ** 2 * (k - 2) ** 2 * (k - 3) ** 2 * (k - 4) ** 2
(a, b, c) = [int(x) for x in input().split()]
d = b * b - 4 * a * c
x1 = (-b - d ** 0.5) / 2 / a
x2 = (-b + d ** 0.5) / 2 / a
print(max([x1, x2]))
print(min([x1, x2]))


from decimal import *
s = input().split()
getcontext().prec = 1000
a = int(s[0])
b = int(s[1])
c = int(s[2])
disc = Decimal(b * b - 4 * a * c)
x = Decimal((0 - b + disc.sqrt()) / (2 * a))
y = Decimal((0 - b - disc.sqrt()) / (2 * a))
print(max(x, y))
print(min(x, y))


from math import sqrt
(a, b, c) = list(map(int, input().split()))
disc = b ** 2 - 4 * a * c
x1 = (-b - sqrt(disc)) / (2 * a)
x2 = (-b + sqrt(disc)) / (2 * a)
print(max(x1, x2))
print(min(x1, x2))


(a, b, c) = map(int, input().split())
d = (b ** 2 - 4 * a * c) ** 0.5 / 2 / a
b = -b / 2 / a
c = sorted((b - d, b + d))
print('{:.9f}\n{:.9f}'.format(c[1], c[0]))


def main():
	(a, b, c) = (int(x) for x in input().split())
	plus = quadraticEqPlus(a, b, c)
	minus = quadraticEqMinus(a, b, c)
	print(max(plus, minus))
	print(min(plus, minus))

def quadraticEqPlus(a, b, c):
	return (-b + (b ** 2 - 4 * a * c) ** 0.5) / (2 * a)

def quadraticEqMinus(a, b, c):
	return (-b - (b ** 2 - 4 * a * c) ** 0.5) / (2 * a)
main()


(a, b, c) = map(int, input().split())
if a < 0:
	a *= -1
	b *= -1
	c *= -1
d = (b * b - 4 * a * c) ** 0.5
print((-b + d) / 2 / a, (-b - d) / 2 / a, sep='\n')


(a, b, c) = map(int, input().split(' '))
import math

def determinant(plus):
	sign = -1
	if plus:
		sign = 1
	return (-b + sign * math.sqrt(b * b - 4 * a * c)) / (2 * a)
x1 = determinant(True)
x2 = determinant(False)
if x1 > x2:
	print(x1)
	print(x2)
else:
	print(x2)
	print(x1)


from itertools import combinations, accumulate, groupby, count
from sys import stdout, stdin, setrecursionlimit
from io import BytesIO, IOBase
from collections import *
from random import *
from bisect import *
from string import *
from queue import *
from heapq import *
from math import *
from os import *
from re import *

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = read(self._fd, max(fstat(self._fd).st_size, 8192))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = read(self._fd, max(fstat(self._fd).st_size, 8192))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(stdin, stdout) = (IOWrapper(stdin), IOWrapper(stdout))

def fast():
	return stdin.readline().strip()

def zzz():
	return [int(i) for i in fast().split()]
(z, zz) = (fast, lambda : list(map(int, z().split())))
(szz, graph, mod, szzz) = (lambda : sorted(zz()), {}, 10 ** 9 + 7, lambda : sorted(zzz()))

def lcd(xnum1, xnum2):
	return xnum1 * xnum2 // gcd(xnum1, xnum2)

def output(answer, end='\n'):
	stdout.write(str(answer) + end)
dx = [-1, 1, 0, 0, 1, -1, 1, -1]
dy = [0, 0, 1, -1, 1, -1, -1, 1]
(a, b, c) = zzz()
x1 = (-b + sqrt(b * b - 4 * a * c)) / (2 * a)
x2 = (-b - sqrt(b * b - 4 * a * c)) / (2 * a)
print(max(x1, x2), min(x1, x2))


import math
(a, b, c) = [int(x) for x in input().split()]
x = b * b * 1.0 - 4.0 * a * c
x = math.sqrt(x)
x1 = (-1.0 * b + x) / (2.0 * a)
x2 = (-1.0 * b - x) / (2.0 * a)
if x1 > x2:
	print('%.10f' % x1)
	print('%.10f' % x2)
else:
	print('%.10f' % x2)
	print('%.10f' % x1)


(a, b, c) = map(int, input().split())
d = sorted([(-b + (b ** 2 - 4 * a * c) ** 0.5) / (2 * a), (-b - (b ** 2 - 4 * a * c) ** 0.5) / (2 * a)])
print(str(d[1]) + '\n' + str(d[0]))


def main():
	from math import sqrt
	(a, b, c) = map(float, input().split())
	b = b / a
	c = c / a
	r = sqrt(b ** 2 - 4 * c)
	print(str((-b + r) / 2) + '\n' + str((-b - r) / 2))
main()


import math
v = str(input())
v = v.split(' ')
(a, b, c) = (int(v[0]), int(v[1]), int(v[2]))
x1 = (-b + math.sqrt(b ** 2 - 4 * a * c)) / (2 * a)
x2 = (-b - math.sqrt(b ** 2 - 4 * a * c)) / (2 * a)
if x1 > x2:
	print(x1, x2)
else:
	print(x2, x1)


(a, b, c) = map(int, input().split())
D = b * b - 4 * a * c
x1 = (-b + D ** (1 / 2)) / (2 * a)
x2 = (-b - D ** (1 / 2)) / (2 * a)
if x1 >= x2:
	print(float(x1))
	print(float(x2))
else:
	print(float(x2))
	print(float(x1))


import math
(a, b, c) = map(int, input().split())
p = (-1 * b + (b ** 2 - 4 * a * c) ** 0.5) / (2 * a)
q = (-1 * b - (b ** 2 - 4 * a * c) ** 0.5) / (2 * a)
print(max(p, q))
print(min(p, q))


from sys import stdin
inFile = stdin
tokens = []
tokens_next = 0

def next_str():
	global tokens, tokens_next
	while tokens_next >= len(tokens):
		tokens = inFile.readline().split()
		tokens_next = 0
	tokens_next += 1
	return tokens[tokens_next - 1]

def nextInt():
	return int(next_str())
a = nextInt()
b = nextInt()
c = nextInt()
f = -b + (b * b - 4 * a * c) ** 0.5
f /= 2 * a
s = -b - (b * b - 4 * a * c) ** 0.5
s /= 2 * a
print(max(f, s))
print(min(f, s))


X = list(map(int, input().split(' ')))
D = X[1] ** 2 - 4 * X[0] * X[2]
print(max((-X[1] + D ** (1 / 2)) / (2 * X[0]), (-X[1] - D ** (1 / 2)) / (2 * X[0])))
print(min((-X[1] + D ** (1 / 2)) / (2 * X[0]), (-X[1] - D ** (1 / 2)) / (2 * X[0])))


(a, b, c) = map(int, input().split())
D = b * b - 4 * a * c
x1 = (-b + D ** 0.5) / (2 * a)
x2 = (-b - D ** 0.5) / (2 * a)
if x1 > x2:
	print(x1, x2)
else:
	print(x2, x1)


(a, b, c) = map(int, input().split())
d = (b * b - 4 * a * c) ** 0.5
x = (-b + d) / 2 / a
y = (-b - d) / 2 / a
(x, y) = sorted([x, y])
print(y)
print(x)


(a, b, c) = list(map(int, input().split()))
D = b * b - 4 * a * c
x = (-b + D ** 0.5) / 2 / a
y = (-b - D ** 0.5) / 2 / a
print(max(x, y))
print(min(x, y))


from math import sqrt
(a, b, c) = input().split()
(a, b, c) = (float(a), float(b), float(c))
rD = sqrt(b * b - 4 * a * c)
roots = ((-b + rD) / (2 * a), (-b - rD) / (2 * a))
print(max(roots))
print(min(roots))


(a, b, c) = map(int, input().split())
z = (-b - (b ** 2 - 4 * a * c) ** 0.5) / (2 * a)
z1 = (-b + (b ** 2 - 4 * a * c) ** 0.5) / (2 * a)
print(max(z, z1), min(z, z1), sep='\n')


import math
a = input('').split(' ')
print(max((-float(a[1]) - (float(a[1]) ** 2 - 4 * float(a[0]) * float(a[2])) ** 0.5) / 2 / float(a[0]), (-float(a[1]) + (float(a[1]) ** 2 - 4 * float(a[0]) * float(a[2])) ** 0.5) / 2 / float(a[0])))
print(min((-float(a[1]) + (float(a[1]) ** 2 - 4 * float(a[0]) * float(a[2])) ** 0.5) / 2 / float(a[0]), (-float(a[1]) - (float(a[1]) ** 2 - 4 * float(a[0]) * float(a[2])) ** 0.5) / 2 / float(a[0])))


ln = input().split(' ')
a = int(ln[0])
b = int(ln[1])
c = int(ln[2])
d = (b ** 2 - 4 * a * c) ** 0.5
if a > 0:
	print((-b + d) / (2 * a))
	print((-b - d) / (2 * a))
else:
	print((-b - d) / (2 * a))
	print((-b + d) / (2 * a))


from math import sqrt
(a, b, c) = [int(x) for x in input().split()]
x1 = (-b + sqrt(b * b - 4 * a * c)) / a / 2
x2 = (-b - sqrt(b * b - 4 * a * c)) / a / 2
if x1 <= x2:
	print(x2)
	print(x1)
else:
	print(x1)
	print(x2)


def main():
	(a, b, c) = map(int, input().split())
	delta = (b * b - 4 * a * c) ** 0.5
	for value in sorted(((-b + delta) / (2 * a), (-b - delta) / (2 * a)), reverse=True):
		print(value)
main()


from math import sqrt
(a, b, c) = map(int, input().split())
d = b * b - 4 * a * c
print('{:.15f}'.format(max((-b - sqrt(d)) / (2 * a), (-b + sqrt(d)) / (2 * a))))
print('{:.15f}'.format(min((-b - sqrt(d)) / (2 * a), (-b + sqrt(d)) / (2 * a))))


from math import sqrt
(a, b, c) = map(float, input().split())
x = [0, 0]
x[0] = (-b + sqrt(b * b - 4.0 * a * c)) / (2.0 * a)
x[1] = (-b - sqrt(b * b - 4.0 * a * c)) / (2.0 * a)
print('%.10f' % max(x), '%.10f' % min(x), sep='\n')


import math
x = input().split()
a = int(x[0])
b = int(x[1])
c = int(x[2])
t = math.sqrt(b * b - 4 * a * c)
print(max((t - b) / (2 * a), (-t - b) / (2 * a)))
print(min((t - b) / (2 * a), (-t - b) / (2 * a)))


(a, b, c) = map(int, input().split())
if a > 0:
	print((-b + (b * b - 4 * a * c) ** 0.5) / (2 * a))
	print((-b - (b * b - 4 * a * c) ** 0.5) / (2 * a))
elif a < 0:
	print((-b - (b * b - 4 * a * c) ** 0.5) / (2 * a))
	print((-b + (b * b - 4 * a * c) ** 0.5) / (2 * a))
else:
	print(-c / b)
	print(-c / b)


(a, b, c) = map(int, input().split())
list(map(lambda x: print('%.9f' % x), sorted([(-b + (b ** 2 - 4 * a * c) ** 0.5) / (2 * a), (-b - (b ** 2 - 4 * a * c) ** 0.5) / (2 * a)], reverse=True)))


from math import sqrt

def equation(a, b, c):
	if a != 0:
		d = b ** 2 - 4 * a * c
		if d > 0 and a > 0:
			x1 = (-b - sqrt(d)) / (2 * a)
			x2 = (-b + sqrt(d)) / (2 * a)
			if x1 < x2:
				return (format(x2, '.7f'), format(x1, '.7f'))
			else:
				return (format(x1, '.7f'), format(x2, '.7f'))
		if d > 0 and a < 0:
			x1 = (-b + sqrt(d)) / (2 * a)
			x2 = (-b - sqrt(d)) / (2 * a)
			return (format(x2, '.7f'), format(x1, '.7f'))
		elif d == 0:
			x = -b / (2 * a)
			return [format(x, '.7f')]
		else:
			return [format(0, '.7f')]
	elif b == c == 0:
		return [-1]
	elif b != 0:
		x = -c / b
		return [format(x, '.7f')]
	else:
		return [format(0, '.7f')]
(A, B, C) = [int(i) for i in input().split()]
print(*equation(A, B, C), sep='\n')


(a, b, c) = list(map(int, input().split()))
d = b ** 2 - 4 * a * c
x1 = (-b + d ** 0.5) / (2 * a)
x2 = (-b - d ** 0.5) / (2 * a)
(x1, x2) = (min(x1, x2), max(x1, x2))
print(x2)
print(x1)


import math
(a, b, c) = map(int, input().split())
D = b ** 2 - 4 * a * c
x1 = (-b + math.sqrt(D)) / (2 * a)
x2 = (-b - math.sqrt(D)) / (2 * a)
ans1 = max(x1, x2)
ans = min(x1, x2)
print(ans1)
print(ans)


import math as ma
(a, b, c) = list(map(int, input().split()))
d = ma.sqrt(b ** 2 - 4 * a * c)
e = [(-b + d) / (2 * a), (-b - d) / (2 * a)]
print(max(e))
print(min(e))


import os, sys, pdb
import time, calendar, datetime
import math, itertools
import operator as op
from functools import reduce

def ncr(n, r):
	r = min(r, n - r)
	numer = reduce(op.mul, range(n, n - r, -1), 1)
	denom = reduce(op.mul, range(1, r + 1), 1)
	return numer // denom
(a, b, c) = list(map(int, input().split()))
x1 = (-b + math.sqrt(b * b - 4 * a * c)) / (2 * a)
x2 = (-b - math.sqrt(b * b - 4 * a * c)) / (2 * a)
print(max(x1, x2))
print(min(x1, x2))


(a, b, c) = map(int, input().split())
d = b * b - 4 * a * c
r1 = (-b + d ** 0.5) / (2 * a)
r2 = (-b - d ** 0.5) / (2 * a)
if r1 < r2:
	(r1, r2) = (r2, r1)
print(r1)
print(r2)


from math import sqrt
(a, b, c) = map(int, input().split())
x1 = (-b + sqrt(b * b - 4 * a * c)) / 2.0 / a
x2 = (-b - sqrt(b * b - 4 * a * c)) / 2.0 / a
print('%0.6f\n%0.6f' % (max(x1, x2), min(x1, x2)))


(a, b, c) = map(int, input().split())
k = (b ** 2 - 4 * a * c) ** 0.5
n1 = (-b + k) / (2 * a)
n2 = (-b - k) / (2 * a)
print(max(n1, n2), '\n' + str(min(n1, n2)))


(a, b, c) = list(map(int, str(input()).split()))
d = b ** 2 - 4 * a * c
if d <= 0:
	exit()
d = d ** 0.5
x = (-b + d) / (2 * a)
y = (-b - d) / (2 * a)
if x > y:
	print(x)
	print(y)
else:
	print(y)
	print(x)


import math
[a, b, c] = map(int, input().split(' '))
sqrt = math.sqrt
r1 = (-b - sqrt(b * b - 4 * a * c)) / (2 * a)
r2 = (-b + sqrt(b * b - 4 * a * c)) / (2 * a)
if r1 > r2:
	print(r1)
	print(r2)
else:
	print(r2)
	print(r1)


import sys
import math

def main():
	(a, b, c) = map(int, input().split())
	d = b ** 2 - 4 * a * c
	x1 = (-b - math.sqrt(d)) / (2 * a)
	x2 = (-b + math.sqrt(d)) / (2 * a)
	if x1 < x2:
		t = x1
		x1 = x2
		x2 = t
	print('{0:.10f}\n{1:.10f}'.format(x1, x2))
main()


import math
(a, b, c) = map(float, input().split())
d = math.sqrt(b * b - 4 * a * c)
print('%.6f' % max((-b + d) / (2 * a), (-b - d) / (2 * a)))
print('%.6f' % min((-b + d) / (2 * a), (-b - d) / (2 * a)))


import math
(a, b, c) = map(int, input().split())
d = math.sqrt(b ** 2 - 4 * a * c)
b *= -1
a *= 2
print(max((b - d) / a, (b + d) / a))
print(min((b - d) / a, (b + d) / a))


(a, b, c) = map(int, input().split())
b /= 2 * a
d = (b * b - c / a) ** 0.5
print(d - b, -b - d)


import math
(a, b, c) = input().split()
a = int(a)
b = int(b)
c = int(c)
x = (-b + math.sqrt(b ** 2 - 4 * a * c)) / (2 * a)
y = (-b - math.sqrt(b ** 2 - 4 * a * c)) / (2 * a)
if x < y:
	print(y)
	print(x)
if y < x:
	print(x)
	print(y)


from sys import stdin, stdout
from math import gcd, ceil, sqrt
ii1 = lambda : int(stdin.readline().strip())
is1 = lambda : stdin.readline().strip()
iia = lambda : list(map(int, stdin.readline().strip().split()))
isa = lambda : stdin.readline().strip().split()
mod = 1000000007
(a, b, c) = iia()
one = (-b + sqrt(b ** 2 - 4 * a * c)) / (2 * a)
two = (-b - sqrt(b ** 2 - 4 * a * c)) / (2 * a)
if one > two:
	print(one, two, sep='\n')
else:
	print(two, one, sep='\n')


from sys import stdout, stdin, setrecursionlimit
from io import BytesIO, IOBase
from collections import *
from itertools import *
from random import *
from bisect import *
from string import *
from queue import *
from heapq import *
from math import *
from re import *
from os import *

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = read(self._fd, max(fstat(self._fd).st_size, 8192))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = read(self._fd, max(fstat(self._fd).st_size, 8192))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(stdin, stdout) = (IOWrapper(stdin), IOWrapper(stdout))
(graph, mod, szzz) = ({}, 10 ** 9 + 7, lambda : sorted(zzz()))

def getStr():
	return input()

def getInt():
	return int(input())

def listStr():
	return list(input())

def getStrs():
	return input().split()

def isInt(s):
	return '0' <= s[0] <= '9'

def input():
	return stdin.readline().strip()

def zzz():
	return [int(i) for i in input().split()]

def output(answer, end='\n'):
	stdout.write(str(answer) + end)

def lcd(xnum1, xnum2):
	return xnum1 * xnum2 // gcd(xnum1, xnum2)

def lcm(xnum1, xnum2):
	return xnum1 * xnum2 // gcd(xnum1, xnum2)
dx = [-1, 1, 0, 0, 1, -1, 1, -1]
dy = [0, 0, 1, -1, 1, -1, -1, 1]
daysInMounth = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
(a, b, c) = zzz()
d = b * b - 4 * a * c
(x, y) = ((-b + d ** 0.5) / (2 * a), (-b - d ** 0.5) / (2 * a))
print(max(x, y), min(x, y))


from sys import stdin
from math import sqrt
(a, b, c) = map(int, stdin.readline().split())
p = b / a
q = c / a
root1 = -p / 2 + sqrt(p * p / 4 - q)
root2 = -p / 2 - sqrt(p * p / 4 - q)
print(root1)
print(root2)


from math import *
(a, b, c) = map(int, input().split())
delta = b * b - 4 * a * c
x = [(-b + sqrt(delta)) / (2 * a), (-b - sqrt(delta)) / (2 * a)]
print(max(x[0], x[1]))
print(min(x[0], x[1]))


from math import *
(a, b, c) = [int(x) for x in input().split()]
f = (-b + sqrt(b * b - 4 * a * c)) / (2 * a)
s = (-b - sqrt(b * b - 4 * a * c)) / (2 * a)
print(max(f, s), min(f, s), sep='\n')


(a, b, c) = map(int, input().split())
delt = (b * b - 4 * a * c) ** 0.5
x1 = (-b + delt) / (2 * a)
x2 = (-b - delt) / (2 * a)
if x1 < x2:
	t = x1
	x1 = x2
	x2 = t
print(x1)
print(x2)


import math
n = input().split(' ')
a = int(n[0])
b = int(n[1])
c = int(n[2])
d = b ** 2 - 4 * a * c
r1 = (-b + math.sqrt(d)) / (2 * a)
r2 = (-b - math.sqrt(d)) / (2 * a)
print('%.8f\n%.8f' % (max(r1, r2), min(r1, r2)))


(a, b, c) = [int(j) for j in input().split()]
D = b ** 2 - 4 * a * c
D = pow(D, 0.5)
s1 = (D - b) / (2 * a)
b *= -1
s2 = (b - D) / (2 * a)
print(max(s1, s2))
print(min(s1, s2))


import math
z = input().split()
a = int(z[0])
b = int(z[1])
c = int(z[2])
d = b ** 2 - 4 * a * c
x1 = (-b - math.sqrt(d)) / (2 * a)
x2 = (-b + math.sqrt(d)) / (2 * a)
print(max(x1, x2))
print(min(x1, x2))


from math import sqrt
(a, b, c) = map(int, input().split())
x1 = (-b + sqrt(b * b - 4 * a * c)) / (2 * a)
x2 = (-b - sqrt(b * b - 4 * a * c)) / (2 * a)
print(round(max(x1, x2), 10))
print(round(min(x1, x2), 10))


import math
tab = [int(i) for i in input().split()]
de = pow(tab[1], 2) - 4 * tab[0] * tab[2]
x1 = (-tab[1] - math.sqrt(de)) / (2 * tab[0])
x2 = (-tab[1] + math.sqrt(de)) / (2 * tab[0])
print('{:10.10f}'.format(max(x1, x2)))
print('{:10.10f}'.format(min(x1, x2)))


from math import sqrt as sq
(a, b, c) = map(int, input().split())
d = b ** 2 - 4 * a * c
x = [(-b + sq(d)) / (2 * a), (-b - sq(d)) / (2 * a)]
x.sort()
print(x[1])
print(x[0])


from math import *
(a, b, c) = map(int, input().split())
Delta = b ** 2 - 4 * a * c
x1 = (-b - sqrt(Delta)) / (2 * a)
x2 = (-b + sqrt(Delta)) / (2 * a)
if x1 > x2:
	(x2, x1) = (x1, x2)
x2 = '%.7f' % x2
x1 = '%.7f' % x1
print(x2[:-1])
print(x1[:-1])


(a, b, c) = map(int, input().split())
D = pow(b * b - 4 * a * c, 0.5)
res1 = (-b + D) / 2 / a
res2 = (-b - D) / 2 / a
print(max(res1, res2))
print(min(res2, res1))


import re
import math
st = input()
s = re.split('[\\s]', st)
a = int(s[0])
b = int(s[1])
c = int(s[2])
d = b * b - 4 * a * c
x1 = (-b + math.sqrt(d)) / 2 / a
x2 = (-b - math.sqrt(d)) / 2 / a
if x1 > x2:
	print(x1)
	print(x2)
else:
	print(x2)
	print(x1)


import math
(a, b, c) = map(int, input().split(' '))
if a < 0:
	(a, b, c) = (-a, -b, -c)
delta = b * b - 4 * a * c
print((-b + math.sqrt(delta)) / 2 / a)
print((-b - math.sqrt(delta)) / 2 / a)


(a, b, c) = (int(_) for _ in input().split())
d = b * b - 4 * a * c
x = [(-b - d ** 0.5) / 2 / a, (-b + d ** 0.5) / 2 / a]
x.sort()
print(x[1])
print(x[0])


import math

def main():
	(a, b, c) = input().split(' ')
	(a, b, c) = (int(a), int(b), int(c))
	D = math.sqrt(b * b - 4 * a * c)
	(x1, x2) = ((-b + D) / (2 * a), (-b - D) / (2 * a))
	if x1 < x2:
		(x1, x2) = (x2, x1)
	print(x1)
	print(x2)
main()


(a, b, c) = list(map(int, input().split()))
d = (b * b - 4 * a * c) ** 0.5
(p, q) = ((-b + d) / (2 * a), (-b - d) / (2 * a))
print(max(p, q))
print(min(p, q))


(a, b, c) = map(int, input().split())
D = (b * b - 4 * a * c) ** 0.5
ans1 = (-b + D) / (2 * a)
ans2 = (-b - D) / (2 * a)
if ans1 < ans2:
	(ans1, ans2) = (ans2, ans1)
print(ans1)
print(ans2)


(a, b, c) = map(int, input().split())
if a < 0:
	(a, b, c) = (-a, -b, -c)
import math
x1 = (-b + math.sqrt(b ** 2 - 4 * a * c)) / (2 * a)
x2 = (-b - math.sqrt(b ** 2 - 4 * a * c)) / (2 * a)
print(x1)
print(x2)


(a, b, c) = map(float, input().split())
q = (b * b - 4 * a * c) ** 0.5
x = (-b + q) / (2 * a)
y = (-b - q) / (2 * a)
print(max(x, y))
print(min(x, y))


from math import sqrt

def main():
	(a, b, c) = map(int, input().split())
	(delta, twoOfa) = (sqrt(b * b - 4 * a * c), 2 * a)
	for value in sorted(((-b + delta) / twoOfa, (-b - delta) / twoOfa), reverse=True):
		print(value)
main()


(a, b, c) = (int(s) for s in input().split())
d = b * b - 4 * a * c
x1 = (-b + d ** 0.5) / (2 * a)
x2 = (-b - d ** 0.5) / (2 * a)
print(max(x1, x2))
print(min(x1, x2))


from decimal import *
(a, b, c) = map(Decimal, input().split())
delta = Decimal(b ** 2 - Decimal(4) * a * c).sqrt()
x1 = Decimal((-b + delta) / (Decimal(2) * a))
x2 = Decimal((-b - delta) / (Decimal(2) * a))
print(Decimal(max(x1, x2)))
print(Decimal(min(x1, x2)))


(a, b, c) = [int(x) for x in input().split()]
z = (b ** 2 - 4 * a * c) ** 0.5
r1 = (-b - z) / (2 * a)
r2 = (-b + z) / (2 * a)
if r1 > r2:
	print(r1)
	print(r2)
else:
	print(r2)
	print(r1)


import math
(a, b, c) = map(int, input().split())
x1 = (-b + math.sqrt(b * b - 4 * a * c)) / 2 / a
x2 = (-b - math.sqrt(b * b - 4 * a * c)) / 2 / a
if x1 < x2:
	x = x1
	x1 = x2
	x2 = x
print('{:.15f}'.format(x1))
print('{:.15f}'.format(x2))


import math
(a, b, c) = input().split()
a = int(a)
b = int(b)
c = int(c)
if (-b + math.sqrt(b * b - 4 * a * c)) / (2 * a) > (-b - math.sqrt(b * b - 4 * a * c)) / (2 * a):
	print((-b + math.sqrt(b * b - 4 * a * c)) / (2 * a))
	print((-b - math.sqrt(b * b - 4 * a * c)) / (2 * a))
else:
	print((-b - math.sqrt(b * b - 4 * a * c)) / (2 * a))
	print((-b + math.sqrt(b * b - 4 * a * c)) / (2 * a))


(a, b, c) = map(float, input().split())
d = (b ** 2.0 - 4.0 * a * c) ** 0.5
if a > 0.0:
	print((-b + d) / 2.0 / a)
	print((-b - d) / 2.0 / a)
else:
	print((-b - d) / 2.0 / a)
	print((-b + d) / 2.0 / a)


line = input()
(a, b, c) = [int(x) for x in line.split()]
D = (b ** 2 - 4 * a * c) ** (1 / 2)
x1 = (-b + D) / (a * 2)
x2 = (-b - D) / (a * 2)
if x1 > x2:
	print(x1)
	print(x2)
else:
	print(x2)
	print(x1)


(a, b, c) = map(int, input().split())
data = sorted([(-b + (b ** 2 - 4 * a * c) ** 0.5) / (2 * a), (-b - (b ** 2 - 4 * a * c) ** 0.5) / (2 * a)])
print(data[1])
print(data[0])


import sys, math
input = sys.stdin.readline

def HalfDead():
	(a, b, c) = map(float, input().split())
	d = (b * b - 4 * a * c) ** 0.5
	x1 = (-b + d) / (2 * a)
	x2 = (-b - d) / (2 * a)
	res = [x1, x2]
	res.sort(reverse=True)
	print(res[0])
	print(res[1])
HalfDead()


def main():
	(a, b, c) = map(float, input().split())
	b *= 0.5
	d = (b * b - a * c) ** 0.5
	res = ((d - b) / a, -(d + b) / a)
	print(max(res))
	print(min(res))
main()


(a, b, c) = map(int, input().split())
a = float(a)
b = float(b)
c = float(c)
d = (b ** 2.0 - 4.0 * a * c) ** 0.5
x = (-b + d) / (2 * a)
y = (-b - d) / (2 * a)
if y > x:
	print(y)
	print(x)
else:
	print(x)
	print(y)


import sys
from math import *
input = sys.stdin.buffer.readline
(a, b, c) = map(int, input().split())
x1 = (-b + sqrt(b * b - 4 * a * c)) / (2 * a)
x2 = (-b - sqrt(b * b - 4 * a * c)) / (2 * a)
print(max(x1, x2))
print(min(x1, x2))


(a, b, c) = [int(x) for x in input().split()]
for x in reversed(sorted([(-b + (b ** 2 - 4 * a * c) ** 0.5) / (2 * a), (-b - (b ** 2 - 4 * a * c) ** 0.5) / (2 * a)])):
	print(x)


x = list(map(int, input().split(' ')))
d = x[1] ** 2 - 4 * x[0] * x[2]
print(max((-x[1] + d ** (1 / 2)) / (2 * x[0]), (-x[1] - d ** (1 / 2)) / (2 * x[0])))
print(min((-x[1] + d ** (1 / 2)) / (2 * x[0]), (-x[1] - d ** (1 / 2)) / (2 * x[0])))


import re, sys, string, operator, functools, fractions, collections
sys.setrecursionlimit(10 ** 7)
dX = [-1, 1, 0, 0, -1, 1, -1, 1]
dY = [0, 0, -1, 1, 1, -1, -1, 1]
RI = lambda x=' ': list(map(int, input().split(x)))
RS = lambda x=' ': input().rstrip().split(x)
mod = int(1000000000.0 + 7)
eps = 1e-06
(a, b, c) = RI()
d = pow(b * b - 4 * a * c, 0.5)
r1 = (-b + d) / (2 * a)
r2 = (-b - d) / (2 * a)
if r1 < r2:
	(r1, r2) = (r2, r1)
print('%.20f\n%.20f' % (r1, r2))


(a, b, c) = map(int, input().split())
delta = b * b - 4 * a * c
x_1 = (-b + delta ** 0.5) / (2 * a)
x_2 = (-b - delta ** 0.5) / (2 * a)
if x_1 < x_2:
	(x_1, x_2) = (x_2, x_1)
print(x_1)
print(x_2)


(a, b, c) = map(int, input().split())
dsqrt = (b * b - 4 * a * c) ** 0.5
sol1 = (-b + dsqrt) / (2.0 * a)
sol2 = (-b - dsqrt) / (2.0 * a)
if not sol1 > sol2:
	(sol1, sol2) = (sol2, sol1)
print('%10.10f' % sol1)
print('%10.10f' % sol2)


def main():
	(a, b, c) = map(int, input().split())
	c = (b * b - 4 * a * c) ** 0.5
	(a, b) = ((-b + c) / (2 * a), (-b - c) / (2 * a))
	if a > b:
		print(a)
		print(b)
	else:
		print(b)
		print(a)
main()


(a, b, c) = map(int, input().split(' '))
d = -b + (b ** 2 - 4 * a * c) ** 0.5
e = -b - (b ** 2 - 4 * a * c) ** 0.5
d /= 2 * a
e /= 2 * a
if d > e:
	print(d)
	print(e)
else:
	print(e)
	print(d)


(a, b, c) = input().split()
a = int(a)
b = int(b)
c = int(c)
y = b ** 2 - 4 * a * c
d = (-b - y ** (1 / 2)) / (2 * a)
g = (-b + y ** (1 / 2)) / (2 * a)
if g > d:
	print(g)
	print(d)
else:
	print(d)
	print(g)


import math
(a, b, c) = map(lambda x: int(x), input().split(' '))
d = b ** 2 - 4 * a * c
(x1, x2) = (max((-b + d ** 0.5) / 2 / a, (-b - d ** 0.5) / 2 / a), min((-b + d ** 0.5) / 2 / a, (-b - d ** 0.5) / 2 / a))
print(x1, x2)


from math import sqrt
(a, b, c) = map(int, input().split())
x = (-b + sqrt(b * b - 4 * a * c)) / (2 * a)
y = (-b - sqrt(b * b - 4 * a * c)) / (2 * a)
if x > y:
	print(x)
	print(y)
else:
	print(y)
	print(x)


from math import sqrt
from decimal import *
getcontext().prec = 1000
(ia, ib, ic) = map(int, input().split())
a = Decimal(ia)
b = Decimal(ib)
c = Decimal(ic)
d = b * b - 4 * a * c
x1 = (-b + d.sqrt()) / (2 * a)
x2 = (-b - d.sqrt()) / (2 * a)
if ic == 0:
	if ib > 0:
		x1 = 0
	else:
		x2 = 0
(x1, x2) = (max(x1, x2), min(x1, x2))
print(x1)
print(x2)