You are given an equation: 

Ax2 + Bx + C = 0. 

Your task is to find the number of distinct roots of the equation and print all of them in ascending order.

Input

The first line contains three integer numbers A, B and C ( - 105 ≤ A, B, C ≤ 105). Any coefficient may be equal to 0.

Output

In case of infinite root count print the only integer -1. In case of no roots print the only integer 0. In other cases print the number of root on the first line and the roots on the following lines in the ascending order. Print roots with at least 5 digits after the decimal point.

Examples

Input

1 -5 6


Output

2
2.0000000000
3.0000000000

Difficulty: HARD
Tags: Mathematics

Starter code:

Solutions:
(a, b, c) = map(float, input().split())
D = b ** 2 - 4 * a * c
if D < 0:
	print(0)
elif a == 0 and b == 0 and (c != 0):
	print(0)
elif a == 0 and b == 0 and (c == 0):
	print(-1)
elif a == 0:
	x0 = c / -b
	print(1)
	print(x0)
elif b == 0:
	print(1)
	print(0)
elif D == 0 and (a > 0 or a < 0):
	x = -b / (2 * a)
	print(1)
	print(x)
elif D > 0 and (a > 0 or a < 0):
	x1 = (-b + D ** 0.5) / (2 * a)
	x2 = (-b - D ** 0.5) / (2 * a)
	print(2)
	g = [x1, x2]
	for i in sorted(g):
		print(i)


s = [int(n) for n in input().split()]
if s[0] == 0 and s[1] * s[2] != 0:
	print(1)
	print(-s[2] / s[1])
elif s[0] * s[1] != 0 and s[2] == 0:
	print(2)
	a = 0
	b = -s[1] / s[0]
	p = [a, b]
	print('%6f' % min(p))
	print('%6f' % max(p))
elif s[0] * s[2] < 0 and s[1] == 0:
	print(2)
	p = [(-s[2] / s[0]) ** 0.5, -(-s[2] / s[0]) ** 0.5]
	print('%.6f' % min(p))
	print('%.6f' % max(p))
elif s[0] == 0 and s[1] == 0 and (s[2] != 0):
	print(0)
elif s[0] == s[1] == s[2] == 0:
	print(-1)
elif s[0] * s[1] * s[2] != 0:
	if s[1] ** 2 < 4 * (s[0] * s[2]):
		print(0)
	elif s[1] ** 2 == 4 * (s[0] * s[2]):
		print(1)
		print('%.6f' % (-s[1] / (2 * s[0])))
	else:
		print(2)
		j = (-s[1] + (s[1] ** 2 - 4 * s[0] * s[2]) ** 0.5) / (2 * s[0])
		k = (-s[1] - (s[1] ** 2 - 4 * s[0] * s[2]) ** 0.5) / (2 * s[0])
		p = [j, k]
		print('%.6f' % min(p))
		print('%.6f' % max(p))
elif s[0] == s[2] == 0 and s[1] != 0:
	print(1)
	print('%6f' % 0)
elif s[2] == s[1] == 0 and s[0] != 0:
	print(1)
	print('%6f' % 0)
elif s[0] * s[2] != 0 and s[1] == 0:
	if s[0] * s[2] > 0:
		print(0)
	else:
		print(2)
		print('%6f' % -(-s[2] / s[0]) ** 0.5)
		print('%6f' % (-s[2] / s[0]) ** 0.5)


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


import math
(a, b, c) = input().split()
a = int(a)
b = int(b)
c = int(c)
if a == 0:
	if b == 0:
		if c == 0:
			print(-1)
		else:
			print(0)
	elif c == 0:
		print(1, 0.0, sep='\n')
	else:
		print(1, -c / b, sep='\n')
elif c == 0:
	if b == 0:
		print(1, 0.0, sep='\n')
	else:
		print(2, min(0.0, -b / a), max(0.0, -b / a), sep='\n')
elif b == 0:
	if c / a > 0:
		print(0)
	else:
		print(2, min(-math.sqrt(-c / a), math.sqrt(-c / a)), max(-math.sqrt(-c / a), math.sqrt(-c / a)), sep='\n')
elif b ** 2 < 4 * a * c:
	print(0)
elif b ** 2 == 4 * a * c:
	print(1, -b / (2 * a), sep='\n')
else:
	print(2, min((-b - math.sqrt(b ** 2 - 4 * a * c)) / (2 * a), (-b + math.sqrt(b ** 2 - 4 * a * c)) / (2 * a)), max((-b - math.sqrt(b ** 2 - 4 * a * c)) / (2 * a), (-b + math.sqrt(b ** 2 - 4 * a * c)) / (2 * a)), sep='\n')


(a, b, c) = map(int, input().split())
(ch1, ch2, ch3) = (a == 0, b == 0, c == 0)
if ch1 and ch2 and ch3:
	answer = -1
elif ch1 and ch2:
	answer = 0
elif ch1 and ch3 or (ch2 and ch3):
	answer = 1
	answers = [0]
elif ch1:
	answer = 1
	answers = [-c / b]
elif ch2:
	if -c / a > 0:
		answer = 2
		answers = [-(-c / a) ** 0.5, (-c / a) ** 0.5]
	else:
		answer = 0
elif ch3:
	answer = 2
	answers = [-b / a, 0]
else:
	D = b ** 2 - 4 * a * c
	if D > 0:
		answer = 2
		answers = [(-b + D ** 0.5) / (2 * a), (-b - D ** 0.5) / (2 * a)]
	elif D == 0:
		answer = 1
		answers = [-b / (2 * a)]
	else:
		answer = 0
print(answer)
if answer > 0:
	for i in sorted(answers):
		print(i)


(a, b, c) = list(map(int, input().strip().split()))
import sys
if a == 0:
	if b == 0:
		if c == 0:
			print(-1)
			sys.exit(0)
		else:
			print(0)
			sys.exit(0)
	else:
		print(1)
		print(-c / b)
		sys.exit(0)
else:
	(a, b, c) = (1, b / a, c / a)
	if b == 0:
		if c == 0:
			print(1)
			print('{0:.10f}'.format(0))
			sys.exit(0)
		if c < 0:
			print(2)
			print('{0:.10f}'.format(-c ** 0.5))
			print('{0:.10f}'.format(c ** 0.5))
			sys.exit(0)
		if c > 0:
			print(0)
	elif c == 0:
		nicli = set([0])
		nicli.add(-b)
		print(len(nicli))
		for e in sorted(list(nicli)):
			print('{0:.10f}'.format(e))
		sys.exit(0)
	else:
		d = b * b - 4 * a * c
		if d < 0:
			print(0)
			sys.exit(0)
		elif abs(d) < 10 ** (-12):
			print(1)
			print('{0:.10f}'.format(-b / (2 * a)))
			sys.exit(0)
		else:
			x1 = max((-b + d ** 0.5) / (2 * a), (-b - d ** 0.5) / (2 * a))
			x2 = c / x1
			koreni = set()
			koreni.add(round(x1, 10))
			koreni.add(round(x2, 10))
			koreni = sorted(list(koreni))
			print(len(koreni))
			for e in koreni:
				print('{0:.10f}'.format(e))
			sys.exit(0)


from decimal import *
(a, b, c) = map(int, input().split())
if a != 0:
	if b ** 2 - 4 * a * c < 0:
		print(0)
	else:
		arr = [(-b + (b ** 2 - 4 * a * c) ** 0.5) / (2 * a), (-b - (b ** 2 - 4 * a * c) ** 0.5) / (2 * a)]
		if max(arr) == min(arr):
			print(1)
			print(float(Decimal(arr[0])))
		else:
			print(len(arr))
			print(float(Decimal(min(arr))))
			print(float(Decimal(max(arr))))
elif a == 0 and b != 0:
	print(1)
	print(float(Decimal(-c / b)))
elif a == b == c == 0:
	print(-1)
else:
	print(0)


from math import sqrt
(a, b, c) = list(map(int, input().split()))
if a == 0 and b == 0 and (c == 0):
	print(-1)
elif a == 0 and b == 0:
	print(0)
elif a == 0:
	print(1)
	ans = -1 * c / b
	print(ans)
else:
	d = b * b - 4 * a * c
	if d < 0:
		print(0)
	elif d > 0:
		print(2)
		d = sqrt(d)
		ans1 = (-b - d) / (2 * a)
		ans2 = (-b + d) / (2 * a)
		if ans1 < ans2:
			(ans1, ans2) = (ans2, ans1)
		print(ans2)
		print(ans1)
	else:
		print(1)
		ans = -b / (2 * a)
		print(ans)


(a, b, c) = map(int, input().split())
d = b * b - 4 * a * c
if a == 0:
	if b == 0 and c == 0:
		print(-1)
	elif b == 0:
		print(0)
	else:
		print(f'1\n{-c / b}')
elif d < 0:
	print(0)
else:
	s = sorted({(-b + d ** 0.5) / (2 * a), (-b - d ** 0.5) / (2 * a)})
	print(len(s))
	for i in s:
		print(f'{i:.5f}')


import math as m
(a, b, c) = [int(s) for s in input().split()]
if a == 0:
	if b == 0:
		if c == 0:
			print(-1)
		else:
			print(0)
	else:
		print(1)
		print(-c / b)
else:
	if a < 0:
		(a, b, c) = (-a, -b, -c)
	d = b ** 2 - 4 * a * c
	if d > 0:
		print(2)
		print((-b - m.sqrt(d)) / (2 * a))
		print((-b + m.sqrt(d)) / (2 * a))
	elif d == 0:
		print(1)
		print(-b / (2 * a))
	else:
		print(0)


def shovel(a, b, c):
	if a == 0 and b == 0 and (c == 0):
		return -1
	if a == 0 and b == 0:
		return 0
	if a == 0:
		print(1)
		return '%.5f' % (-c / b)
	if b == 0:
		if c == 0:
			print(1)
			return '%.5f' % 0
	x = b * b - 4 * a * c
	if x < 0:
		return 0
	if x == 0:
		print(1)
		return '%.5f' % (-b / (2 * a))
	y = (-b - x ** 0.5) / (2 * a)
	z = (-b + x ** 0.5) / (2 * a)
	print(2)
	if y < z:
		print('%.5f' % y)
		return '%.5f' % z
	print('%.5f' % z)
	return '%.5f' % y
(a, b, c) = map(int, input().split())
print(shovel(a, b, c))


(a, b, c) = map(int, input().split())
d = b ** 2 - 4 * a * c
if a == b == 0 == c:
	print(-1)
elif d < 0 or a == b == 0:
	print(0)
elif d == 0:
	print(1)
	print('{0:5f}'.format(round(-b / (2 * a), 5)))
elif a == 0:
	print(1)
	x = round(-c / b, 5)
	print('{0:5f}'.format(x))
else:
	print(2)
	x = '{0:5f}'.format(round((-b + d ** 0.5) / (2 * a), 5))
	y = '{0:5f}'.format(round((-b - d ** 0.5) / (2 * a), 5))
	(x, y) = sorted([x, y])
	if x != y:
		print(x, y, sep='\n')
	else:
		print(x)


(a, b, c) = list(map(int, input().split()))
if a == 0 and b == 0 and (c == 0):
	print(-1)
elif b * b < 4 * a * c:
	print(0)
elif a == 0:
	if b == 0:
		print(0)
	else:
		print(1)
		print('{0:.5f}'.format(-(c / b)))
else:
	d = b * b - 4 * a * c
	x1 = (-b + d ** 0.5) / (2 * a)
	x2 = (-b - d ** 0.5) / (2 * a)
	if x1 == x2:
		print(1)
		print('{0:.5f}'.format(x1))
	else:
		print(2)
		print('{0:.5f}'.format(min(x1, x2)))
		print('{0:.5f}'.format(max(x1, x2)))


from math import sqrt
(a, b, c) = map(int, input().split())
det = b * b - 4 * a * c
if a == 0:
	if b == 0 and c == 0:
		print(-1)
	elif b == 0:
		print(0)
	else:
		print(1)
		p = round(-c / b, 5)
		print(p)
elif det < 0:
	print(0)
elif det == 0:
	print(1)
	p = round(-b / (a * 2), 5)
	print(p)
else:
	print(2)
	neu = -b + sqrt(det)
	p = round(neu / (2 * a), 5)
	neu = -b - sqrt(det)
	q = round(neu / (2 * a), 5)
	if p > q:
		(p, q) = (q, p)
	print(p)
	print(q)


(a, b, c) = [int(a) for a in input().split()]
if a == 0:
	if b == 0:
		if c == 0:
			print(-1)
		else:
			print(0)
	else:
		print(1)
		print(-c / b)
else:
	D = b ** 2 - 4 * a * c
	if D == 0:
		print(1)
		print(-b / (2 * a))
	elif D < 0:
		print(0)
	else:
		print(2)
		ans = sorted([(-b - D ** 0.5) / (2 * a), (-b + D ** 0.5) / (2 * a)])
		print(*ans, sep='\n')


import math
(a, b, c) = map(int, input().split())
if a == 0:
	if b == 0 and c == 0:
		print(-1)
	elif b == 0 and c != 0:
		print(0)
	else:
		x = -c / b
		print(1)
		print('{:.10f}'.format(x))
else:
	delta = pow(b, 2) - 4 * a * c
	if delta < 0:
		print(0)
	elif delta == 0:
		x = -b / (2 * a)
		print(1)
		print('{:.10f}'.format(x))
	else:
		x1 = (-b - math.sqrt(delta)) / (2 * a)
		x2 = (-b + math.sqrt(delta)) / (2 * a)
		print(2)
		if x1 > x2:
			print('{:.10f}'.format(x2))
			print('{:.10f}'.format(x1))
		else:
			print('{:.10f}'.format(x1))
			print('{:.10f}'.format(x2))


(a, b, c) = list(map(int, input().split()))
if a != 0:
	k = b * b - 4 * a * c
	if k < 0:
		print(0)
	else:
		a1 = (-b + k ** 0.5) / (2 * a)
		a2 = (-b - k ** 0.5) / (2 * a)
		if a1 == a2:
			print(1)
			print(str(a1) + '0' * 5)
		if a1 != a2:
			print(2)
			print(str(min(a1, a2)) + '0' * 5)
			print(str(max(a1, a2)) + '0' * 5)
elif b != 0:
	k = str(-c / b)
	print(1)
	print(k + '0' * 5)
elif c == 0:
	print(-1)
else:
	print(0)


import math
(a, b, c) = map(int, input().split())
sqr = float(b ** 2 - 4 * a * c)
if sqr >= 0:
	e = float(math.sqrt(sqr))
	if e == 0:
		try:
			root1 = float((-b - e) / (2 * a))
			root = 1
			print(root)
			print('%.5f' % root1)
		except ZeroDivisionError as zd:
			if c == 0:
				print('-1')
			elif a & b == 0:
				print('0')
			else:
				pass
	elif e == 13.416407864998739:
		try:
			if a == 0:
				root = 1
				print(root)
				res = -c / b
				print(res)
			else:
				root1 = float((-b - e) / (2 * a))
				root2 = float((-b + e) / (2 * a))
				roots = 2
				print(roots)
				print('%.10f' % root2)
				print('%.10f' % root1)
		except ZeroDivisionError as zd:
			print('-1')
	elif e == 5.0:
		try:
			if a == 0:
				root = 1
				print(root)
				res = -c / b
				print(res)
			else:
				root1 = float((-b - e) / (2 * a))
				root2 = float((-b + e) / (2 * a))
				roots = 2
				print(roots)
				print('%.10f' % root2)
				print('%.10f' % root1)
		except ZeroDivisionError as zd:
			print('-1')
	elif e == 4.0:
		try:
			if a == 0:
				root = 1
				print(root)
				res = -c / b
				print(res)
			else:
				root1 = float((-b - e) / (2 * a))
				root2 = float((-b + e) / (2 * a))
				roots = 2
				print(roots)
				print('%.10f' % root2)
				print('%.10f' % root1)
		except ZeroDivisionError as zd:
			print('-1')
	else:
		try:
			if a == 0:
				root = 1
				print(root)
				res = -c / b
				print(res)
			else:
				root1 = float((-b - e) / (2 * a))
				root2 = float((-b + e) / (2 * a))
				roots = 2
				print(roots)
				print('%.10f' % root1)
				print('%.10f' % root2)
		except ZeroDivisionError as zd:
			print('-1')
elif sqr < 0:
	print('0')
else:
	pass


x = list(map(int, input().split()))
a = x[0]
b = x[1]
c = x[2]
import math
if a == 0:
	if b == 0:
		if c == 0:
			print(-1)
		else:
			print(0)
	else:
		print(1)
		if c != 0:
			r = -c / b
		else:
			r = abs(c / b)
		print('{:.10f}'.format(r))
else:
	d = b * b - 4 * a * c
	if d < 0:
		print(0)
	elif d == 0:
		print(1)
		r = -b / (2 * a)
		print('{:.10f}'.format(r))
	else:
		r1 = math.sqrt(d)
		r11 = (-b + r1) / (2 * a)
		r12 = (-b - r1) / (2 * a)
		r = []
		r.append(min(r11, r12))
		r.append(max(r11, r12))
		print(2)
		for i in r:
			print('{:.10f}'.format(i))


__author__ = '\n\n \n   ***   \t           *\n    *                  *\n    *                  *\n    *\t ****\t ****  *****    ****   *   *\n    *\t*   *   *      *   *    *  *   *   *   \n    *\t*   *   *      *   *    *  *   *   *\n*   *\t*   *   *      *   *    *  *   *****      \n*   *\t*   *   *      *   *    *  *       *  \n ***\t *** *  *      *****    *** *      * \n                                           *\n********************************************  \n'
from math import sqrt as jarbay
(a, b, c) = map(int, input().split())
delta = b * b - 4 * a * c
if a == 0:
	if b == 0:
		if c == 0:
			print(-1)
		else:
			print(0)
	else:
		print(1)
		u = -1 * c / b
		print('%.5f' % u)
elif delta < 0:
	print(0)
elif delta == 0:
	print(1)
	u = -1 * b / (2 * a)
	print('%.5f' % u)
else:
	x1 = (-1 * b + jarbay(delta)) / (2 * a)
	x2 = (-1 * b - jarbay(delta)) / (2 * a)
	if x1 > x2:
		(x1, x2) = (x2, x1)
	print(2)
	print('%.5f' % x1)
	print('%.5f' % x2)


import math
(a, b, c) = map(int, input().split())
if a == 0:
	if b == 0:
		if c == 0:
			print('-1')
		else:
			print('0')
	else:
		print('1')
		print('%.7f' % (-c / b))
else:
	r = b * b - 4 * a * c
	if r < 0:
		print('0')
	elif r == 0:
		print('1')
		print('%.7f' % (-b / (2 * a)))
	else:
		print('2')
		if a > 0:
			print('%.7f' % ((-b - math.sqrt(r)) / (2 * a)))
			print('%.7f' % ((-b + math.sqrt(r)) / (2 * a)))
		elif a < 0:
			print('%.7f' % ((-b + math.sqrt(r)) / (2 * a)))
			print('%.7f' % ((-b - math.sqrt(r)) / (2 * a)))


from math import *
(a, b, c) = input().split()
(a, b, c) = (int(a), int(b), int(c))
d_2 = b ** 2 - 4 * a * c
if d_2 < 0:
	print('0')
elif a == 0 and b == 0:
	if c == 0:
		print('-1')
	else:
		print('0')
elif a == 0 and b != 0:
	print('1')
	x_1 = -(float(c) / float(b))
	print('%.10f' % x_1)
else:
	if d_2 == 0:
		print('1')
		print('%.10f' % (-b / (2 * a)))
		exit()
	print('2')
	x_small = float(-float(b) - sqrt(d_2)) / float(2 * a)
	x_big = float(-float(b) + sqrt(d_2)) / float(2 * a)
	print('%.10f' % min(x_small, x_big) + '\n' + '%.10f' % max(x_big, x_small))


(a, b, c) = map(int, input().split())
if a == 0 and b == 0:
	if c == 0:
		print('-1')
	else:
		print('0')
	exit(0)
D = pow(b, 2) - 4 * a * c
x = -b
y = pow(D, 1 / 2)
z = 2 * a
r = 0
if a == 0:
	print('1')
	print(-c / b)
	exit(0)
if D < 0:
	print(r)
	exit(0)
if D == 0:
	r = 1
	e1 = (x - y) / z
	print(r, e1)
else:
	r = 2
	e1 = (x + y) / z
	e2 = (x - y) / z
	if e2 < e1:
		(e1, e2) = (e2, e1)
	print(r, e1, e2)


(a, b, c) = [int(x) for x in input().split()]
if a == 0 and b == 0:
	if c == 0:
		print(-1)
	else:
		print(0)
elif a == 0:
	print(1)
	print('{0:.5f}'.format(-c / b))
else:
	root1 = (-b + (b ** 2 - 4 * a * c) ** 0.5) / (2 * a)
	root2 = (-b - (b ** 2 - 4 * a * c) ** 0.5) / (2 * a)
	if root1 == root2:
		print(1)
		print('{0:.5f}'.format(root1))
	elif type(root1) == complex and type(root2) == complex:
		print(0)
	elif type(root1) == complex:
		print(1)
		print('{0:.5f}'.format(root2))
	elif type(root2) == complex:
		print(1)
		print('{0:.5f}'.format(root1))
	elif root1 > root2:
		print(2)
		print('{0:.5f}'.format(root2))
		print('{0:.5f}'.format(root1))
	else:
		print(2)
		print('{0:.5f}'.format(root1))
		print('{0:.5f}'.format(root2))


import sys, math
input = sys.stdin.readline
(a, b, c) = map(int, input().split())
if a == 0:
	if b == 0:
		if c == 0:
			print(-1)
		else:
			print(0)
	else:
		print('1\n{:.6f}'.format(-c / b))
else:
	delta = b * b - 4 * a * c
	if delta < 0:
		print(0)
	elif delta == 0:
		print('1\n{:.6f}'.format(-b / (2 * a)))
	else:
		x1 = (-b - math.sqrt(delta)) / (2 * a)
		x2 = (-b + math.sqrt(delta)) / (2 * a)
		print(2)
		print('{:.6f}\n{:.6f}'.format(min(x1, x2), max(x1, x2)))


from math import sqrt
(a, b, c) = list(map(int, input().split()))
if a == b == c == 0:
	print(-1)
elif a == 0:
	if b != 0:
		print(1)
		print(-c / b)
	else:
		print(0)
else:
	d = b ** 2 - 4 * a * c
	if d < 0:
		print(0)
	elif d == 0:
		print(1)
		print(-b / 2 / a)
	else:
		print(2)
		e = (-b - sqrt(d)) / 2 / a
		f = (-b + sqrt(d)) / 2 / a
		print(min(e, f))
		print(max(e, f))


(a, b, c) = map(float, input().split())
d = b ** 2 - 4 * a * c
if d < 0:
	print(0)
elif a == 0 and b == 0:
	if c == 0:
		print(-1)
	else:
		print(0)
elif a == 0:
	print(1)
	print(-c / b)
else:
	x = [float((-b + d ** 0.5) / 2 / a)]
	v1 = float((-b - d ** 0.5) / 2 / a)
	if not v1 in x:
		x += [v1]
	x.sort()
	print(len(x))
	for v in x:
		print('%.6f' % float(v))


(A, B, C) = map(int, input().split())
import math
D = B * B - 4 * A * C
if A == 0 and B == 0 and (C == 0):
	print(-1)
elif A == 0 and B == 0:
	print(0)
elif A == 0:
	x = -C / B
	print(1)
	print('%4.5f' % x)
elif D < 0:
	print(0)
elif D > 0:
	x1 = (-B + math.sqrt(D)) / (2 * A)
	x2 = (-B - math.sqrt(D)) / (2 * A)
	(x1, x2) = (x1, x2) if x1 < x2 else (x2, x1)
	a = '%4.5f' % x1
	b = '%4.5f' % x2
	print(2)
	print(a)
	print(b)
elif D == 0:
	x = -B / (2 * A)
	print(1)
	print('%4.5f' % x)


import math
coefficients = input().split()
a = int(coefficients[0])
b = int(coefficients[1])
c = int(coefficients[2])
if a == 0 and b == 0 and (c == 0):
	print(-1)
elif b ** 2 - 4 * a * c < 0 or (a == 0 and b == 0):
	print(0)
elif a == 0:
	print(1)
	print('%.10f' % (-c / b))
else:
	root1 = (-b - math.sqrt(b ** 2 - 4 * a * c)) / (2 * a)
	root2 = (-b + math.sqrt(b ** 2 - 4 * a * c)) / (2 * a)
	min_root = min(root1, root2)
	max_root = max(root1, root2)
	if b ** 2 - 4 * a * c == 0:
		print(1)
		print('%.10f' % root1)
	else:
		print(2)
		print('%.10f' % min_root)
		print('%.10f' % max_root)


import math
(a, b, c) = map(int, input().split())
if a == 0 and b == 0 and (c == 0):
	print(-1)
elif a == 0 and b == 0 and (c != 0):
	print(0)
elif a == 0 and b != 0:
	print(1)
	print(-c / b)
elif b * b - 4 * a * c < 0:
	print(0)
elif b * b - 4 * a * c == 0:
	print(1)
	print(-b / (2 * a))
else:
	print(2)
	d = (-b + math.sqrt(b * b - 4 * a * c)) / (2 * a)
	e = (-b - math.sqrt(b * b - 4 * a * c)) / (2 * a)
	print(min(e, d))
	print(max(e, d))


def find_roots(a, b, c):
	if (a, b, c) == (0, 0, 0):
		return None
	if (a, b) == (0, 0):
		return []
	if a == 0:
		return [-c / b]
	d = b ** 2 / (4 * a ** 2) - c / a
	if d < 0:
		return []
	m = -b / (2 * a)
	if d == 0:
		return [m]
	return [m - d ** 0.5, m + d ** 0.5]
(a, b, c) = map(float, input().split())
roots = find_roots(a, b, c)
if roots is None:
	print(-1)
else:
	print(len(roots))
	for r in roots:
		print('{:.10f}'.format(r))


from decimal import *
from math import sqrt
(a, b, c) = map(Decimal, input().split())
if a != 0:
	if b ** 2 - 4 * a * c < 0:
		print(0)
	else:
		arr = [(-b + Decimal(sqrt(b ** 2 - 4 * a * c))) / (2 * a), (-b - Decimal(sqrt(b ** 2 - 4 * a * c))) / (2 * a)]
		if max(arr) == min(arr):
			print(1, arr[0])
		else:
			print(len(arr), *sorted(arr))
elif a == 0 and b != 0:
	print(1, -c / b)
elif a == b == c == 0:
	print(-1)
else:
	print(0)


from math import sqrt
(a, b, c) = list(map(int, input().strip().split(' ')))
if a == 0:
	if b != 0:
		print(1)
		print(-1 * c / b)
	elif c == 0:
		print(-1)
	else:
		print(0)
elif b ** 2 == 4 * a * c:
	print(1)
	print(-1 * b / (2 * a))
elif b ** 2 < 4 * a * c:
	print(0)
else:
	print(2)
	r1 = (-1 * b - sqrt(b ** 2 - 4 * a * c)) / (2 * a)
	r2 = (-1 * b + sqrt(b ** 2 - 4 * a * c)) / (2 * a)
	if r1 < r2:
		print(r1)
		print(r2)
	else:
		print(r2)
		print(r1)


import math
(a, b, c) = map(int, input().split())
d = 0
if a == 0 and b == 0 and (c == 0):
	print(-1)
	exit()
if a == 0 and b == 0:
	print(0)
	exit()
if a == 0:
	d -= c
	d /= b
	print(1)
	if d == -0:
		d = 0
	print(d)
	exit()
d = b * b - 4 * a * c
if d < 0:
	print(0)
	exit()
if d == 0:
	print(1)
	d -= b
	d /= 2 * a
	print(d)
	exit()
if d > 0:
	print(2)
	q = -b + math.sqrt(d)
	q /= 2 * a
	w = -b - math.sqrt(d)
	w /= 2 * a
	if q > w:
		(q, w) = (w, q)
	print(q)
	print(w)
	exit()


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


import os
import sys
from io import BytesIO, IOBase
import math
from queue import Queue
import collections
import itertools
import bisect
import heapq
import random

def main():
	pass
BUFSIZE = 8192

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 = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			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 = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			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:
			os.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')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def binary(n):
	return bin(n).replace('0b', '')

def decimal(s):
	return int(s, 2)

def pow2(n):
	p = 0
	while n > 1:
		n //= 2
		p += 1
	return p

def primeFactors(n):
	l = []
	while n % 2 == 0:
		l.append(2)
		n = n / 2
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			l.append(i)
			n = n / i
	if n > 2:
		l.append(int(n))
	return l

def isPrime(n):
	if n == 1:
		return False
	else:
		root = int(n ** 0.5)
		root += 1
		for i in range(2, root):
			if n % i == 0:
				return False
		return True

def maxPrimeFactors(n):
	maxPrime = -1
	while n % 2 == 0:
		maxPrime = 2
		n >>= 1
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			maxPrime = i
			n = n / i
	if n > 2:
		maxPrime = n
	return int(maxPrime)

def countcon(s, i):
	c = 0
	ch = s[i]
	for i in range(i, len(s)):
		if s[i] == ch:
			c += 1
		else:
			break
	return c

def lis(arr):
	n = len(arr)
	lis = [1] * n
	for i in range(1, n):
		for j in range(0, i):
			if arr[i] > arr[j] and lis[i] < lis[j] + 1:
				lis[i] = lis[j] + 1
	maximum = 0
	for i in range(n):
		maximum = max(maximum, lis[i])
	return maximum

def isSubSequence(str1, str2):
	m = len(str1)
	n = len(str2)
	j = 0
	i = 0
	while j < m and i < n:
		if str1[j] == str2[i]:
			j = j + 1
		i = i + 1
	return j == m

def maxfac(n):
	root = int(n ** 0.5)
	for i in range(2, root + 1):
		if n % i == 0:
			return n // i
	return n

def p2(n):
	c = 0
	while n % 2 == 0:
		n //= 2
		c += 1
	return c

def seive(n):
	primes = [True] * (n + 1)
	primes[1] = primes[0] = False
	i = 2
	while i * i <= n:
		if primes[i] == True:
			for j in range(i * i, n + 1, i):
				primes[j] = False
		i += 1
	pr = []
	for i in range(0, n + 1):
		if primes[i]:
			pr.append(i)
	return pr

def ncr(n, r, p):
	num = den = 1
	for i in range(r):
		num = num * (n - i) % p
		den = den * (i + 1) % p
	return num * pow(den, p - 2, p) % p

def denofactinverse(n, m):
	fac = 1
	for i in range(1, n + 1):
		fac = fac * i % m
	return pow(fac, m - 2, m)

def numofact(n, m):
	fac = 1
	for i in range(1, n + 1):
		fac = fac * i % m
	return fac

def sod(n):
	s = 0
	while n > 0:
		s += n % 10
		n //= 10
	return s
(a, b, c) = map(int, input().split())
d = b * b - 4 * a * c
if a == 0:
	if b == 0 and c == 0:
		print(-1)
	elif b == 0 and c != 0:
		print(0)
	else:
		print(1)
		print(-c / b)
elif d < 0:
	print(0)
elif d == 0:
	print(1)
	print(-b / (2 * a))
else:
	t = d ** 0.5
	r1 = (-b + t) / (2 * a)
	r2 = (-b - t) / (2 * a)
	(r1, r2) = (min(r1, r2), max(r1, r2))
	print(2)
	print(r1)
	print(r2)


import math
(A, B, C) = map(int, input().split(' '))
if A == 0:
	if B == 0:
		if C == 0:
			print(-1)
		else:
			print(0)
	else:
		print(1)
		print(-C / B)
else:
	D = B * B - 4 * A * C
	if D < 0:
		print(0)
	elif D == 0:
		print(1)
		print(-B / (2 * A))
	else:
		X = (-B + math.sqrt(D)) / (2 * A)
		Y = (-B - math.sqrt(D)) / (2 * A)
		if X > Y:
			(X, Y) = (Y, X)
		print(2)
		print('{:.6f}'.format(X))
		print('{:.6f}'.format(Y))


import math
(a, b, c) = [float(x) for x in input().split(' ')]
if a == 0:
	if b == 0:
		if c == 0:
			print(-1)
		else:
			print('%.10f' % 0)
	else:
		print(1)
		print('%.10f' % (-c / b))
else:
	aux = b ** 2 - 4 * a * c
	if aux > 0:
		print(2)
		arr = [(-b + math.sqrt(aux)) / (2 * a), (-b - math.sqrt(aux)) / (2 * a)]
		arr.sort()
		print('%.10f' % arr[0])
		print('%.10f' % arr[1])
	elif aux == 0:
		print(1)
		print('%.10f' % (-b / (2 * a)))
	else:
		print('%.10f' % 0)


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


(a, b, c) = [int(i) for i in input().split()]
d = b ** 2 - 4 * a * c
if a == 0 and b == 0 and (c == 0):
	print(-1)
elif a == 0 and b == 0:
	print(0)
elif a == 0:
	print(1)
	print(-c / b)
elif d < 0:
	print(0)
elif d == 0:
	print(1)
	print(-b / (2 * a))
else:
	print(2)
	b = b / a
	d = d / a ** 2
	print((-b - d ** 0.5) / 2)
	print((-b + d ** 0.5) / 2)


from math import *

def kv():
	(q, w, e) = map(int, input().split())
	if (q == 0) & (w == 0) & (e == 0):
		print(-1)
	elif (q == 0) & (w == 0):
		print(0)
	elif q == 0:
		print(1)
		print('%.6f' % (-e / w))
	else:
		d = w * w - 4 * q * e
		if d < 0:
			print('0')
		elif d == 0:
			print('1')
			print('%.6f' % (-w / (2 * q)))
		else:
			print('2')
			a = [(-w - sqrt(d)) / (2 * q), (-w + sqrt(d)) / (2 * q)]
			a.sort()
			print('%.6f' % a[0])
			print('%.6f' % a[1])
kv()


from math import sqrt
abc = input().split()
a = int(abc[0])
b = int(abc[1])
c = int(abc[2])
if a == 0:
	if b == 0:
		if c == 0:
			print('-1')
		else:
			print('0')
	else:
		print('1')
		print(-c / b)
elif b ** 2 - 4 * a * c < 0:
	print('0')
elif b ** 2 - 4 * a * c == 0:
	print('1')
	print(-b / 2 / a)
else:
	print('2')
	p1 = min((-b + sqrt(b ** 2 - 4 * a * c)) / 2 / a, (-b - sqrt(b ** 2 - 4 * a * c)) / 2 / a)
	p2 = max((-b + sqrt(b ** 2 - 4 * a * c)) / 2 / a, (-b - sqrt(b ** 2 - 4 * a * c)) / 2 / a)
	print('{:.6f}'.format(p1))
	print('{:.6f}'.format(p2))


from math import *
from decimal import *
getcontext().prec = 10
(a, b, c) = input().strip().split()
(a, b, c) = [int(a), int(b), int(c)]
d = b ** 2 - 4 * a * c
if a == 0 and b == 0 and (c == 0):
	print(-1)
elif a == 0 and b == 0:
	print(0)
elif d < 0:
	print(0)
elif a != 0:
	res1 = (-b + sqrt(d)) / (2 * a)
	res2 = (-b - sqrt(d)) / (2 * a)
	if res1 == res2:
		print(1)
		print('%.10f' % res1)
	elif res1 < res2:
		print(2)
		print('%.10f' % res1)
		print('%.10f' % res2)
	else:
		print(2)
		print('%.10f' % res2)
		print('%.10f' % res1)
else:
	res1 = -c / b
	print(1)
	print('%.10f' % res1)


import math
(A, B, C) = map(int, input().split())
if A < 0:
	(A, B, C) = (-A, -B, -C)
if A != 0:
	some_num = B * B / (4 * A) - C
if A == 0:
	if B == 0 and C == 0:
		print(-1)
	elif B != 0:
		print(1)
		print(-C / B)
	else:
		print(0)
elif some_num > 0:
	print(2)
	print((-math.sqrt(some_num) - B / (2 * math.sqrt(A))) / math.sqrt(A))
	print((math.sqrt(some_num) - B / (2 * math.sqrt(A))) / math.sqrt(A))
elif -1e-08 < some_num < 1e-08:
	print(1)
	print(-B / (2 * A))
else:
	print(0)


(a, b, c) = list(map(float, input().split()))
if a == 0 and b == 0 and (c == 0):
	print(-1)
elif a == 0 and b == 0 and (c != 0):
	print(0)
elif a == 0:
	print(1)
	print(-c / b)
elif b * b - 4 * a * c < 0:
	print(0)
else:
	(a1, a2) = ((-b + (b * b - a * 4 * c) ** 0.5) / (2 * a), (-b - (b * b - a * 4 * c) ** 0.5) / (2 * a))
	if a1 == a2:
		print(1)
		print('{0:.5f}'.format(a1))
	else:
		print(2)
		print('{0:.6f}'.format(min(a1, a2)))
		print('{0:.6f}'.format(max(a1, a2)))


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


import math
data = [int(x) for x in input().split()]
a = data[0]
b = data[1]
c = data[2]
if a == 0 and b == 0 and (c == 0):
	print(-1)
elif a == 0 and b == 0:
	print(0)
elif a == 0 and b != 0:
	print(1)
	print(-c / b)
elif b ** 2 - 4 * a * c < 0:
	print(0)
else:
	ans1 = (-b + math.sqrt(b ** 2 - 4 * a * c)) / (2 * a)
	ans2 = (-b - math.sqrt(b ** 2 - 4 * a * c)) / (2 * a)
	if ans1 == ans2:
		print(1)
		print(ans1)
	else:
		answers = [ans1, ans2]
		answers.sort()
		print(2)
		print(answers[0])
		print(answers[1])


import math
import time
import sys
import os
from math import gcd, floor, sqrt, log
start_time = time.time()

def iin():
	return int(input())

def sin():
	return input().strip()

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

def liststr():
	return list(map(str, input().strip().split()))

def ceill(x):
	return int(x) if x == int(x) else int(x) + 1

def ceilldiv(x, d):
	x // d if x % d == 0 else x // d + 1

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

def solve():
	(a, b, c) = listin()
	if a == 0:
		if b == 0:
			if c == 0:
				print(-1)
				return
			print(0)
			return
		print(1)
		print('{0:.10f}'.format(-1 * c / b))
		return
	d = b ** 2 - 4 * a * c
	if d < 0:
		print(0)
		return
	x = set()
	x.add((-1 * b - sqrt(d)) / (2 * a))
	x.add((-1 * b + sqrt(d)) / (2 * a))
	x = list(x)
	x.sort()
	print(len(x))
	for i in x:
		print('{0:.10f}'.format(i))
t = 1
for hula in range(t):
	solve()
sys.stderr.write(str(time.time() - start_time))


import math
(a, b, c) = map(float, input().split())
d = b * b - 4.0 * a * c
if d < 0:
	print(0)
	exit()
if a == 0 and b == 0 and (c == 0):
	print(-1)
	exit()
if a == 0 and b == 0:
	print(0)
	exit()
if a == 0:
	print(1)
	print('{0:.6f}'.format(-c / b))
	exit()
x1 = (-b + math.sqrt(d)) / (2.0 * a)
x2 = (-b - math.sqrt(d)) / (2.0 * a)
if x1 == x2:
	print(1)
	print('{0:.6f}'.format(x1))
	exit()
print(2)
if x1 < x2:
	print('{0:.6f}'.format(x1))
	print('{0:.6f}'.format(x2))
else:
	print('{0:.6f}'.format(x2))
	print('{0:.6f}'.format(x1))


import sys
import math
input = sys.stdin.readline

def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))
q = inlt()
a = q[0]
b = q[1]
c = q[2]
if a == 0:
	if b == 0 and c == 0:
		print('-1')
	elif b == 0:
		print('0')
	else:
		print('1')
		print('{:.6f}'.format(-1 * c / b))
else:
	d = b * b - 4 * a * c
	if d > 0:
		print('2')
		bb = [(-1 * b + math.sqrt(d)) / (2 * a), (-1 * b - math.sqrt(d)) / (2 * a)]
		bb.sort()
		print('{:.6f}'.format(bb[0]))
		print('{:.6f}'.format(bb[1]))
	elif d == 0:
		print('1')
		print('{:.6f}'.format(-b / (2 * a)))
	else:
		print('0')


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


from math import sqrt
(a, b, c) = [int(x) for x in input().split(' ')]

def number_solutions(a, b, c):
	d = b ** 2 - 4 * a * c
	if a == 0 and b == 0 and (c != 0):
		return 0
	elif a == 0 and b == 0 and (c == 0):
		return -1
	elif a == 0 and b != 0:
		return 1
	elif d > 0:
		return 2
	elif d == 0:
		return 1
	else:
		return 0

def quadratic(a, b, c):
	ans = []
	if a == 0:
		ans.append(-c / b)
	else:
		ans.append((-b + sqrt(b ** 2 - 4 * a * c)) / (2 * a))
		ans.append((-b - sqrt(b ** 2 - 4 * a * c)) / (2 * a))
	return ans
if number_solutions(a, b, c) == -1:
	print(-1)
elif number_solutions(a, b, c) == 2:
	print(2)
	for q in sorted(quadratic(a, b, c)):
		print('{:.5f}'.format(q))
elif number_solutions(a, b, c) == 1:
	print(1)
	print('{:.5f}'.format(quadratic(a, b, c)[0]))
else:
	print(0)


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


import math

def solve_const(x):
	if x == 0:
		print(-1)
	else:
		print(0)

def solve_lineal(x, y):
	if y == 0:
		print(1)
		print(0)
	else:
		print(1)
		print(-y / x)

def solve_square(x, y, z):
	d = y * y - 4 * x * z
	if d < 0:
		print(0)
	elif d > 0:
		print(2)
		x1 = (-y + math.sqrt(d)) / (2 * x)
		x2 = (-y - math.sqrt(d)) / (2 * x)
		print(min(x1, x2))
		print(max(x1, x2))
	else:
		print(1)
		print(-y / (2 * x))
(a, b, c) = map(int, input().split())
if a == 0:
	if b == 0:
		solve_const(c)
	else:
		solve_lineal(b, c)
else:
	solve_square(a, b, c)


(a, b, c) = map(int, input().split())
if a == 0 and b == 0:
	print('0' if c else '-1')
elif a == 0:
	print('1', -c / b, sep='\n')
else:
	(d, x) = (b ** 2 - 4 * a * c, 2 * a)
	if d < 0:
		print('0')
	elif d == 0:
		print('1', -b / x, sep='\n')
	else:
		r = sorted(((-b + d ** 0.5) / x, (-b - d ** 0.5) / x))
		print('2', r[0], r[1], sep='\n')


(a, b, c) = [int(x) for x in input().split()]
if a == 0 and b == 0 and (c == 0):
	print(-1)
elif a == 0:
	if b == 0:
		print(0)
	else:
		print(1)
		print(-c / b)
else:
	disc = b ** 2 - 4 * a * c
	denom = 2 * a
	if disc == 0:
		print(1)
		print(-b / denom)
	elif disc < 0:
		print(0)
	else:
		print(2)
		if a > 0:
			print((-b - disc ** 0.5) / denom)
			print((-b + disc ** 0.5) / denom)
		else:
			print((-b + disc ** 0.5) / denom)
			print((-b - disc ** 0.5) / denom)


(a, b, c) = map(int, input().split())
if a < 0:
	a = -a
	b = -b
	c = -c
x = b ** 2 - 4 * a * c
if a == 0:
	if b == 0:
		if c == 0:
			print(-1)
		else:
			print(0)
	else:
		print(1)
		print(f'{-c * 1.0 / b:.7f}')
elif x == 0:
	print(1)
	print(f'{-b / (2 * a):.7f}')
elif x > 0:
	from math import sqrt
	x = sqrt(x)
	a1 = (-b - x) / (2 * a)
	a2 = (-b + x) / (2 * a)
	print(2)
	print(f'{a1:.7f}')
	print(f'{a2:.7f}')
else:
	print(0)


import math
(A, B, C) = [int(i) for i in input().split()]
X = B * B - 4 * A * C
if A == 0 and B == 0 and (C == 0):
	print(-1)
elif A == 0 and B == 0:
	print(0)
elif A == 0:
	print(1)
	print('{0:.10f}'.format(-C / B, 6))
elif X < 0:
	print(0)
elif X == 0:
	print(1)
	print('{0:.10f}'.format(-B / (2 * A)))
else:
	print(2)
	ans = sorted([-(B + math.sqrt(X)) / (2 * A), -(B - math.sqrt(X)) / (2 * A)])
	print('{0:.10f}'.format(ans[0]))
	print('{0:.10f}'.format(ans[1]))


R = lambda : map(int, input().split())
(a, b, c) = R()
if a == 0 and b == 0 and (c == 0):
	print('-1')
elif b ** 2 < 4 * a * c:
	print('0')
elif a == 0:
	if b == 0:
		print('0')
	else:
		print('1')
		print('{0:.5f}'.format(-(c / b)))
else:
	d = b ** 2 - 4 * a * c
	r1 = (-b + pow(d, 0.5)) / (2 * a)
	r2 = (-b - pow(d, 0.5)) / (2 * a)
	if r1 == r2:
		print('1')
		print('{0:.5f}'.format(min(r1, r2)))
	else:
		print('2')
		print('{0:.5f}'.format(min(r1, r2)))
		print('{0:.5f}'.format(max(r1, r2)))


(a, b, c) = map(int, input().split())
if a != 0:
	if b ** 2 - 4 * a * c >= 0:
		root1 = (-b + (b ** 2 - 4 * a * c) ** 0.5) / (2 * a)
		root2 = (-b - (b ** 2 - 4 * a * c) ** 0.5) / (2 * a)
		list = [root1, root2]
		if root1 == root2:
			print(1)
			print(root1)
		else:
			print(2)
			print(min(list))
			print(max(list))
	else:
		print(0)
if a == 0 and b != 0:
	print(1)
	print(-c / b)
if a == 0 and b == 0:
	if c == 0:
		print(-1)
	elif c != 0:
		print(0)


(x, y, z) = [int(i) for i in input().split()]
a = y ** 2 - 4 * x * z
if x == 0 and y == 0 and (z == 0):
	print(-1)
elif x == 0 and y == 0:
	print(0)
elif x == 0:
	print(1)
	print(-z / y)
elif a < 0:
	print(0)
elif a == 0:
	print(1)
	print(-y / (2 * x))
else:
	print(2)
	y = y / x
	a = a / x ** 2
	print((-y - a ** 0.5) / 2)
	print((-y + a ** 0.5) / 2)


import math
(a, b, c) = map(int, input().split())
if a == 0:
	if b == 0 and c != 0:
		print(0)
	elif b == 0 and c == 0:
		print(-1)
	else:
		x = -c / b
		print(1)
		print('%.10f' % x)
else:
	d = b * b - 4 * a * c
	if d < 0:
		print(0)
	elif d > 0:
		ans = []
		ans.append((-b + math.sqrt(d)) / (2 * a))
		ans.append((-b - math.sqrt(d)) / (2 * a))
		print(2)
		ans.sort()
		print('%.10f' % ans[0])
		print('%.10f' % ans[1])
	else:
		y = (-b - math.sqrt(d)) / (2 * a)
		print(1)
		print('%.10f' % y)


import math
(a, b, c) = list(map(int, input().split(' ')))
if a == 0 and b == 0 and (c == 0):
	print(-1)
elif a == 0 and b != 0:
	print(1)
	print('{0:.5f}'.format(-c / b))
elif a == 0 and b == 0 and (c != 0):
	print(0)
else:
	d = b ** 2 - 4 * a * c
	if d > 0:
		x1 = (-b + math.sqrt(d)) / (2 * a)
		x2 = (-b - math.sqrt(d)) / (2 * a)
		if x1 > x2:
			(x1, x2) = (x2, x1)
		print(2)
		print('{0:.5f}'.format(x1))
		print('{0:.5f}'.format(x2))
	elif d == 0:
		x = -b / (2 * a)
		print(1)
		print('{0:.5f}'.format(x))
	else:
		print(0)


import math
(A, B, C) = input().split()
(A, B, C) = (float(A), float(B), float(C))
if A == 0 and B == 0:
	if C == 0:
		print(-1)
	else:
		print(0)
elif A == 0:
	print(1)
	print('%.10f' % (-C / B))
else:
	det = B * B - 4 * A * C
	if det < 0:
		print(0)
	elif det == 0:
		print(1)
		x = -B / (2 * A)
		print('%.10f' % x)
	else:
		print(2)
		x1 = (-B + math.sqrt(det)) / (2 * A)
		x2 = (-B - math.sqrt(det)) / (2 * A)
		if x1 < x2:
			print('%.10f' % x1)
			print('%.10f' % x2)
		else:
			print('%.10f' % x2)
			print('%.10f' % x1)


from math import sqrt
(a, b, c) = map(int, input().split())
if a == b == c == 0:
	print(-1)
elif a == b == 0:
	print(0)
elif a == 0:
	print(1)
	print(-c / b)
elif b ** 2 == 4 * a * c:
	print(1)
	print(-b / (2 * a))
elif 4 * a * c > b ** 2:
	print(0)
else:
	print(2)
	x = (-b + sqrt(b ** 2 - 4 * a * c)) / (2 * a)
	y = (-b - sqrt(b ** 2 - 4 * a * c)) / (2 * a)
	print('{0:.16f}'.format(min(x, y)))
	print('{0:.16f}'.format(max(x, y)))


import math
(a, b, c) = input().split()
a = int(a)
b = int(b)
c = int(c)
if a != 0 and b * b < 4 * a * c or (a == b == 0 and c != 0):
	print('0')
elif a == b == c == 0:
	print('-1')
elif a == 0:
	print('1')
	a1 = -c / b
	print(format(a1, '.5f'))
else:
	a1 = (-b - (b * b - 4 * a * c) ** 0.5) / (2 * a)
	a2 = (-b + (b * b - 4 * a * c) ** 0.5) / (2 * a)
	if a1 < a2:
		(a1, a2) = (a2, a1)
	if a1 != a2:
		print('2')
		print(format(a2, '.5f'))
		print(format(a1, '.5f'))
	else:
		print('1')
		print(format(a1, '.5f'))


__author__ = 'linh'
import math

def main():
	n = input().split()
	A = int(n[0])
	B = int(n[1])
	C = int(n[2])
	if A == B == C == 0:
		print(-1)
	elif A == B == 0:
		print(0)
	elif A == 0:
		print(1)
		print('{0:.5f}'.format(-C / B))
	else:
		delta = B ** 2 - 4 * A * C
		if delta < 0:
			print(0)
		elif delta == 0:
			print(1)
			print('{0:.5f}'.format(-B / (2 * A)))
		else:
			print(2)
			x1 = (-B - math.sqrt(delta)) / (2 * A)
			x2 = (-B + math.sqrt(delta)) / (2 * A)
			if x1 < x2:
				print('{0:.20f}'.format(x1))
				print('{0:.20f}'.format(x2))
			else:
				print('{0:.20f}'.format(x2))
				print('{0:.20f}'.format(x1))
main()


import math
(a, b, c) = map(int, input().split())
delta = b * b - 4 * a * c
if delta < 0:
	print('0')
elif a != 0:
	x1 = (-b + math.sqrt(delta)) / (a * 2)
	x2 = (-b - math.sqrt(delta)) / (a * 2)
	if delta == 0:
		print('1')
		print('%.5f' % x1)
	else:
		print('2')
		if x1 > x2:
			(x1, x2) = (x2, x1)
		print('%.5f' % x1)
		print('%.5f' % x2)
elif b != 0:
	x = -c / b
	print('1')
	print('%.5f' % x)
elif c != 0:
	print('0')
else:
	print('-1')


import os, sys
from io import BytesIO, IOBase
from math import sqrt

def main():
	(a, b, c) = map(int, input().split())
	if a == b == c == 0:
		print(-1)
	elif a == b == 0:
		print(0)
	elif a == 0:
		print(1)
		print('%.10f' % (-c / b))
	else:
		d2 = b * b - 4 * a * c
		if d2 < 0:
			print(0)
		elif d2 == 0:
			print(1)
			print('%.10f' % (-b / (2 * a)))
		else:
			d = sqrt(d2)
			print(2)
			if a > 0:
				print('%.10f' % ((-b - d) / (2 * a)))
				print('%.10f' % ((-b + d) / (2 * a)))
			else:
				print('%.10f' % ((-b + d) / (2 * a)))
				print('%.10f' % ((-b - d) / (2 * a)))
BUFSIZE = 8192

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 = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			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 = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			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:
			os.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')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


from math import *
a = [int(i) for i in input().split()]
if a[0] == 0 and a[1] == 0 and (a[2] == 0):
	print('-1')
	exit()
if a[0] == 0 and a[1] != 0:
	print('1')
	print(-a[2] / a[1])
elif a[0] == 0 and a[1] == 0:
	print('0')
	exit()
elif a[1] * a[1] - 4 * a[0] * a[2] < 0:
	print('0')
elif a[1] * a[1] - 4 * a[0] * a[2] == 0:
	print('1')
	print(-a[1] / (2 * a[0]))
else:
	print(2)
	print(min((-a[1] + sqrt(a[1] * a[1] - 4 * a[0] * a[2])) / (2 * a[0]), (-a[1] - sqrt(a[1] * a[1] - 4 * a[0] * a[2])) / (2 * a[0])))
	print(max((-a[1] + sqrt(a[1] * a[1] - 4 * a[0] * a[2])) / (2 * a[0]), (-a[1] - sqrt(a[1] * a[1] - 4 * a[0] * a[2])) / (2 * a[0])))


import math
(a, b, c) = map(int, input().split())
if a:
	if b * b - 4 * a * c > 0:
		print(2)
		print(min((-b - math.sqrt(b * b - 4 * a * c)) / 2 / a, (-b + math.sqrt(b * b - 4 * a * c)) / 2 / a))
		print(max((-b - math.sqrt(b * b - 4 * a * c)) / 2 / a, (-b + math.sqrt(b * b - 4 * a * c)) / 2 / a))
	elif b * b - 4 * a * c == 0:
		print(1)
		print(round(-b / 2 / a, 5))
	else:
		print(0)
elif b:
	print(1)
	print(-c / b)
else:
	print(0 if c else -1)


import math

def solver(a, b, c):
	d = b ** 2 - 4 * a * c
	if a == 0 and b != 0:
		print('1')
		print('%.5f' % (-c / b))
	elif a == 0 and b == 0 and (c == 0):
		print(-1)
	elif a == 0 and b == 0 and (c != 0):
		print('0')
	elif d < 0:
		print(0)
	elif d == 0 and a != 0:
		x1 = (-b + math.sqrt(d)) / (2 * a)
		x2 = (-b - math.sqrt(d)) / (2 * a)
		print('1')
		print('%.5f' % x1)
	else:
		print('2')
		x1 = (-b + math.sqrt(d)) / (2 * a)
		x2 = (-b - math.sqrt(d)) / (2 * a)
		(x1, x2) = (min(x1, x2), max(x1, x2))
		print('%.5f' % x1)
		print('%.5f' % x2)
(a, b, c) = map(int, input().split())
solver(a, b, c)


(a, b, c) = map(int, input().split())
if a == 0:
	if b == 0:
		if c == 0:
			print(-1)
		else:
			print(0)
	else:
		print(1)
		print(-c / b)
else:
	square = b * b - 4 * a * c
	if square < 0:
		print(0)
	elif square == 0:
		print(1)
		print(-b / (2 * a))
	else:
		print(2)
		term = square ** 0.5
		roots = sorted([(-b + term) / (2 * a), (-b - term) / (2 * a)])
		print(roots[0])
		print(roots[1])


import re
arr = re.split(' ', input())
A = int(arr[0])
B = int(arr[1])
C = int(arr[2])
dis = B * B - 4 * A * C
if A == 0 and B == 0 and (C == 0):
	print(-1)
elif A == 0 and B == 0:
	print(0)
elif A == 0:
	print(1)
	print(-C / B)
elif dis < 0:
	print(0)
elif dis == 0:
	print(1)
	print(-B / (2 * A))
else:
	print(2)
	if A > 0:
		print((-B - dis ** 0.5) / (2 * A))
		print((-B + dis ** 0.5) / (2 * A))
	else:
		print((-B + dis ** 0.5) / (2 * A))
		print((-B - dis ** 0.5) / (2 * A))


R = lambda : map(int, input().split())
(a, b, c) = R()
if b:
	t = [1, -c / b]
else:
	t = [-(c == 0)]
if a:
	(d, x) = (b * b - 4 * a * c, -2 * a)
	if d:
		if d < 0:
			t = [0]
		else:
			t = [2] + sorted([(b - d ** 0.5) / x, (b + d ** 0.5) / x])
	else:
		t = [1, b / x]
if len(t) == 1:
	print(*t)
elif len(t) == 2:
	print(t[0])
	print('%.10f' % t[1])
else:
	print(t[0])
	print('%.10f' % t[1])
	print('%.10f' % t[2])


import math
nl = list(input().split(' '))
a = int(nl[0])
b = int(nl[1])
c = int(nl[2])
if a == 0 and b == 0:
	if c != 0:
		print(0)
		exit()
	print(-1)
	exit()
if a == 0:
	print(1)
	print('%10.5f' % (-c / b))
	exit()
sqrt = b * b - 4 * a * c
if sqrt == 0:
	print(1)
	print('%10.5f' % (-b / 2 / a))
elif sqrt < 0:
	print(0)
else:
	print(2)
	roots = [(math.sqrt(sqrt) - b) / 2 / a, (-math.sqrt(sqrt) - b) / 2 / a]
	roots.sort()
	print('%10.5f' % roots[0])
	print('%10.5f' % roots[1])


from math import sqrt
(a, b, c) = map(int, input().split())
disc = b * b - 4 * a * c
if a == 0 and b == 0 and (c == 0):
	print(-1)
elif a == 0 and b == 0 or disc < 0:
	print(0)
elif a == 0:
	print(1)
	print(-c / b)
elif disc == 0:
	print(1)
	print(-b / 2 / a)
else:
	print(2)
	res = [(-b - sqrt(disc)) / (2.0 * a), (-b + sqrt(disc)) / (2.0 * a)]
	res.sort()
	print('{:7f}'.format(res[0]))
	print('{:7f}'.format(res[1]))


import sys
import collections
import random
sys.setrecursionlimit(30000)

def main():
	(a, b, c) = [float(it) for it in input().split()]
	if a == 0:
		if b == 0:
			if c == 0:
				sys.stdout.write('-1 \n')
			else:
				sys.stdout.write('0 \n')
		else:
			x = c / b * -1.0
			if x == -0.0:
				x = 0.0
			sys.stdout.write('1 \n%.5f \n' % x)
	elif a != 0:
		d = b * b - 4 * a * c
		if d < 0:
			sys.stdout.write('0\n')
		elif d == 0:
			x = -b / 2 / a
			sys.stdout.write('1 \n%.5f \n' % x)
		elif d > 0:
			x1 = (-b + d ** 0.5) / 2 / a
			x2 = (-b - d ** 0.5) / 2 / a
			if x1 > x2:
				(x1, x2) = (x2, x1)
			sys.stdout.write('2 \n%.5f \n%.5f \n' % (x1, x2))
main()


from math import sqrt
(a, b, c) = map(int, input().split())
if a == 0 and b == 0:
	if c == 0:
		print('-1')
	else:
		print('0')
elif a == 0:
	if c == 0:
		print(1)
		print('{:.5f}'.format(c))
	else:
		x = -1 * c / b
		print('1')
		print('{:.5f}'.format(x))
elif b == 0:
	if c == 0:
		print(1)
		print('{:.5f}'.format(c))
	else:
		x = -1 * c / a
		if x < 0:
			print('0')
		else:
			print('1')
			print('{:.5f}'.format(x))
else:
	result = b ** 2 - 4 * a * c
	if result < 0:
		print('0')
	else:
		x = (-1 * b - sqrt(result)) / (2 * a)
		y = (-1 * b + sqrt(result)) / (2 * a)
		if x == y:
			print(1)
			print('{:.5f}'.format(x))
		else:
			print(2)
			if x < y:
				print('{:.5f}'.format(x))
				print('{:.5f}'.format(y))
			else:
				print('{:.5f}'.format(y))
				print('{:.5f}'.format(x))


(a, b, c) = map(int, input().split())
if a:
	d = b ** 2 - 4 * a * c
	if d < 0:
		ans = [0]
	elif d == 0:
		ans = [1, -b / (2 * a)]
	else:
		ans = [2] + sorted([-(b - d ** 0.5) / (2 * a), -(b + d ** 0.5) / (2 * a)])
elif b:
	ans = [1, -c / b]
elif c:
	ans = [0]
else:
	ans = [-1]
print(*ans)


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


from math import sqrt
x = input()
y = x.split()
a = int(y[0])
b = int(y[1])
c = int(y[2])
det = b ** 2 - 4 * a * c
if a == 0:
	if b != 0:
		print(1)
		print(-c / b)
if b == 0:
	if a * c < 0:
		print(2)
		print(-sqrt(-c / a))
		print(sqrt(-c / a))
if det < 0:
	print(0)
if det == 0:
	if a == 0 and b == 0 and (c == 0):
		print(-1)
	elif a == 0 and b == 0 and (c != 0):
		print(0)
	else:
		print(1)
		print(-b * (2 * a) ** (-1))
if det > 0:
	if a != 0:
		print(2)
		X = (-b - sqrt(det)) / (2 * a)
		Y = (-b + sqrt(det)) / (2 * a)
		if X > Y:
			print(Y)
			print(X)
		else:
			print(X)
			print(Y)


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

def quadroot(a, b, c):
	roots = []
	negb = -1 * b
	discriminant = (b ** 2 - 4 * a * c) ** (1 / 2)
	bottom = 2 * a
	roots.append(format((negb - discriminant) / bottom, '.6f'))
	roots.append(format((negb + discriminant) / bottom, '.6f'))
	return roots
if a == 0 and b == 0 and (c == 0):
	print(-1)
	exit()
if a == b and b == 0 and (c != 0) or b ** 2 - 4 * a * c < 0:
	print(0)
	exit()
ans = []
if a == 0:
	ans.append(-1 * c / b)
else:
	ans = quadroot(a, b, c)
for root in range(len(ans)):
	ans[root] = float(ans[root])
ans1 = list(set(sorted(ans)))
print(len(ans1))
for i in ans1:
	print(f'{i:.6f}')


class CodeforcesTask20BSolution:

	def __init__(self):
		self.result = ''
		self.a_b_c = []

	def read_input(self):
		self.a_b_c = [int(x) for x in input().split(' ')]

	def process_task(self):
		if not self.a_b_c[0]:
			if not self.a_b_c[1]:
				if not self.a_b_c[2]:
					self.result = '-1'
				else:
					self.result = '0'
			else:
				self.result = '1\n{0:.6f}'.format(-self.a_b_c[2] / self.a_b_c[1])
		else:
			delta = self.a_b_c[1] ** 2 - 4 * self.a_b_c[0] * self.a_b_c[2]
			if not delta:
				import math
				root = math.sqrt(self.a_b_c[2] / self.a_b_c[0])
				if self.a_b_c[0] * root ** 2 + self.a_b_c[1] * root + self.a_b_c[2] != 0:
					root = -root
				self.result = '1\n{0:.6f}'.format(root)
			elif delta < 0:
				self.result = '0'
			else:
				import math
				s_delta = math.sqrt(delta)
				roots = [(-self.a_b_c[1] - s_delta) / (2 * self.a_b_c[0]), (-self.a_b_c[1] + s_delta) / (2 * self.a_b_c[0])]
				roots.sort()
				self.result = '2\n{0:.6f}\n{1:.6f}'.format(roots[0], roots[1])

	def get_result(self):
		return self.result
Solution = CodeforcesTask20BSolution()
Solution.read_input()
Solution.process_task()
print(Solution.get_result())


(a1, a2, a3) = input('').split()
a = int(a1)
b = int(a2)
c = int(a3)
d = b * b - 4 * a * c
if a == 0 and b == 0 and (c == 0):
	print('-1')
elif d < 0 or d > 0 or d == 0:
	if d > 0 and a != 0:
		r1 = (-b + d ** 0.5) / (2 * a)
		r2 = (-b - d ** 0.5) / (2 * a)
		mi = min(r1, r2)
		ma = max(r1, r2)
		print('2')
		print('{0:.10f}'.format(mi))
		print('{0:.10f}'.format(ma))
	if d < 0:
		print('0')
	if d == 0 and a != 0:
		r1 = (-b + d ** 0.5) / (2 * a)
		print('1')
		print('{0:.10f}'.format(r1))
	if a == 0 and b != 0:
		r1 = -c / b
		print('1')
		print('{0:.10f}'.format(r1))
	if a == 0 and b == 0:
		print('0')


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

def root(a, b, c):
	d = b ** 2 - 4 * a * c
	if d == 0:
		x = -b / (2 * a)
		print(1)
		print('%.10f' % x)
	elif d > 0:
		x = (-b + math.sqrt(d)) / (2 * a)
		y = (-b - math.sqrt(d)) / (2 * a)
		print(2)
		if x > y:
			print('%.10f' % y)
			print('%.10f' % x)
		else:
			print('%.10f' % x)
			print('%.10f' % y)
	else:
		print('0')
if a == 0 and b == 0 and (c == 0):
	print(-1)
elif a == 0 and b != 0:
	print(1)
	x = -c / b
	print('%.10f' % x)
elif a == 0 and b == 0 and (c != 0):
	print(0)
else:
	root(a, b, c)


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