Recently, a chaotic virus Hexadecimal advanced a new theorem which will shake the Universe. She thinks that each Fibonacci number can be represented as sum of three not necessary different Fibonacci numbers.

Let's remember how Fibonacci numbers can be calculated. F0 = 0, F1 = 1, and all the next numbers are Fi = Fi - 2 + Fi - 1.

So, Fibonacci numbers make a sequence of numbers: 0, 1, 1, 2, 3, 5, 8, 13, ...

If you haven't run away from the PC in fear, you have to help the virus. Your task is to divide given Fibonacci number n by three not necessary different Fibonacci numbers or say that it is impossible.

Input

The input contains of a single integer n (0 ≤ n < 109) — the number that should be represented by the rules described above. It is guaranteed that n is a Fibonacci number.

Output

Output three required numbers: a, b and c. If there is no answer for the test you have to print "I'm too stupid to solve this problem" without the quotes.

If there are multiple answers, print any of them.

Examples

Input

3


Output

1 1 1


Input

13


Output

2 3 8

Source: codeforces | Difficulty: EASY
Tags: Number theory

Complete search

Implementation

Constructive algorithms


Solutions:
import sys
s = sys.stdin.readline().strip()
s = int(s)

def fabo(a):
	f0 = 0
	f1 = 1
	f2 = 1
	while f2 < a:
		f0 = f1
		f1 = f2
		f2 = f1 + f0
		if a == f2:
			return print(f1, f0, 0)
		else:
			pass
if s == 0:
	print(0, 0, 0)
if s == 1:
	print(0, 0, 1)
else:
	fabo(s)


import sys
import math
input = sys.stdin.readline

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

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

def insr():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	return map(int, input().split())
fib = [0, 1]
now = 0
while now <= 1000000000:
	now = fib[-1] + fib[-2]
	fib.append(now)
n = inp()
for a in fib:
	for b in fib:
		for c in fib:
			if a + b + c == n:
				print(a, b, c)
				exit(0)
print("I'm too stupid to solve this problem")


n = input()
print('0 ' + '0 ' + n)


n = int(input())
print(0, 0, n)


n = int(input())
if n == 0:
	print(0, 0, 0)
elif n == 1:
	print(0, 0, 1)
else:
	(i, j, k, l) = (0, 1, 1, 2)
	while l < n:
		f_i = l + k
		(i, j, k, l) = (j, k, l, f_i)
		if f_i == n:
			break
	if i + j + j != n:
		print("I'm too stupid to solve this problem")
	else:
		print(i, j, j)


n = int(input())
asfas = 0
if n == 0:
	print(0, 0, 0)
elif n == 1:
	print(0, 0, 1)
elif n == 2:
	print(0, 1, 1)
else:
	f = [0, 1]
	a = -1
	i = 1
	while a != n:
		a = f[i] + f[i - 1]
		f.append(a)
		i = i + 1
	print(f[-5], f[-4], f[-2])


n = int(input())
fib = [0, 1]
a = 0
b = 1
if n == 0:
	print(0, 0, 0)
elif n == 1:
	print(0, 0, 1)
else:
	for i in range(50):
		(a, b) = (b, a + b)
		fib.append(b)
	k = fib.index(n)
	print(0, fib[k - 1], fib[k - 2])


n = int(input())
if n == 0:
	print(0, 0, 0)
else:
	(a, b) = (0, 1)
	while a + b != n:
		(a, b) = (b, a + b)
	print(0, a, b)


A = []
f = 0
s = 1
A.append(f)
n = 0
while n < 10 ** 9:
	n = f + s
	A.append(n)
	s = f
	f = n
Inp = int(input())
if Inp == 0:
	print(0, 0, 0)
elif Inp == 1:
	print(0, 0, 1)
else:
	Index = A.index(Inp)
	print(A[Index - 2], A[Index - 2], A[Index - 3])


n = int(input())
f = 0
s = 1
l = [f]
i = 0
while s <= n:
	temp = s
	l.append(s)
	s = f + s
	f = temp
	i += 1
if n == 0:
	print('0 0 0')
elif n == 1:
	print('0 0 1')
elif n == 2:
	print('0 1 1')
else:
	print(l[i - 1], l[i - 3], l[i - 4])


def produce_fib(n):
	x = [0, 1]
	(a, b) = (0, 1)
	t = 0
	while t < n:
		t = a + b
		x.append(t)
		a = b
		b = t
	return x
n = int(input())
if n == 0:
	print('0 0 0')
elif n == 1:
	print('0 0 1')
else:
	series = produce_fib(n)
	from itertools import combinations
	comb = combinations(series, 3)
	flag = 0
	for c in comb:
		if sum(c) == n:
			flag = 1
			print(' '.join(map(str, c)))
			exit()
	print("I'm too stupid to solve this problem")


num = int(input())
fib = [0, 1]
i = 0
if num > 0:
	while fib[-1] != num:
		fib.append(fib[-1] + fib[-2])
if num == 1:
	print(0, 0, 1)
elif num == 0:
	print(0, 0, 0)
elif num == 2:
	print(1, 1, 0)
elif num == 3:
	print(1, 1, 1)
else:
	print(fib[-2], fib[-4], fib[-5])


t = int(input())
count = 1
num = 0
lst = [0, 1]
if t > 2:
	while num != t:
		count += 1
		num = lst[count - 1] + lst[count - 2]
		lst.append(num)
	print(f'{lst[count - 1]} {lst[count - 3]} {lst[count - 4]}')
elif t == 2:
	print('0 1 1')
elif t == 1:
	print('0 0 1')
elif t == 0:
	print('0 0 0')
else:
	print("I'm too stupid to solve this problem")


refer = (0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025, 121393, 196418, 317811, 514229, 832040, 1346269, 2178309, 3524578, 5702887, 9227465, 14930352, 24157817, 39088169, 63245986, 102334155, 165580141, 267914296, 433494437, 701408733)
n = int(input())
d = refer.index(n)
if d < 3:
	print('0 0 ' + str(n))
else:
	print('0 ' + str(refer[d - 2]) + ' ' + str(refer[d - 1]))


n = int(input())
if n <= 3:
	if n == 3:
		print(1, 1, 1)
	elif n == 2:
		print(0, 1, 1)
	elif n == 1:
		print(0, 0, 1)
	else:
		print(0, 0, 0)
else:
	lst = [-1, 0, 1]
	b = 0
	a = 1
	j = 3
	f = 1
	i = 1
	while f != n:
		t = a
		a = a + b
		b = t
		f = a
		lst.append(f)
	l = len(lst)
	print(lst[l - 5], lst[l - 4], lst[l - 2])


n = int(input())

def fib(n):
	a = 0
	b = 1
	c = 0
	i = 0
	while c <= n:
		c = a + b
		a = b
		b = c
		i += 1
	return b - a
a = fib(n)
c = fib(n - a)
d = n - a - c
if n == 0:
	print(str(0) + ' ' + str(0) + ' ' + str(0))
if n == 1:
	print(str(0) + ' ' + str(0) + ' ' + str(1))
if n == 2:
	print(str(0) + ' ' + str(1) + ' ' + str(1))
if n >= 3:
	print(str(d) + ' ' + str(c) + ' ' + str(a))


n = int(input())
l = [0, 1, 1, 2]
if n == 0:
	print(0, 0, 0)
elif n == 1:
	print(1, 0, 0)
elif n == 2:
	print(2, 0, 0)
elif n == 3:
	print(1, 1, 1)
else:
	while n not in l:
		l.append(l[-1] + l[-2])
	print(l[-2], l[-3], 0)


n = int(input())
if n > 2:
	x = [0, 1, 1]
	x2 = 1
	x1 = 1
	while True:
		x1 += x2
		x.append(x1)
		if x1 == n:
			break
		x2 += x1
		x.append(x2)
		if x2 == n:
			break
	print(x[len(x) - 5], x[len(x) - 4], x[len(x) - 2])
elif n == 2:
	print(0, 1, 1)
elif n == 1:
	print(0, 0, 1)
elif n == 0:
	print(0, 0, 0)
else:
	print("I'm too stupid to solve this problem")


print('0 0', input())


n = int(input())
if n == 1:
	print(0, 0, 1)
elif n == 0:
	print(0, 0, 0)
else:
	(u, v) = (0, 1)
	while v != n:
		(u, v) = (v, u + v)
	print(2 * u - v, v - u, v - u)


x = int(input())
print('0', '0', x)


n = int(input())
print(str(n) + ' ' + str(0) + ' ' + str(0))


from sys import stdin, stdout
import math, sys
from itertools import permutations, combinations
from collections import defaultdict, deque, OrderedDict
from os import path
import bisect as bi
import heapq

def yes():
	print('YES')

def no():
	print('NO')
if path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')

	def I():
		return int(input())

	def In():
		return map(int, input().split())
else:

	def I():
		return int(stdin.readline())

	def In():
		return map(int, stdin.readline().split())

def fib():
	(a, b) = (0, 1)
	d = {}
	d[0] = 1
	d[1] = 1
	for i in range(100):
		(a, b) = (b, a + b)
		d[b] = 1
	return d

def main():
	try:
		n = I()
		if d.get(n, 0) != 0:
			print(0, 0, n)
		else:
			ans = []
			for i in range(100):
				for j in range(100):
					if d.get(n - d[i] + d[j], 0) != 0:
						ans = [d[i], d[j], d[n - d[i] + d[j]]]
						break
						break
			if len(ans) != 0:
				print(*ans)
			else:
				print("I'm too stupid to solve this problem")
	except:
		pass
M = 998244353
P = 1000000007
d = fib()
for _ in range(1):
	main()


n = int(input())
if n == 0:
	print(0, 0, 0)
elif n == 1:
	print(0, 0, 1)
elif n == 2:
	print(0, 1, 1)
elif n == 3:
	print(1, 1, 1)
else:
	x = 1
	y = 2
	while n != y:
		(x, y) = (y, x + y)
	L = x
	n -= x
	x = 1
	y = 2
	while n != y:
		(x, y) = (y, x + y)
	print(n - x, x, L)


def theorem(n):
	if n == 3:
		return str(1) + ' ' + str(1) + ' ' + str(1)
	elif n == 2:
		return str(1) + ' ' + str(1) + ' ' + str(0)
	elif n == 1:
		return str(1) + ' ' + str(0) + ' ' + str(0)
	elif n == 0:
		return str(0) + ' ' + str(0) + ' ' + str(0)
	a = 5
	b = 8
	pp4 = 1
	pp3 = 1
	pp2 = 2
	pp1 = 3
	while a != n:
		c = a
		a = b
		b = c + b
		pp4 = pp3
		pp3 = pp2
		pp2 = pp1
		pp1 = c
	return str(pp4) + ' ' + str(pp3) + ' ' + str(pp1)
n = int(input())
print(theorem(n))


class Code:

	def __init__(self):
		self.n = int(input())

	def process(self):
		print(0, 0, self.n)
code = Code()
code.process()


def main():
	s = 0
	l = 0
	p = 1
	n = int(input())
	a = [0, 1]
	i = 2
	while s <= n:
		s = l + p
		l = p
		p = s
		a.append(s)
	for k in a:
		for b in a:
			for c in a:
				if k + b + c == n:
					print(k, b, c)
					return
	print("I'm too stupid to solve this problem")
	return
main()


k = int(input())
print('0 0 ' + str(k))


n = int(input())
if n == 0:
	print(0, 0, 0)
elif n == 1:
	print(1, 0, 0)
else:
	a = 1
	b = 1
	l = []
	l.append(0)
	l.append(a)
	l.append(b)
	c = 0
	while c != n:
		c = a + b
		a = b
		b = c
		l.append(c)
	l.pop()
	n = len(l)
	print(l[n - 1], l[n - 3], l[n - 4])


phi = (1 + 5 ** 0.5) / 2
n = int(input())
if not n == 1:
	print(round(n / phi ** 2), round(n / phi ** 2), round(n / phi ** 3))
else:
	print(1, 0, 0)


fibs = [0, 1]
while fibs[-1] < 10 ** 9:
	fibs += [fibs[-1] + fibs[-2]]

def ans(N):
	if N == 0:
		return '0 0 0'
	if N == 1:
		return '1 0 0'
	i = fibs.index(N)
	return f'{fibs[i - 2]} {fibs[i - 2]} {fibs[i - 3]}'
N = int(input())
print(ans(N))


import math
n = int(input())
if n == 1:
	print(0, 0, 1)
elif n == 0:
	print(0, 0, 0)
elif n == 2:
	print(0, 1, 1)
elif n == 3:
	print(1, 1, 1)
elif n >= 5:
	te = n * ((1 + math.sqrt(5)) / 2)
	te = int(round(te, 0))
	te1 = te - n
	te2 = n - te1
	te3 = te1 - te2
	te4 = te2 - te3
	print(te4, te3, te1)


print('0 0 {}'.format(input()))


val = input()
print(0)
print(0)
print(val)


import math
n = int(input())
k = 0
for x in range(1, 1000):
	if n == round(((1 + math.sqrt(5)) / 2) ** x / math.sqrt(5)):
		k = x
print(round(((1 + math.sqrt(5)) / 2) ** (k - 1) / math.sqrt(5)), end=' ')
print(round(((1 + math.sqrt(5)) / 2) ** (k - 2) / math.sqrt(5)), end=' ')
print(0)


def fib(k):
	a = 0
	b = 1
	l = [0, 1]
	c = 0
	while c != k:
		c = b + a
		l.append(c)
		a = b
		b = c
	return l
n = int(input())
l = fib(n)
if n > 1:
	print(l[-3], l[-3], l[-4])
elif n == 1:
	print(1, 0, 0)
else:
	print(0, 0, 0)


n = int(input())
if n:
	(a, b, c) = (0, 1, 1)
	while c != n:
		a = b
		b = c
		c = a + b
	print('0 ' + str(a) + ' ' + str(b))
else:
	print('0 0 0')


n = int(input())
a = 0
b = 1
c = 1
x = 2
while x < n:
	x = x + c
	a = b
	b = c
	c = x - b
if n == 0:
	print(0, 0, 0)
elif n == 1:
	print(0, 0, 1)
else:
	print(a, b, b)


import time, math
from sys import stdin, stdout

def I():
	return int(stdin.readline())

def In():
	return map(int, stdin.readline().split())

def L():
	return list(map(int, stdin.readline().split()))

def Si():
	return sorted(list(map(int, stdin.readline().split())))

def Si():
	return sorted(list(map(int, stdin.readline().split())), reverse=True)

def P(x):
	return stdout.write(str(x) + '\n')

def Pi(x, y, z):
	return stdout.write(str(x) + ' ' + str(y) + ' ' + str(z) + '\n')

def solve():
	n = I()
	f0 = 0
	f1 = 1
	sum = 1
	if n == 0:
		P('0 0 0')
	else:
		while sum != n:
			f0 = f1
			f1 = sum
			sum = f0 + f1
		Pi('0', f0, f1)
solve()


n = int(input())
if n == 0:
	print('0 0 0')
elif n == 1:
	print('1 0 0')
else:
	l = []
	l.append(0)
	l.append(1)
	a = 0
	b = 1
	while b < n:
		l.append(a + b)
		t = a
		a = b
		b = t + b
	if b == n:
		print(str(l[-3]) + ' ' + str(l[-3]) + ' ' + str(l[-4]))
	else:
		print("I'm too stupid to solve this problem")


n = int(input())
fib = [0, 0, 0, 1]
while fib[len(fib) - 1] + fib[len(fib) - 3] + fib[len(fib) - 4] < n:
	fib.append(fib[-1] + fib[-2])
if n == 0:
	print(0, 0, 0)
elif n == 2:
	print(0, 1, 1)
elif fib[len(fib) - 1] + fib[len(fib) - 3] + fib[len(fib) - 4] != n:
	print("I'm too stupid to solve this problem")
else:
	print(fib[len(fib) - 4], fib[len(fib) - 3], fib[len(fib) - 1])


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, copy, functools
import random
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return list(map(int, sys.stdin.readline().split()))

def LLI():
	return [list(map(int, l.split())) for l in sys.stdin.readlines()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().split()]

def LS():
	return sys.stdin.readline().split()

def I():
	return int(sys.stdin.readline())

def F():
	return float(sys.stdin.readline())

def S():
	return input()

def pf(s):
	return print(s, flush=True)

def pe(s):
	return print(str(s), file=sys.stderr)

def main():
	n = I()
	if n == 0:
		return '0 0 0'
	if n == 1:
		return '0 0 1'
	if n == 2:
		return '0 1 1'
	a = [0, 1]
	while a[-1] != n:
		a.append(a[-1] + a[-2])
	return '{} {} {}'.format(a[-5], a[-4], a[-2])
print(main())


n = int(input())
l = []
l.append(0)
l.append(1)
ind = 2
while l[ind - 1] + l[ind - 2] <= n:
	l.append(l[ind - 1] + l[ind - 2])
	ind += 1
if n == 0:
	f = 0
	s = 0
	t = 0
elif n == 1:
	f = 0
	s = 0
	t = 1
else:
	f = l[ind - 3]
	s = l[ind - 3]
	t = l[ind - 4]
print(str(f) + ' ' + str(s) + ' ' + str(t))


n = int(input())
x = [0, 1]
i = 0
if n == 0:
	print(0, 0, 0)
elif n == 1:
	print(1, 0, 0)
elif n == 2:
	print(1, 1, 0)
else:
	while x[i + 1] < n:
		x.append(x[i] + x[i + 1])
		i += 1
	print(x[i - 3], x[i - 2], x[i])


def readln():
	return tuple(map(int, input().split()))
(n,) = readln()
print(0, 0, n)


import sys, math, string, bisect
input = sys.stdin.readline
from collections import deque
L = lambda : list(map(int, input().split()))
Ls = lambda : list(input().split())
M = lambda : map(int, input().split())
print(0, 0, input())


n = int(input())
f0 = 0
f1 = 1
while f1 < n:
	f2 = f1
	f1 = f1 + f0
	f0 = f2
a = f0
f0 = 0
f1 = 1
while a + f1 < n:
	f2 = f1
	f1 = f1 + f0
	f0 = f2
b = f0
f0 = 0
f1 = 1
while a + b + f1 < n:
	f2 = f1
	f1 = f1 + f0
	f0 = f2
c = f1
if n == 0:
	c = 0
if a + b + c == n:
	if n == 2:
		print(str(1) + ' ' + str(1) + ' ' + str(0))
	elif n == 3:
		print(str(1) + ' ' + str(1) + ' ' + str(1))
	else:
		print(str(c) + ' ' + str(b) + ' ' + str(a))
else:
	print("I'm too stupid to solve this problem")


def fib_ser(k):
	li = [0, 1]
	a = 0
	b = 1
	for i in range(1, k + 1):
		li.append(a + b)
		c = a + b
		a = b
		b = c
		if li[-1] == k:
			break
	return li
n = int(input())
if n == 0:
	print('0 0 0')
elif n == 1:
	print('0 0 1')
elif n == 2:
	print('0 1 1')
else:
	li1 = fib_ser(n)
	print(li1[-5], li1[-4], li1[-2])


x = input()
print('0 0 ' + x)


n = int(input())
print('0 0 {}'.format(n))


n = int(input())
s = 0
f = 1
pre = 1
c = 0
if n == 0:
	print(0, 0, 0)
else:
	while f != n:
		pre = f
		f = f + s
		c = s
		s = pre
	print(0, c, pre)


n = int(input())
e = 5 ** 0.5

def fib(i):
	return round(1 / e * ((1 + e) / 2) ** i)
a = []
i = 0
while fib(i) <= n:
	a.append(fib(i))
	i += 1
k = len(a)
if k == 1:
	print('0 0 0')
elif k == 2:
	print('1 0 0')
elif k == 3:
	print('1 0 0')
elif k == 4:
	print('1 1 0')
elif k >= 5:
	s = ''
	s += str(a[k - 3])
	s += ' '
	s += str(a[k - 3])
	s += ' '
	s += str(a[k - 4])
	print(s)


def findIndex(n):
	if n <= 1:
		return n
	a = 0
	b = 1
	c = 1
	res = 1
	while c < n:
		c = a + b
		res = res + 1
		a = b
		b = c
	return res

def fibo(n):
	if n < 0:
		raise ValueError('Negative arguments not implemented')
	return fcci(n)[0]

def fcci(n):
	if n == 0:
		return (0, 1)
	else:
		(a, b) = fcci(n // 2)
		c = a * (b * 2 - a)
		d = a * a + b * b
		if n % 2 == 0:
			return (c, d)
		else:
			return (d, c + d)
fb = int(input())
if findIndex(fb) < 4:
	if findIndex(fb) == 3:
		print(0, 1, 1)
	elif findIndex(fb) == 2 or findIndex(fb) == 1:
		print(0, 0, 1)
	else:
		print(0, 0, 0)
else:
	print(fibo(findIndex(fb) - 4), fibo(findIndex(fb) - 3), fibo(findIndex(fb) - 1))


def fib3():
	n = int(input())
	if n == 0:
		return ' '.join([str(x) for x in [0, 0, 0]])
	if n == 1:
		return ' '.join([str(x) for x in [0, 0, 1]])
	c = 0
	b = 1
	a = 1
	while True:
		if a + b == n:
			return ' '.join([str(x) for x in [b, c, b]])
		(a, b, c) = (a + b, a, b)
print(fib3())


a = int(input())
if a == 0:
	print('0 0 0')
else:
	s = 0
	d = 1
	w = 0
	while s + d != a:
		(s, d) = (d, s + d)
	print('0', s, d)


import math

def fibonacci(n):
	if math.sqrt(5 * n * n + 4) % 1 == 0 or math.sqrt(5 * n * n - 4) % 1 == 0:
		return True
	return False
n = int(input())
if n == 0:
	print(0, 0, 0)
elif n == 1:
	print(1, 0, 0)
elif n == 2:
	print(1, 1, 0)
else:
	print(n, 0, 0)


n = int(input())
f = [0, 1]
i = 2
while f[-1] < n:
	f = f + [f[i - 1] + f[i - 2]]
	i += 1
i -= 1
a = f[i - 1]
r = n - a
c = b = -1
j = i - 1
while b == -1:
	if f[j] <= r:
		b = f[j]
	j -= 1
r -= b
j = i - 1
while c == -1:
	if f[j] <= r:
		c = f[j]
	j -= 1
if a + b + c == n:
	print(a, b, c)
elif n == 1:
	print('1 0 0')
else:
	print("I'm too stupid to solve this problem")


def fibo(n):
	fibo_list = [0]
	(a, b) = (0, 1)
	while b < n:
		(a, b) = (b, a + b)
		fibo_list.append(a)
	return fibo_list
n = int(input())
if n == 0:
	print(0, 0, 0)
elif n == 1:
	print(1, 0, 0)
elif n == 2:
	print(2, 0, 0)
else:
	main = fibo(n)
	if n == main[len(main) - 1] + main[len(main) - 3] + main[len(main) - 4]:
		print(main[len(main) - 1], main[len(main) - 3], main[len(main) - 4])
	else:
		print("I'm too stupid to solve this problem")


import sys, math, string, bisect
input = sys.stdin.readline
from collections import deque
L = lambda : list(map(int, input().split()))
Ls = lambda : list(input().split())
M = lambda : map(int, input().split())
fib = [0] * 10 * 5
fib[1] = 1
for i in range(2, 10 * 5):
	fib[i] = fib[i - 1] + fib[i - 2]
n = int(input())
l = []
p = n
for i in range(3):
	k = bisect.bisect_right(fib, n) - 1
	n -= fib[k]
	l.append(fib[k])
if sum(l) == p:
	print(*l)
else:
	print("I'm too stupid to solve this problem")


n = int(input())
l = [0, 1]
i = 0
k = 1
j = 0
if n > 3:
	while j <= n:
		j = i + k
		l.append(k)
		i = k
		k = j
	c = len(l)
	print(l[c - 2], l[c - 5], l[c - 4])
elif n == 0:
	print(0, 0, 0)
elif n == 1:
	print(0, 0, 1)
elif n == 2:
	print(1, 1, 0)
elif n == 3:
	print(1, 1, 1)


from collections import Counter
n = int(input())
arr = []
arr.append(0)
arr.append(1)
res = []
i = 2
while arr[i - 1] < n:
	arr.append(arr[i - 1] + arr[i - 2])
	i += 1
arr = list(set(arr))
mapp = Counter(arr)
if n in mapp:
	res.append(n)
	res.append(0)
	res.append(0)
if n not in mapp:
	for i in arr:
		if n - i in mapp:
			res.append(i)
			res.append(n - i)
			res.append(0)
			break
if res:
	print(*res)
else:
	print("I'm too stupid to solve this problem")


fib = [0, 1, 1]
mapping = {0: 0, 1: 2, 2: 3}
j = 4
while fib[-1] <= 10 ** 10:
	fib.append(fib[-1] + fib[-2])
	mapping.update({fib[-1] + fib[-2]: j})
	j += 1
n = int(input())
ind = 0
if n == 2:
	print(0, 1, 1)
elif n == 1:
	print(0, 0, 1)
elif n == 0:
	print(0, 0, 0)
else:
	ind = mapping[n]
	print(fib[ind - 4], fib[ind - 3], fib[ind - 1])


n = int(input())
if n == 0:
	print('0 0 0')
elif n == 1:
	print('0 0 1')
elif n == 2:
	print('0 1 1')
else:
	a = [0, 1, 1]
	m = 3
	while a[m - 1] < n:
		a.append(a[m - 1] + a[m - 2])
		m += 1
	print(str(a[m - 2]) + ' ' + str(a[m - 4]) + ' ' + str(a[m - 5]))


n = int(input())
a = []
a.append(0)
a.append(1)
a.append(1)
i = 2
while a[i] <= n:
	b = a[i] + a[i - 1]
	a.append(b)
	i = i + 1
if n == 0:
	print('0 0 0')
elif n == 1:
	print('0 0 1')
elif n == 2:
	print('0 1 1')
elif n == 3:
	print('1 1 1')
elif a[i - 1] == n:
	print(a[i - 5], a[i - 4], a[i - 2])
else:
	print("I'm too stupid to solve this problem")


input_fib_nummber = int(input())
fib = [0, 1, 1, 2]
if input_fib_nummber == 0:
	print(0, 0, 0)
elif input_fib_nummber == 1:
	print(0, 0, 1)
else:
	while True:
		if fib[3] == input_fib_nummber:
			print(fib[0], fib[1], fib[1])
			break
		fib = [fib[1], fib[2], fib[3], fib[2] + fib[3]]


n = int(input())

def main(n):
	if n == 0:
		print(0, 0, 0)
		return 0
	if n == 1:
		print(0, 0, 1)
		return 0
	fibs = [0, 1, 1, 2]
	while fibs[-1] < n:
		fibs.append(fibs[-2] + fibs[-1])
	index = len(fibs) - 1
	if index > 2:
		print(fibs[index - 2], fibs[index - 2], fibs[index - 3])
main(n)


n = int(input())
f = [0] * 44
i = 1
f[0] = 0
f[1] = 1
while f[i] < 1000000000 and i != 44:
	i += 1
	f[i] = f[i - 1] + f[i - 2]
	f.append(f[i])
for i in range(len(f)):
	for j in range(len(f)):
		for k in range(len(f)):
			if f[i] + f[j] + f[k] == n:
				print(f[i], f[j], f[k])
				exit()
print('I' + chr(39) + 'm too stupid to solve this problem')


IL = lambda : list(map(int, input().split()))
I = lambda : int(input())
F = [0, 1]
for i in range(1000):
	F.append(sum(F[-2:]))
n = I()
if n < 4:
	print(' '.join((['0', '0', '0'] + ['1' for i in range(n)])[-3:]))
else:
	d = F.index(n)
	print(F[d - 4], F[d - 3], F[d - 1])


number = int(input())
if number == 0:
	print(0, 0, 0)
else:
	A = [0, 1, 1]
	while True:
		if A[len(A) - 1] * 3 < number:
			A.append(A[len(A) - 1] + A[len(A) - 2])
		elif A[len(A) - 1] * 3 == number:
			print(A[len(A) - 1], A[len(A) - 1], A[len(A) - 1])
			break
		elif A[len(A) - 1] * 2 + A[len(A) - 2] < number:
			print(number, 0, 0)
			break
		elif A[len(A) - 1] * 2 + A[len(A) - 2] == number:
			print(A[len(A) - 2], A[len(A) - 1], A[len(A) - 1])
			break
		elif A[len(A) - 1] + A[len(A) - 2] + A[len(A) - 3] < number:
			print(number, 0, 0)
			break
		elif A[len(A) - 1] + A[len(A) - 2] + A[len(A) - 3] == number:
			print(A[len(A) - 3], A[len(A) - 2], A[len(A) - 1])
			break
		else:
			print(number, 0, 0)
			break


print('0 0 {}'.format(int(input())))


n = int(input())
if n == 0:
	print(0, 0, 0)
elif n == 1:
	print(1, 0, 0)
else:
	a = 0
	b = 1
	c = 1
	d = 2
	while d != n:
		d = c + d
		c = b + c
		temp = b
		b = a + b
		a = temp
	print(a, b, b)


import sys
input = sys.stdin.readline
n = int(input())
print(0, 0, n)


number = int(input())
fibo = [0, 1]
list = []
for i in range(2, 1000):
	fibo.append(fibo[i - 2] + fibo[i - 1])
index = int(fibo.index(number))
for No_1 in fibo[1:index]:
	for No_2 in fibo[1:index]:
		for No_3 in fibo[1:index]:
			if No_1 + No_2 + No_3 == number:
				list = [No_1, No_2, No_3]
				break
if number == 0:
	list = [0, 0, 0]
elif number == 1:
	list = [0, 0, 1]
elif number == 2:
	list = [0, 1, 1]
if len(list) == 0:
	print("I'm too stupid to solve this problem")
else:
	list.sort()
	print(*list)


def main():
	from sys import stdin, stdout
	a = [0, 1, 1]
	for _ in range(43):
		a.append(a[-1] + a[-2])
	n = int(stdin.readline())
	if n == 0:
		print(0, 0, 0)
		return
	fp = 0
	sp = 45
	while fp < sp:
		if a[fp] + a[sp] == n:
			break
		elif a[fp] + a[sp] < n:
			fp += 1
		elif a[fp] + a[sp] > n:
			sp -= 1
	if a[fp] + a[sp] == n:
		stdout.write(str(a[fp]) + ' ' + str(a[sp - 2]) + ' ' + str(a[sp - 1]) + '\n')
	else:
		stdout.write("I'm too stupid to solve this problem\n")
main()


num = int(input())
print(num, 0, 0)


n = int(input())
(i, j) = (0, 1)
mat = [0]
while j <= n:
	(i, j) = (j, j + i)
	mat.append(i)
res = []
k = len(mat) - 1
while k > -1:
	if n - mat[k] >= 0:
		res.append(mat[k])
		n -= mat[k]
		if len(res) >= 3:
			break
	else:
		k -= 1
	if n < 0:
		break
if n == 0 and len(res) == 3:
	print(*res)
else:
	print("I'm too stupid to solve this problem")


print(0, 0, int(input()))


__author__ = 'Esfandiar'
n = int(input())
ans = [0, 0, 0]
if n == 0:
	print(*[0, 0, 0])
	exit()
a = 0
b = 1
c = 0
aa = 0
while c != n:
	c = a + b
	aa = a
	a = b
	b = c
print(*[0, aa, a])


f = list([0])

def get_fib(a, b, l):
	if b + a <= l:
		f.append(a + b)
		get_fib(b, b + a, l)

def get_seq(i, c_i, c_s, n):
	if c_i == 3 and c_s == n:
		return []
	elif c_i == 3 or c_s > n:
		return None
	else:
		for j in range(i + 1):
			v = get_seq(j, c_i + 1, c_s + f[j], n)
			if v != None:
				v.append(str(f[j]))
				return v
n = int(input())
get_fib(0, 1, n)
v = get_seq(len(f) - 1, 0, 0, n)
if v != None:
	print(' '.join(v))
else:
	print("I'm too stupid to solve this problem")


a = int(input())
b = [0, 1]
while b[-1] < 10 ** 9:
	b += [b[-2] + b[-1]]
if a == 0:
	print(0, 0, 0)
elif a == 1:
	print(0, 0, 1)
elif a == 2:
	print(0, 1, 1)
else:
	c = b.index(a)
	print(b[c - 4], b[c - 3], b[c - 1])


n = int(input())
if n == 0:
	print(0, 0, 0)
	exit(0)
else:
	(a, b) = (0, 1)
	while a + b != n:
		(a, b) = (b, a + b)
		if a + b > n:
			print("I'm too stupid to solve this problem")
			exit(0)
print(0, a, b)
exit(0)


def three_fib(n):
	if n == 0:
		return (0, 0, 0)
	elif n == 1:
		return (0, 0, 1)
	else:
		(a, b, c) = (0, 0, 1)
		while b + c < n:
			(a, b, c) = (b, c, b + c)
		return (b - a, a, c)
n = int(input())
nums = three_fib(n)
print(*nums)


n = int(input())
f1 = 0
f2 = 1
s = 1
if n == 0:
	print(0, 0, 0)
	exit()
while s < n:
	s = f1 + f2
	f1 = f2
	f2 = s
if s != n:
	print("I'm too stupid to solve this problem")
else:
	print(0, 0, n)


s = [0, 1, 1]
for i in range(3, 10 ** 9):
	s.append(s[i - 1] + s[i - 2])
	if s[i] >= 10 ** 9:
		break
n = int(input())
if n not in s:
	print("I'm too stupid to solve this problem")
if n == 0:
	print('0', '0', '0')
if n == 1:
	print('0', '0', '1')
if n == 2:
	print('0', '1', '1')
if n in s[4:-1]:
	x = s.index(n)
	print(s[x - 4], s[x - 3], s[x - 1])


import sys
import math
import bisect
import itertools
import random
import re

def main():
	A = [0, 1]
	while A[-1] < 10 ** 9:
		A.append(A[-2] + A[-1])
	n = int(input())
	p = -1
	for i in range(len(A)):
		if A[i] == n:
			p = i
			break
	if p == 0:
		ans = [0, 0, 0]
	elif p == 1:
		ans = [0, 0, 1]
	elif p == 2:
		ans = [0, 0, 1]
	else:
		ans = [A[p - 3], A[p - 2], A[p - 2]]
	print(' '.join(list((str(a) for a in ans))))
main()


x = int(input())
f0 = 0
f1 = 1
f2 = 1
f3 = 2
f4 = 3
while 1:
	f0 = f1
	f1 = f2
	f2 = f3
	f3 = f4
	f4 = f2 + f3
	if x == 0:
		print('0 0 0')
		break
	elif x == 1:
		print('1 0 0')
		break
	elif x == 2:
		print('1 1 0')
		break
	elif x == 3:
		print('1 1 1')
		break
	elif f4 == x:
		print(f0, f1, f3)
		break


from collections import Counter
arr = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025, 121393, 196418, 317811]
for i in range(20):
	arr.append(arr[-1] + arr[-2])
n = int(input())
x = n
lis = []
c = Counter(arr)
for i in range(3):
	while True:
		if x in c:
			lis.append(x)
			x = n - x if n - x > 0 else 0
			n = x
			break
		x -= 1
print(' '.join(map(str, lis)))


def binSearch(a, x):
	l = -1
	r = len(a)
	while l < r - 1:
		m = (r + l) // 2
		if a[m] < x:
			l = m
		else:
			r = m
	return r
a = [0] * 47
a[1] = 1
a[2] = 1
for i in range(3, 47):
	a[i] = a[i - 1] + a[i - 2]
n = int(input())
i = binSearch(a, n)
if n == 0:
	print(0, 0, 0)
elif n == 1:
	print(0, 0, 1)
else:
	print(0, a[i - 2], a[i - 1])


dp = [0, 1] + [0] * 100
for i in range(2, 95):
	dp[i] = dp[i - 1] + dp[i - 2]
i = int(input())
if i == 0:
	print(0, 0, 0)
elif i == 1:
	print(0, 0, 1)
else:
	for a in range(2, 95):
		if dp[a] == i:
			print(0, dp[a - 1], dp[a - 2])


def prev_fibonacci(prev_fibonacci_list, n):
	if len(prev_fibonacci_list) < 4:
		a = n / ((1 + 5 ** 0.5) / 2.0)
		prev_fibonacci_list.append(round(a))
		return prev_fibonacci(prev_fibonacci_list, round(a))
	return prev_fibonacci_list
n = int(input())
if n == 3:
	(a, b, c) = (0, 1, 2)
elif n == 2:
	(a, b, c) = (0, 1, 1)
elif n == 1:
	(a, b, c) = (0, 0, 1)
elif n == 0:
	(a, b, c) = (0, 0, 0)
else:
	prev_fibonacci_numbers = prev_fibonacci([], n)
	(a, b, c) = (prev_fibonacci_numbers[3], prev_fibonacci_numbers[2], prev_fibonacci_numbers[0])
print(a, b, c)


import sys
input = sys.stdin.readline
n = int(input())
relativne = [0, 1]
while relativne[-1] < 10 ** 9:
	relativne.append(relativne[-1] + relativne[-2])
for x in relativne:
	for y in relativne:
		for z in relativne:
			if x + y + z == n:
				print(x, y, z)
				sys.exit()
print("I'm too stupid to solve this problem")


def findIndex(n):
	if n <= 1:
		return n
	a = 0
	b = 1
	c = 1
	res = 1
	while c < n:
		c = a + b
		res = res + 1
		d = a
		a = b
		b = c
	return (d, a)
n = int(input())
if n == 0:
	print(0, 0, 0)
elif n == 1:
	print(0, 0, 1)
else:
	(a, b) = findIndex(n)
	print(0, a, b)


s = [0, 0, 0, 0, 0, 0, 1]
while s[len(s) - 1] < 10 ** 9:
	x = len(s)
	s.append(s[x - 1] + s[x - 2])
i = int(input())
idx = 0
if i <= 2:
	print(0, 0, i)
else:
	for v in s:
		if v == i:
			break
		idx += 1
	print(s[idx - 4], s[idx - 3], s[idx - 1])


n = int(input())
t = []
while n > 0:
	l = [0, 1]
	while l[0] + l[1] <= n:
		a = l[0] + l[1]
		l[0] = l[1]
		l[1] = a
	n = n - l[1]
	t.append(l[1])
for i in range(3 - len(t)):
	t.append(0)
if len(t) > 3:
	print('Im too stupid to solve this problem')
else:
	print(*t)


def fibnoci(n):
	(p, q, r) = (0, 1, 0)
	if n == 0:
		return 0
	else:
		while r < n:
			r = p + q
			p = q
			q = r
		return p
t = int(input())
a = t
b = []
c = 0
while t >= 0 and len(b) < 3:
	if t == 2 and len(b) == 2:
		c = 2
	elif t == 3 and len(b) < 2:
		c = 1
	elif len(b) == 2 and t == a - b[0] - b[1]:
		c = t
	else:
		c = fibnoci(t)
	b += [c]
	t -= c
b.reverse()
if len(b) == 3:
	print(*b)
else:
	print("I'm too stupid to solve this problem")


a = [0, 1]
n = int(input())
i = 2
r = 0
while r < n:
	r = a[i - 1] + a[i - 2]
	a.append(r)
	i += 1
l = len(a) - 1
if n > 3:
	print(a[l - 4], a[l - 3], a[l - 1])
elif n == 3:
	print(1, 1, 1)
elif n == 2:
	print(0, 1, 1)
elif n == 1:
	print(0, 0, 1)
elif n == 0:
	print(0, 0, 0)


fib1 = 0
fib2 = 1
fib0 = 0
fibx = int(input())
while fib2 < fibx:
	fib_sum = fib1 + fib2
	fib0 = fib1
	fib1 = fib2
	fib2 = fib_sum
print(0, fibx - fib1, fib1)


print(f'0 0 {input()}')


def main():
	n = input()
	print(0, 0, n)
main()


n = int(input())

def generate(nx):
	arr = [0, 1]
	initial = 0
	while initial < nx:
		initial = arr[-1] + arr[-2]
		arr.append(initial)
	return arr

def solve(x):
	arr = generate(x)
	pairs = []
	for i in range(len(arr) - 1):
		if arr[i] * 3 == x:
			print(arr[i], arr[i], arr[i])
			return
		for j in range(1, len(arr)):
			pairs.append([arr[i], arr[j]])
	for i in range(len(pairs)):
		if x - sum(pairs[i]) in arr:
			print(*pairs[i], x - sum(pairs[i]))
			return
	print("I'm too stupid to solve this problem")
solve(n)


fibo = [0, 1]
for i in range(1000):
	x = fibo[i] + fibo[i + 1]
	fibo.append(x)
	i += 1
x = int(input())
z = fibo.index(x)
while True:
	if x <= 1:
		print(x, '0 0')
		exit()
	elif x == 2:
		print('0 1 1')
		exit()
	else:
		x = x - fibo[z - 1] - fibo[z - 3] - fibo[z - 4]
		if x == 0:
			print(fibo[z - 4], fibo[z - 3], fibo[z - 1])
			exit()
		else:
			print("I'm too stupid to solve this problem")
			exit()


ser = [0, 1]

def fib(n):
	i = 1
	while i < n:
		ser.append(i)
		i = ser[-1] + ser[-2]
	if i != n:
		return -1
	else:
		return len(ser)
n = int(input())
(a, b, c) = (0, 0, 0)
ans = 1
if n == 0:
	ans = 1
elif n == 1:
	a = 1
elif n == 2:
	a = 1
	b = 1
elif n == 3:
	a = 1
	b = 1
	c = 1
else:
	ans = fib(n)
	if ans != -1:
		a = ser[ans - 2]
		b = ser[ans - 2]
		c = ser[ans - 3]
if ans != -1:
	print(a, b, c)
else:
	print("I'm too stupid to solve this problem")


n = int(input())
if n == 0:
	print(0, 0, 0)
elif n == 1:
	print(0, 0, 1)
else:
	(a, b) = (1, 1)
	k = 0
	while a + b < n:
		(a, b) = (b, a + b)
	c = b - a
	d = a - c
	print(d, c, b)


n = int(input())
if n != 2:
	a = n / ((1 + 5 ** 0.5) / 2.0)
	b = a / ((1 + 5 ** 0.5) / 2.0)
	c = b / ((1 + 5 ** 0.5) / 2.0)
	d = c / ((1 + 5 ** 0.5) / 2.0)
else:
	d = 1
	c = 1
	a = 0
print(round(d), round(c), round(a))


def hexa(n):
	l = []
	l.append(0)
	l.append(1)
	i = 2
	while n not in l:
		l.append(l[i - 1] + l[i - 2])
		i = i + 1
	m = l.index(n)
	if n == 1:
		return '1 0 0'
	elif n == 2:
		return '0 1 1'
	elif n == 0:
		return '0 0 0'
	elif n == 3:
		return '1 1 1'
	else:
		return str(l[m - 1]) + ' ' + str(l[m - 3]) + ' ' + str(l[m - 4])
n = int(input())
print(hexa(n))


print('0 0 %s' % input())


n = int(input())
if n == 0:
	print(0, 0, 0)
elif n == 1:
	print(0, 0, 1)
else:
	(a, b) = (0, 1)
	while True:
		if 2 * b + a == n:
			print(a, b, b)
			break
		c = a + b
		(a, b) = (b, c)


from bisect import bisect
f = [0, 1, 1, 2, 3]
i = 5
cur = 3
while cur < int(10000000000.0):
	cur = f[i - 1] + f[i - 2]
	f.append(cur)
	i += 1

def main(n):
	if n == 0:
		return '0 0 0'
	if n == 1:
		return '0 0 1'
	i = bisect(f, n) - 1
	a = f[i - 2]
	b = f[i - 2]
	c = f[i - 3]
	return '{} {} {}'.format(a, b, c)
print(main(int(input())))


n = int(input())
if n == 0:
	print(0, 0, 0)
elif n == 1:
	print(0, 0, 1)
elif n == 2:
	print(0, 1, 1)
else:
	old = 0
	i = 1
	old = 1
	vold = 1
	while i < n:
		vold = old
		old = i
		i = old + vold
	print(0, old, vold)


import math
x = int(input())
if x == 1:
	print(0, 0, 1)
elif x == 2:
	print(0, 1, 1)
else:
	g = (1 + math.sqrt(5)) / 2
	p = round(x / g)
	p2 = round(p / g)
	p3 = round(p2 / g)
	print(p2, p2, p3)


k = int(input())
x = 0
y = 1
z = x + y
if k == 0:
	print(0, 0, 0)
else:
	while z != k:
		x = y
		y = z
		z = x + y
	print(0, x, y)


n = int(input())
if n == 0:
	print(0, 0, 0)
	exit()
if n == 1:
	print(0, 0, 1)
	exit()
fibonacci = [0, 1, 1, 2]
while fibonacci[-1] != n:
	fibonacci.append(fibonacci[-1] + fibonacci[-2])
print(fibonacci[-4], fibonacci[-3], fibonacci[-3])


numerin = input()
print('0 0 ' + numerin)


f = lambda : map(int, input().split())
a = '0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711 28657 46368 75025 121393 196418 317811 514229 832040 1346269 2178309 3524578 5702887 9227465 14930352 24157817 39088169 63245986 102334155 165580141 267914296 433494437 701408733 1134903170'
a = a.split()
n = input()
if int(n) > 3:
	print(a[a.index(n) - 1], a[a.index(n) - 3], a[a.index(n) - 4])
elif n == '3':
	print('1 1 1')
elif n == '2':
	print('0 1 1')
elif n == '1':
	print('0 0 1')
else:
	print('0 0 0')


n = int(input())
a1 = list()
a1.append(0)
a1.append(1)
i = 0
num = 0
if n == 0:
	print('0 0 0')
else:
	while num <= n:
		num = a1[i] + a1[i + 1]
		a1.append(num)
		i += 1
	a1.pop()
	if a1[-1] != n:
		print("I'm too stupid to solve this problem")
	else:
		print(str(a1[-2]) + ' ' + str(a1[-3]) + ' ' + str(a1[0]))


fib = [0, 1]
n = int(input())
j = 2
if n == 0:
	print('0 0 0')
else:
	while True:
		fib.append(fib[j - 1] + fib[j - 2])
		if fib[j] == n:
			print('0', fib[j - 1], fib[j - 2])
			break
		j += 1


n = int(input())
if n == 0:
	print(*[0, 0, 0])
elif n == 1:
	print(*[0, 0, 1])
else:
	prev2 = 0
	prev1 = 1
	prev = 1
	while prev != n:
		curr = prev + prev1
		prev2 = prev1
		prev1 = prev
		prev = curr
	print(*[0, prev2, prev1])


(n, ans) = (int(input()), '')
t = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025, 121393, 196418, 317811, 514229, 832040, 1346269, 2178309, 3524578, 5702887, 9227465, 14930352, 24157817, 39088169, 63245986, 102334155, 165580141, 267914296, 433494437, 701408733, 1134903170]
for j in range(3):
	i = 0
	while t[i] <= n:
		i += 1
	n -= t[i - 1]
	ans += str(t[i - 1]) + ' '
if n == 0:
	print(ans)
else:
	print("I'm too stupid to solve this problem")


import sys
import math
n = int(sys.stdin.readline())
print('0 0 ' + str(n))


fibbo = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025, 121393, 196418, 317811, 514229, 832040, 1346269, 2178309, 3524578, 5702887, 9227465, 14930352, 24157817, 39088169, 63245986, 102334155, 165580141, 267914296, 433494437, 701408733]
n = int(input())
status = 0
if n in fibbo:
	print(0, 0, n)
elif n / 3 in fibbo:
	print(n // 3, n // 3, n // 3)
else:
	for i in range(n, 0, -1):
		if i in fibbo:
			print(i, end=' ')
			break
	for j in range(n - i, 0, -1):
		if j in fibbo:
			print(j, end=' ')
			break
	for k in range(n - i - j, 0, -1):
		if k in fibbo:
			print(k)
			break


import sys
import math
import collections
from collections import deque
from functools import reduce
from sys import stdin, stdout, setrecursionlimit
setrecursionlimit(2 ** 20)

def factors(n):
	return list(set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0))))
T = 1
for _ in range(T):
	n = int(stdin.readline())
	print(*[0, 0, n])


n = int(input())
fibo = [0, 1]
for i in range(50):
	fibo.append(fibo[i + 1] + fibo[i])
i = fibo.index(n)
if i > 2:
	print(fibo[i - 2], fibo[i - 2], fibo[i - 3])
elif n == 1:
	print('0 0 1')
elif n == 0:
	print('0 0 0')


n = int(input())
if n == 0:
	print(0, 0, 0)
elif n == 1:
	print(0, 0, 1)
elif n == 2:
	print(0, 1, 1)
else:
	f = [0]
	i = 1
	while i <= n:
		f.append(i)
		i = f[-1] + f[-2]
	print(f[-4], f[-3], f[-3])


n = int(input())
fib = [0, 1]
if n > 1:
	while fib[-1] != n:
		fib.append(fib[-1] + fib[-2])
	if n != 2:
		print(fib[-5], fib[-4], fib[-2])
	else:
		print(fib[-4], fib[-3], fib[-2])
else:
	print('0 ' * (3 - n) + '1' * n)


f = int(input())
print(f, ' 0 0')


def main():
	n = int(input())
	print('0 0', n)
	return
main()


import sys
input = sys.stdin.readline

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 nCr(n, k):
	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 = 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)]
	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(1000000.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

def factoriazation(x):
	ret = {}
	while x != 1:
		ret[spf[x]] = ret.get(spf[x], 0) + 1
		x = x // spf[x]
	return ret

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

def str_array():
	return input().strip().split()
MOD = int(1000000000.0) + 7
CMOD = 998244353
INF = float('inf')
NINF = -float('inf')
n = int(input())
print(0, 0, n)


n = int(input())
a = 0
b = 1
print(0, 0, n)


n = int(input())
fibo = [0, 1]
while fibo[-1] < n:
	fibo.append(fibo[-1] + fibo[-2])
t = fibo.index(fibo[-1])
if n > 2:
	print(fibo[t - 4], fibo[t - 3], fibo[t - 1])
elif n == 2:
	print(0, 1, 1)
elif n == 1:
	print(0, 0, 1)
else:
	print(0, 0, 0)


n = int(input())
if n < 3:
	print('0 ' * (3 - n) + '1 ' * n)
else:
	f = 0
	f1 = 1
	f2 = 1
	f3 = 2
	f4 = 3
	while f4 != n:
		f4 += f3
		f3 += f2
		f2 += f1
		(f, f1) = (f1, f1 + f)
	print(f, f1, f3)


n = int(input())
if n >= 2:
	(a, b, value) = (0, 1, 0)
	while a + b < n:
		value = a
		(a, b) = (b, a + b)
	print(str(value), str(a), str(a))
elif n == 1 or n == 0:
	print('0', '0', str(n))


from collections import *
n = int(input())
if n == 3:
	print('1 1 1')
elif n == 1:
	print('1 0 0')
elif n == 2:
	print('1 1 0')
elif n == 0:
	print('0 0 0 ')
else:
	F = deque([1, 1], maxlen=4)
	while F[-1] != n:
		F.append(F[-1] + F[-2])
	print(F[-3], end=' ')
	print(F[-3], end=' ')
	print(F[-4], end=' ')


def get_sum(d, n):
	for i in d:
		if d[i] == n:
			print(d[i - 1], d[i - 2])

def main():
	n = int(input())
	if n == 0:
		print(0, 0, 0)
		return
	if n == 1:
		print(0, 0, 1)
		return
	if n == 2:
		print(0, 1, 1)
		return
	d = {}
	d[0] = 0
	d[1] = 1
	for i in range(2, 51):
		d[i] = d[i - 1] + d[i - 2]
	for i in d:
		if d[i] == n:
			print(d[i - 2], end=' ')
			get_sum(d, d[i - 1])
main()


import math

def ps(a):
	s = int(math.sqrt(a))
	return s * s == a

def check(a):
	return ps(5 * a * a + 4) or ps(5 * a * a - 4)
t = int(input())
if check(t) == True:
	print(0, 0, t)
else:
	print("I'm too stupid to solve this problem")


n = int(input())
l = [0, 1]
if n == 0:
	print('0 0 0')
elif n == 1:
	print('0 0 1')
else:
	while l[-1] != n:
		l.append(l[-1] + l[-2])
	print(l[-3], l[-3], l[-4], end=' ')


x = int(input())
z = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025, 121393, 196418, 317811, 514229, 832040, 1346269, 2178309, 3524578, 5702887, 9227465, 14930352, 24157817, 39088169, 63245986, 102334155, 165580141, 267914296, 433494437, 701408733]
check = True
for i in range(0, len(z)):
	if check == False:
		break
	for l in range(0, len(z)):
		if check == False:
			break
		for k in range(0, len(z)):
			if z[i] + z[l] + z[k] == x:
				check = False
				print(z[i], z[l], z[k])
				break


k = eval(input())
a = []
a.append(0)
a.append(0)
a.append(k)
print(a[0], a[1], a[2])


n = int(input())
print(0, end=' ')
print(0, end=' ')
print(n, end=' ')


from functools import lru_cache

@lru_cache(maxsize=50)
def fib(n):
	if n <= 1:
		return 0
	if n in (2, 3):
		return 1
	return fib(n - 1) + fib(n - 2)
fib_nums = set()
for i in range(1, 47):
	fib_nums.add(fib(i))
inp = int(input())
if inp in fib_nums:
	print(0, 0, inp)
else:
	print("I'm too stupid to solve this problem")


m = {}
fibo = [0] * 47
fibo[1] = 1
m[0] = 0
for i in range(2, 47):
	fibo[i] = fibo[i - 2] + fibo[i - 1]
	m[fibo[i]] = i
n = int(input())
if n == 0:
	print(0, 0, 0)
	exit(0)
print(fibo[m[n] - 1], fibo[m[n] - 2], 0)


n = int(input())
pibo = [0, 1]
while True:
	pibo.append(pibo[-1] + pibo[-2])
	if pibo[-1] > 1000000000:
		break
if n == 0:
	print(0, 0, 0)
elif n == 1:
	print(1, 0, 0)
else:
	tmp = pibo.index(n)
	print(pibo[tmp - 2], pibo[tmp - 2], pibo[tmp - 3])


n = int(input())
print(f'0 0 {n}')


import sys
inpt = sys.stdin.readline()
n = int(inpt)
t = 1
a = b = 0
if n <= 1:
	print(0, 0, n)
else:
	while True:
		if t == n:
			print(0, a, b)
			break
		else:
			a = b
			b = t
			t = a + b


x = int(input())
print('0 0 {}'.format(x))


from itertools import product
from math import ceil

def binary_table(string_with_all_characters, length_to_make):
	return [''.join(x) for x in product(string_with_all_characters, repeat=length_to_make)]

def all_possible_substrings(string):
	return [string[i:j] for i in range(len(string)) for j in range(i + 1, len(string) + 1)]

def number_of_substrings(length):
	return int(length * (length + 1) / 2)

def is_prime(num):
	for i in range(2, num):
		if num / i == int(num / i) and num != i:
			return False
	return True
num = int(input())
if num == 0:
	print(*[0, 0, 0])
elif num == 1:
	print(*[0, 0, 1])
elif num == 2:
	print(*[0, 1, 1])
elif num == 3:
	print(*[1, 1, 1])
else:
	first = 0
	second = 0
	third = 0
	fourth = 1
	broken = False
	while True:
		temp = third + fourth
		if temp == num:
			break
		elif temp > num:
			broken = True
			break
		first = second
		second = third
		third = fourth
		fourth = temp
	if broken:
		print("I'm too stupid to solve this problem")
	else:
		print(first, second, fourth)


from sys import *
n = int(input())
fib_num = []
fib_num.append(0)
fib_num.append(1)
(a, b) = (0, 1)
c = 1
while c < n:
	fib_num.append(c)
	a = b
	b = c
	c = a + b
i = 0
found = False
while i < len(fib_num):
	j = 0
	while j < len(fib_num):
		if fib_num[i] + fib_num[j] > n:
			break
		k = 0
		while k < len(fib_num):
			if fib_num[i] + fib_num[j] + fib_num[k] > n:
				break
			elif fib_num[i] + fib_num[j] + fib_num[k] == n:
				print(fib_num[i], fib_num[j], fib_num[k])
				found = True
				break
			k = k + 1
		if found:
			break
		j = j + 1
	if found:
		break
	i = i + 1
if found == False:
	print("I'm too stupid to solve this problem")


n = int(input())
phi = 1.6180339
count = 5
arr = [0, 1, 1, 2, 3, 5]
fn = 5

def round_int(x):
	if x == float('inf') or x == float('-inf'):
		return float('nan')
	return int(round(x))
if n == 0:
	print(0, 0, 0)
elif n == 1:
	print(0, 0, 1)
elif n == 2:
	print(0, 1, 1)
elif n == 3:
	print(0, 1, 2)
elif n == 5:
	print(0, 2, 3)
else:
	while fn != n:
		count += 1
		fn = arr[count - 1] + arr[count - 2]
		arr.append(fn)
	else:
		print(arr[count - 1], arr[count - 3], arr[count - 4])
		exit()


a = int(input())
d = {}
(p, q) = (0, 1)
if a == 0:
	print(0, 0, 0)
elif a == 1:
	print(0, 0, 1)
else:
	while q != a:
		c = p + q
		d[c] = [p, q]
		p = q
		q = c
	print(d[c][0], d[d[c][1]][0], d[d[c][1]][1])


from sys import setrecursionlimit
setrecursionlimit = 100000000000000
dp = [0] * 46
dp[0] = 0
dp[1] = 1

def fibo(n):
	for i in range(2, n):
		dp[i] = dp[i - 1] + dp[i - 2]
	return
fibo(46)
n = int(input())
if n == 3:
	print('1 1 1')
	exit()
elif n == 0:
	print('0 0 0')
	exit()
elif n == 1:
	print('0 0 1')
	exit()
elif n == 2:
	print('0 1 1')
	exit()
a = dp.index(n)
z = []
z.append(dp[a - 1])
z.append(dp[a - 3])
z.append(dp[a - 4])
print(*z)


i = int(input())
f = 0
s = 1
t = f + s
if i == 0:
	print('0 0 0')
else:
	series = [1]
	while t < i:
		f = s
		s = t
		t = f + s
		series.append(t)
	series.append(0)
	found = 0
	for j in series:
		for k in series:
			total = j + k
			if i - total in series:
				print(j, k, i - total)
				found = 1
				break
		if found == 1:
			break
	if found == 0:
		print("I'm too stupid to solve this problem")


p = int(input())
print(0, 0, p)


n = int(input())

def Fib(n):
	if n == 3:
		return '1 1 1'
	if n == 0:
		return '0 0 0'
	if n == 1:
		return '0 0 1'
	if n == 2:
		return '0 1 1'
	else:
		d = {}
		d[1] = 0
		d[2] = 1
		i = 3
		while d[i - 1] != n:
			if i not in d:
				d[i] = d[i - 1] + d[i - 2]
			i = i + 1
		return ' '.join(list(map(str, [d[i - 5], d[i - 4], d[i - 2]])))
print(Fib(n))


n = int(input())

def fib(n):
	a = [0, 1]
	if n == 1 or n == 1:
		return a
	i = 0
	while i <= n:
		i = a[-1] + a[-2]
		a.append(i)
	return a
if n == 0:
	print('0 0 0')
elif n == 1:
	print('1 0 0 ')
elif n == 2:
	print('1 1 0')
elif n == 3:
	print('1 1 1')
else:
	a = fib(n)
	print(str(a[-3]) + ' ' + str(a[-5]) + ' ' + str(a[-6]))


f = [0, 0, 0, 0, 0, 1]
i = int(input())
while f[-1] <= i:
	f.append(f[-1] + f[-2])
print(*([f[-3], f[-5], f[-6]] if i != 2 else '1 1 0'))


n = int(input())
f = -1
s = 1
t = 0
a = []
while t < n:
	t = f + s
	a.append(t)
	f = s
	s = t
if len(a) >= 5:
	print(a[-2], a[-4], a[-5])
elif n == 2:
	print('0 1 1')
elif n == 1:
	print('0 0 1')
elif n == 0:
	print('0 0 0')


numero = input()
print('0 0 ' + numero)


inp = input()
print('0 0', inp)


A = [0, 1]
for i in range(2, 51):
	k = A[i - 2] + A[i - 1]
	A.append(k)
n = int(input())
p = 0
if n == 0:
	print(0, 0, 0)
elif n == 1:
	print(0, 0, 1)
else:
	for a in A:
		for b in A:
			for c in A:
				if a != n and b != n and (c != n) and (a + b + c == n):
					print(a, b, c)
					p = 1
					break
			if p == 1:
				break
		if p == 1:
			break


import itertools
import math
from collections import defaultdict

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

def solve():
	print(input(), 0, 0)
solve()


from sys import stdin
input = stdin.readline

def solve():
	n = int(input())
	if n <= 5:
		print(0, 0, n)
		return
	dp = [1, 1]
	while dp[-1] < n:
		dp.append(dp[-2] + dp[-1])
	print(dp[-2], dp[-4], dp[-5])
solve()


def main():
	N = int(input())
	print(0, 0, N)
main()


def main():
	print(0, 0, input())
main()


n = int(input())
f = [0, 1, 1, 2, 3]
if n <= 3:
	ans = [0] * (3 - n) + [1] * n
else:
	while f[-1] < n:
		f = [f[1], f[2], f[3], f[4], f[3] + f[4]]
	ans = [f[0], f[1], f[3]]
print(*ans)


n = int(input())
if n == 0:
	print(0, 0, 0)
elif n == 1:
	print(1, 0, 0)
else:
	fib = [0, 1, 1, 2]
	while n not in fib:
		fib.append(fib[-1] + fib[-2])
	print(fib[-4], fib[-3], fib[-3])


def main():
	n = int(input())
	print('{} 0 0'.format(n))
main()


a = 0
b = 1
ans = [a, b]
while True:
	c = ans[-1] + ans[-2]
	if c <= 10 ** 9:
		ans.append(c)
	else:
		break
n = int(input())
for i in ans:
	for j in ans:
		for k in ans:
			if i + j + k == n:
				print(i, j, k)
				exit()
print("I'm too stupid to solve this problem")


n = int(input())

def fun(n):
	i = 0
	j = 1
	k = 1
	t = 2
	while t != n:
		(i, j, k, t) = (j, k, t, t + k)
	print(j, i, j)
if n == 0:
	print(0, 0, 0)
elif n == 1:
	print(1, 0, 0)
else:
	fun(n)


def binarysearch(L, left, right, k):
	mid = (left + right) // 2
	if L[left] == k:
		return left
	elif L[right] == k:
		return right
	elif L[mid] == k:
		return mid
	elif L[right] < k or L[left] > k:
		return -1
	elif L[mid] < k:
		return binarysearch(L, mid + 1, right, k)
	elif L[mid] > k:
		return binarysearch(L, left, mid, k)
	else:
		return -1

def theorem(n):
	if n == 0:
		return '0' + ' ' + '0' + ' ' + '0'
	elif n == 1:
		return '1' + ' ' + '0' + ' ' + '0'
	elif n == 2:
		return '1' + ' ' + '1' + ' ' + '0'
	elif n == 3:
		return '1' + ' ' + '1' + ' ' + '1'
	else:
		L = [0, 1, 1] + [-1] * 43
		for i in range(2, len(L)):
			L[i] = L[i - 1] + L[i - 2]
		k = binarysearch(L, 0, len(L) - 1, n)
		return str(L[k - 2]) + ' ' + str(L[k - 2]) + ' ' + str(L[k - 3])
n = int(input())
print(theorem(n))


from sys import stdin, stdout
import math
from itertools import permutations, combinations
from collections import defaultdict
from bisect import bisect_left

def L():
	return list(map(int, stdin.readline().split()))

def In():
	return map(int, stdin.readline().split())

def I():
	return int(stdin.readline())
P = 1000000007
lis = [0, 1]
for i in range(2, 100):
	lis.append(lis[i - 1] + lis[i - 2])
n = I()
print(0, 0, n)


def fibo(n):
	if n == 0 or n == 1:
		return list()
	else:
		l = list()
		l.append(0)
		l.append(1)
		while True:
			x = l[len(l) - 1]
			y = l[len(l) - 2]
			z = x + y
			l.append(z)
			if z == n:
				break
		return l
n = int(input())
l = fibo(n)
if len(l) == 0:
	if n == 0:
		print(0, 0, 0)
	else:
		print(0, 0, 1)
else:
	x = l[len(l) - 3]
	y = l[len(l) - 3]
	z = l[len(l) - 4]
	print(x, y, z)


loop = int(input())
e = [0, 1]
sums = 0
i = 2
while sums < loop:
	sums = e[i - 1] + e[i - 2]
	e.append(sums)
	i += 1
n = 0
m = 0
o = 0
for i in range(len(e) - 2):
	for j in range(i, len(e) - 1):
		for k in range(j, len(e)):
			if e[i] + e[j] + e[k] == loop:
				n = e[i]
				m = e[j]
				o = e[k]
print(str(n) + ' ' + str(m) + ' ' + str(o))


T_ON = 0
DEBUG_ON = 1
MOD = 998244353

def solve():
	n = read_int()
	if n == 0:
		print(0, 0, 0)
		return
	if n == 1:
		print(1, 0, 0)
		return
	(a, b) = (0, 1)
	while b < n:
		(a, b) = (b, a + b)
	assert b == n
	print(a, b - a, 0)

def main():
	T = read_int() if T_ON else 1
	for i in range(T):
		solve()

def debug(*xargs):
	if DEBUG_ON:
		print(*xargs)
from collections import *
import math
import os
import sys
from io import BytesIO, IOBase
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 read_int():
	return int(input())

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

def print_nums(nums):
	print(' '.join(map(str, nums)))

def YES():
	print('YES')

def Yes():
	print('Yes')

def NO():
	print('NO')

def No():
	print('No')

def First():
	print('First')

def Second():
	print('Second')

def fib(n):
	(a, b) = (0, 1)
	for _ in range(n):
		(a, b) = (b, a + b)
	return a

def fib_ns(n):
	assert n >= 1
	f = [0 for _ in range(n + 1)]
	f[0] = 0
	f[1] = 1
	for i in range(2, n + 1):
		f[i] = f[i - 1] + f[i - 2]
	return f

def fib_to_n(n):
	f = []
	(a, b) = (0, 1)
	while a <= n:
		f.append(a)
		(a, b) = (b, a + b)
	return f

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

def xgcd(a, b):
	(x0, x1, y0, y1) = (0, 1, 1, 0)
	while a != 0:
		((q, a), b) = (divmod(b, a), a)
		(y0, y1) = (y1, y0 - q * y1)
		(x0, x1) = (x1, x0 - q * x1)
	return (b, x0, y0)

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

def is_even(x):
	return x % 2 == 0

def is_odd(x):
	return x % 2 == 1

def modinv(a, m):
	(g, x, _) = xgcd(a, m)
	if g != 1:
		raise Exception('gcd(a, m) != 1')
	return x % m

def mod_add(x, y):
	x += y
	while x >= MOD:
		x -= MOD
	while x < 0:
		x += MOD
	return x

def mod_mul(x, y):
	return x * y % MOD

def mod_pow(x, y):
	if y == 0:
		return 1
	if y % 2:
		return mod_mul(x, mod_pow(x, y - 1))
	p = mod_pow(x, y // 2)
	return mod_mul(p, p)

def mod_inv(y):
	return mod_pow(y, MOD - 2)

def mod_div(x, y):
	return mod_mul(x, mod_inv(y))

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

def gen_primes(n):
	P = [True for _ in range(n + 1)]
	P[0] = P[1] = False
	for i in range(int(n ** 0.5) + 1):
		if P[i]:
			for j in range(2 * i, n + 1, i):
				P[j] = False
	return P

def is_lucky(n):
	return set(list(str(n))).issubset({'4', '7'})
main()


n = int(input())
i = 0
k = 1
if n == 0:
	exit(print(0, 0, 0))
while 1:
	p = i + k
	if p == n:
		exit(print(0, 0, p))
	elif p > n:
		exit(print(0, k, n - k))
	i = k
	k = p


def hexadecimalTheorem():
	n = int(input())
	if n == 0:
		print(0, 0, 0)
	if n == 1:
		print(0, 0, 1)
	if n > 1:
		f = 0
		s = 1
		while True:
			t = f + s
			if t == n:
				print(0, f, s)
				return
			f = s
			s = t
hexadecimalTheorem()


arr = [0, 1]
n = int(input())
ans = ()
if n == 0:
	ans = (0, 0, 0)
elif n == 1:
	ans = (0, 0, 1)
else:
	while True:
		l = len(arr)
		ne = arr[l - 1] + arr[l - 2]
		if ne == n:
			ans = (0, arr[l - 2], arr[l - 1])
			break
		else:
			arr.append(ne)
print(ans[0], ans[1], ans[2])


import sys
n = int(input())
if n == 1:
	print(1, 0, 0)
	exit(0)
elif n == 0:
	print(0, 0, 0)
	exit(0)
p = 0
pp = 1
i = 1
while i < n:
	t = i
	p = pp
	pp = t
	i = pp + p
print(p, pp, 0)


i = input()
print('0 0', i)


n = int(input())
entry = [0, 1]
if n == 0:
	print(str(0) + ' ' + str(0) + ' ' + str(0))
elif n == 1:
	print(str(0) + ' ' + str(0) + ' ' + str(1))
elif n == 2:
	print(str(0) + ' ' + str(1) + ' ' + str(1))
elif n == 3:
	print(str(1) + ' ' + str(1) + ' ' + str(1))
else:
	a = 0
	b = 1
	c = 1
	while c <= n:
		entry.append(c)
		a = b
		b = c
		c = a + b
	print(str(entry[-2]) + ' ' + str(entry[-4]) + ' ' + str(entry[-5]))


n = int(input())
s = 1
t = 1

def Fibonacci(n, x):
	if x == 1:
		return n
	s = 1
	t = 0
	while True:
		if s >= n:
			return (t, Fibonacci(n - t, x - 1))
		k = s + t
		t = s
		s = k
l = Fibonacci(n, 3)
print(l[0], l[1][0], l[1][1])


from math import sqrt
memo = {}
fibs = {}

def generate_fib(m):
	fibs[0] = 0
	fibs[1] = 1
	i = 2
	while fibs[i - 1] < m:
		fibs[i] = fibs[i - 1] + fibs[i - 2]
		i += 1

def calc(n, count, nums):
	if count == 0:
		return nums
	for i in range(len(fibs)):
		if fibs[i] > n:
			break
		guess = calc(n - fibs[i], count - 1, [])
		if sum(guess) + fibs[i] == n:
			return guess + nums + [fibs[i]]
	return nums
n = int(input())
generate_fib(n)
r = calc(n, 3, [])
if not r:
	print("I'm too stupid to solve this problem")
else:
	print(' '.join([str(x) for x in r]))


n = int(input())
l = [0, 1]
i = 1
while i <= n:
	l.append(i)
	i = i + l[-2]
if n == 0:
	print('0 0 0')
elif n == 1:
	print('1', '0', '0')
elif n == 2:
	print('1', '1', '0')
elif n == 3:
	print('1', '1', '1')
else:
	print(l[-2], l[-4], l[-5])


n = int(input())
arr = [0, 1]
can = False
while arr[len(arr) - 1] < n:
	arr.append(arr[-1] + arr[-2])
arr.pop(len(arr) - 1)
if n > 3:
	print(arr[len(arr) - 1], arr[len(arr) - 3], arr[len(arr) - 4])
elif n == 3:
	print('1 1 1')
elif n == 2:
	print('0 1 1')
elif n == 1:
	print('0 0 1')
else:
	print('0 0 0')


n = int(input())
fib = [0, 1]
t1 = 0
if n == 0:
	fib = [0] + fib
while t1 != n:
	t1 = fib[-1] + fib[-2]
	fib.append(t1)
print(0, fib[-3], fib[-2])


numb = int(input())
print(0, 0, numb)


n = int(input())
a = 0
b = 1
c = 1
s = 2
while s < n:
	a = b
	b = c
	c = s
	s = c + b
if s == n:
	print(a, b, b)
elif n == 0:
	print('0 0 0')
elif n == 1:
	print('0 0 1')
else:
	print("I'm too stupid to solve this problem")


import sys
from os import path
if path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
n = int(input())
print('0 0', n)


def Sol(n):
	if n == 0:
		print('0 0 0')
		return
	fib = [0, 1]
	while n >= fib[-1]:
		fib.append(fib[-1] + fib[-2])
	fib = fib[:len(fib) - 1]
	ans = []
	ans.append(fib[-1])
	n -= fib[-1]
	for i in range(len(fib) - 1):
		s = n - fib[i]
		if s in fib:
			ans.append(fib[i])
			ans.append(s)
			break
	for i in ans:
		print(i, end=' ')
	print()
	return
Sol(int(input()))


import sys, os, io, time, copy
if os.path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
import math

def main():
	n = int(input())
	print(0, 0, n)
main()


class Code:

	def __init__(self):
		self.n = int(input())
		self.dp = []

	def fib(self):
		self.dp.extend([0, 1, 1])
		while self.dp[-1] <= self.n:
			self.dp.append(self.dp[-1] + self.dp[-2])

	def process(self):
		self.fib()
		flag = 0
		for i in range(0, len(self.dp)):
			for j in range(0, len(self.dp)):
				for k in range(0, len(self.dp)):
					if self.dp[i] + self.dp[j] + self.dp[k] == self.n:
						flag = 1
						print(self.dp[i], self.dp[j], self.dp[k])
						return
					elif self.dp[i] + self.dp[j] + self.dp[k] > self.n:
						break
				if self.dp[i] + self.dp[j] > self.n:
					break
		if flag == 0:
			print("I'm too stupid to solve this problem")
code = Code()
code.process()


from bisect import bisect_left
from sys import exit
MAX = 1000000000.0 + 1

def gen():
	res = [0, 1]
	while res[-1] < MAX:
		res.append(res[-1] + res[-2])
	return res
F = gen()

def solve(x, l):
	if x == 0:
		return [0] * l
	if l == 1:
		return [x]
	i = bisect_left(F, x)
	res = [F[i - 1]] + solve(x - F[i - 1], l - 1)
	assert len(res) <= 3
	return res
n = int(input())
print(*solve(n, 3))


n = int(input())
fibonacci_list = [0, 1]
i = 2
while i != n + 2:
	k = fibonacci_list[i - 1] + fibonacci_list[i - 2]
	if k > n:
		break
	else:
		fibonacci_list.append(k)
	i += 1
f = fibonacci_list.index(n)
b = fibonacci_list[f - 2]
c = fibonacci_list[f - 1]
a = 0
if n == 0:
	print(0, 0, 0)
elif n > 3:
	f = fibonacci_list.index(b)
	a = fibonacci_list[f - 2]
	b = fibonacci_list[f - 1]
	print(a, b, c)
else:
	f = fibonacci_list.index(b)
	a = fibonacci_list[f - 1]
	b = fibonacci_list[f]
	print(a, b, c)


a = int(input())
print(0, 0, a)


import math

def checkPerfectSquare(n):
	sqrt = int(math.sqrt(n))
	if pow(sqrt, 2) == n:
		return True
	else:
		return False

def isFibonacciNumber(n):
	res1 = 5 * n * n + 4
	res2 = 5 * n * n - 4
	if checkPerfectSquare(res1) or checkPerfectSquare(res2):
		return True
	else:
		return False
num = int(input())
if isFibonacciNumber(num):
	M = [0, 0, num]
	print(*M)
else:
	(n1, n2) = (0, 1)
	count = 0
	L = []
	if nterms == 0:
		L.append(n1)
	else:
		while count < nterms + 1:
			L.append(n1)
			nth = n1 + n2
			n1 = n2
			n2 = nth
			count += 1
	print(L)

	def func(L):
		for i in L:
			for j in L:
				for k in L:
					if i + j + k == nterms:
						return [i, j, k]
	n = func(L)
	if n:
		print(*n)
	else:
		print("I'm too stupid to solve this problem")


n = int(input())
if n == 1:
	print('0 1 0')
elif n == 0:
	print('0 0 0')
else:
	print('0 0', n)


n = int(input())
if n == 0:
	print(0, 0, 0)
elif n == 1:
	print(0, 0, 1)
elif n == 2:
	print(0, 1, 1)
else:
	arr = [0, 1, 1, 2]
	while arr[-1] != n:
		arr.append(arr[-1] + arr[-2])
		if len(arr) > 5:
			arr.pop(0)
	print(arr[-2], arr[-4], arr[-5])


N = int(input())
print(f'0 0 {N}')


n = int(input())
if n == 0:
	print(0, 0, 0)
elif n == 1:
	print(0, 0, 1)
elif n == 2:
	print(0, 1, 1)
else:
	fibs = [0, 1]
	while fibs[-1] != n:
		fibs.append(fibs[-1] + fibs[-2])
	ind = fibs.index(n)
	print(fibs[ind - 1], fibs[ind - 3], fibs[ind - 4])


from sys import *
from collections import defaultdict as dd
from math import *
from bisect import *

def sinp():
	return input()

def inp():
	return int(sinp())

def minp():
	return map(int, sinp().split())

def linp():
	return list(minp())

def strl():
	return list(sinp())

def pr(x):
	print(x)
mod = int(1000000000.0 + 7)

def fibonacci(n):
	arr = [0] * (n + 1)
	arr[1] = 1
	for i in range(2, n + 1):
		arr[i] = arr[i - 1] + arr[i - 2]
	return arr
arr = fibonacci(50)
idx = bisect_left(arr, inp())
if idx == 0:
	print(arr[0], arr[0], arr[0])
elif idx == 1 or idx == 2:
	print(arr[0], arr[0], arr[1])
elif idx == 3:
	print(arr[0], arr[1], arr[2])
else:
	print(arr[idx - 4], arr[idx - 3], arr[idx - 1])


import sys
n = int(sys.stdin.readline())
fibs = [0]
(fib_0, fib_1) = (0, 1)
while fib_1 <= n:
	fibs.append(fib_1)
	(fib_0, fib_1) = (fib_1, fib_0 + fib_1)

def check(n):
	for i in range(len(fibs)):
		for j in range(i, len(fibs)):
			for k in range(j, len(fibs)):
				(a, b, c) = (fibs[i], fibs[j], fibs[k])
				if a + b + c == n:
					return f'{a} {b} {c}'
	return None
answer = check(n)
if answer:
	sys.stdout.write(answer)
else:
	sys.stdout.write("I'm too stupid to solve this problem")


first = 0
second = 1
fibo = [first, second]
n = eval(input())
if n == 3:
	print('1 1 1')
elif n == 2:
	print('0 1 1')
elif n == 1:
	print('0 0 1')
elif n == 0:
	print('0 0 0')
else:
	while second < n:
		temp = first + second
		fibo.append(temp)
		first = second
		second = temp
	print(fibo[-5], ' ', fibo[-4], ' ', fibo[-2])


n = int(input())
a = []
a.append(0)
a.append(1)
a.append(1)
a.append(2)
if n == 0:
	print(*[0, 0, 0])
elif n == 1:
	print(*[0, 0, 1])
elif n == 2:
	print(*[0, 1, 1])
else:
	for i in range(4, n + 2):
		a.append(a[i - 1] + a[i - 2])
		if a[i] == n:
			print(*[a[i - 4], a[i - 3], a[i - 1]])
			break


arr = [0, 1]
counter = 2
for i in range(1000000000):
	arr.append(arr[counter - 1] + arr[counter - 2])
	if arr[counter] > 1000000000:
		break
	counter += 1
n = int(input())
if n == 0:
	print('0 0 0')
elif n == 1:
	print('1 0 0')
elif n == 2:
	print('1 1 0')
else:
	cord = arr.index(n)
	print(f'{arr[cord - 1]} {arr[cord - 3]} {arr[cord - 4]}')


n = int(input())
l = [0, 1]
k = 0
while k != n:
	k = l[len(l) - 1] + l[len(l) - 2]
	l.append(k)
l.pop()
for i in l:
	for j in l:
		for k in l:
			if i + j + k == n:
				print(i, j, k)
				exit()


from math import floor

def f(n):
	(a, b) = (0, 1)
	for i in range(0, n):
		(a, b) = (b, a + b)
	return (a, b)

def count(n):
	for i in range(32):
		if n == 0:
			break
		n >>= 1
	return i

def f_1(n):
	d = count(n)
	if d > 1:
		if n & 1 << d - 2:
			tmp = d * 1.44042009041 - 1.3
		else:
			tmp = d * 1.44042009041 - 1.9
		(a, b) = f(floor(tmp))
		print(a, b, b)
	else:
		print(0, 0, n)
f_1(int(input()))


from math import *

def previousFibonacci(n):
	a = n / ((1 + sqrt(5)) / 2.0)
	return round(a)
n = int(input())
if n == 0:
	print(0, 0, 0)
if n == 1:
	print(1, 0, 0)
if n > 1:
	x = previousFibonacci(n)
	p = previousFibonacci(x)
	print(p, x, 0)


n = int(input())
a = [1, 1]
while a[len(a) - 1] < n:
	a.append(a[len(a) - 1] + a[len(a) - 2])
if n < 3:
	print(n, 0, 0)
elif n == 3:
	print(1, 1, 1)
else:
	b = len(a)
	print(a[b - 2], a[b - 4], a[b - 5])


R = lambda : map(int, input().split())
print(input(), 0, 0)


n = int(input())
if n == 0:
	print(0, 0, 0)
elif n == 1:
	print(0, 0, 1)
else:
	a = 0
	b = 1
	while b < n:
		c = a + b
		a = b
		b = c
	if b != n:
		print("I'm too stupid to solve this problem")
	else:
		d = b - a
		e = a - d
		f = d - e
		print(f, e, a)


n = int(input())
fib = []

def fibarray(n):
	a = int(0)
	b = int(1)
	while a < n or b < n:
		if a < n:
			fib.append(a)
			a += b
		if b < n:
			fib.append(b)
		b += a
	return fib
fibarray(n)
if n >= 3:
	print(fib[-1], fib[-3], fib[-4])
if n < 3:
	if n == 0:
		print(0, 0, 0)
	elif n == 1:
		print(1, 0, 0)
	elif n == 0:
		print(0, 0, 0)
	elif n == 2:
		print(1, 1, 0)


n = int(input())
fib_arr = [0, 1]
fib = 1
fib_dict = {0: (0, 0)}
while fib <= n:
	fib = fib_arr[-1] + fib_arr[-2]
	if fib > n:
		break
	fib_dict[fib] = (fib_arr[-1], fib_arr[-2])
	fib_arr.append(fib_arr[-1] + fib_arr[-2])
found = False
for fib in fib_arr[::-1]:
	if n - fib in fib_dict:
		print(*fib_dict[fib], n - fib)
		found = True
		break
if not found:
	print("I'm too stupid to solve this problem")


def func(n):
	if n == 0:
		print(0, 0, 0)
		return
	elif n == 1:
		print(1, 0, 0)
		return
	elif n == 2:
		print(1, 1, 0)
		return
	x = [0, 1, 1, 2]
	a = 0
	i = 4
	while a < n:
		a = x[i - 1] + x[i - 3] + x[i - 4]
		x.append(a)
		i += 1
	i -= 1
	if x[i] == n:
		print(x[i - 1], x[i - 3], x[i - 4])
		return
	else:
		print("I'm too stupid to solve this problem")
		return
n = int(input())
func(n)


print(str(0) + ' ' + str(0) + ' ' + str(int(input())))


b = [1]

def fib(b):
	if n == 0:
		mm = [0, 0, 0]
		return ' '.join(map(str, mm))
	if n == 1:
		mm = [1, 0, 0]
		return ' '.join(map(str, mm))
	a = 1
	i = 0
	while a < n + 1:
		b.append(a)
		a = a + b[i]
		i = i + 1
	dd = [0]
	dd.append(b[len(b) - 3])
	dd.append(b[len(b) - 2])
	return ' '.join(map(str, dd))
n = int(input())
ans = fib(b)
print(ans)


n = int(input())
l = [0, 1]
while l[-1] < n:
	l.append(l[-1] + l[-2])
anz = [-1]
for i in l:
	for j in l:
		for k in l:
			if i + j + k == n:
				anz = [i, j, k]
if len(anz) == 1:
	print("I'm too stupid to solve this problem")
else:
	print(*anz)


from sys import stdin, stdout
stdout.write('0 0 ' + stdin.readline().strip())


n = int(input())
(x, y) = (0, 1)
while x + y < n:
	(x, y) = (y, x + y)
print(0, x, min(n, y))


n = int(input())

def fib(n):
	l1 = [0, 1, 1]
	h = 1
	while h <= n:
		h = l1[-1] + l1[-2]
		l1.append(h)
	return l1
l = fib(n)

def f(n):
	for i in l:
		for j in l:
			for k in l:
				if i + j + k == n:
					return [i, j, k]
print(*f(n))


n = int(input())
print(n, n - n, n - n)


n = int(input())

def fib_to(k):
	fibs = [0, 1]
	for i in range(2, k + 1):
		fibs.append(fibs[-1] + fibs[-2])
	return fibs
a = fib_to(50)
z = a.index(n)
if n > 1:
	print('0' + ' ' + str(a[z - 2]) + ' ' + str(a[z - 1]))
elif n == 0:
	print('0 0 0')
elif n == 1:
	print('1 0 0')


num = int(input())
stop = "I'm too stupid to solve this problem"

def fib():
	(a, b) = (0, 1)
	while True:
		yield a
		(a, b) = (b, a + b)
fibos = []
for (i, fibonacci_number) in zip(range(47), fib()):
	fibos.append(fibonacci_number)
temp = {3: '1 1 1', 0: '0 0 0', 1: '1 0 0', 2: '1 1 0'}
if num <= 3:
	print(temp[num])
	quit()
try:
	start = fibos.index(num) - 2
	print(fibos[start], fibos[start], fibos[start - 1])
except:
	print(stop)


import sys
n = int(input())
if n < 4:
	print('0 0 ' + str(n))
	sys.exit()
mem = [1, 1, 2, 3]
while mem[-1] < n:
	mem = mem[1:]
	mem.append(mem[-1] + mem[-2])
print(mem[0], mem[1], mem[1])


import sys
input = lambda : sys.stdin.readline()
int_arr = lambda : list(map(int, input().split()))
str_arr = lambda : list(map(str, input().split()))
get_str = lambda : map(str, input().split())
get_int = lambda : map(int, input().split())
get_flo = lambda : map(float, input().split())
mod = 1000000007

def solve():
	pass
n = int(input())
print('0 ' + '0 ' + str(n))


from sys import stdin, stdout
n = int(input())
(a, b, c) = (0, 1, 1)
d = [0, 1]
while c < n:
	c = a + b
	d.append(c)
	a = b
	b = c
for i in d:
	x = i
	f = 0
	for j in d:
		y = j
		for z in d:
			if x + y + z == n:
				f = 1
				break
		if f == 1:
			break
	if f == 1:
		break
if f == 1:
	print(x, y, z)
else:
	print("I'm too stupid to solve this problem")


import functools
n: int = int(input())
print('0 0 ' + str(n))


t = int(input())
c = 0
d = 1
a = [0, 1]
while d < t:
	sum = c + d
	a.append(sum)
	c = d
	d = sum
x = 0
w = 1
j = 0
k = 0
l = 0
if t == 0:
	print('0 0 0')
	w = 0
elif t == 1:
	print('0 0 1')
	w = 0
elif t == 2:
	print('0 1 1')
	w = 0
else:
	while x + 2 < a.index(t) - 1:
		if a[len(a) - 2] + a[len(a) - 4] + a[len(a) - 5] == t:
			print(f'{a[len(a) - 5]} {a[len(a) - 4]} {a[len(a) - 2]}')
			w = 0
			break
		else:
			x += 1
if w == 1:
	print("I'm too stupid to solve this problem")


n = int(input())

def fn(n):
	if n == 0:
		print('0 0 0')
		return
	if n == 1:
		print('1 0 0')
		return
	(f1, f2) = (0, 1)
	f = 0
	while f < n:
		f = f1 + f2
		f1 = f2
		f2 = f
	print(f1, f - f1, 0)
fn(n)


n = int(input())
if n == 0:
	print(0, 0, 0)
else:
	(x, y) = (0, 1)
	while x + y != n:
		(x, y) = (y, x + y)
	print(0, x, y)


k = [0, 0]
k.append(int(input()))
print(*k)


n = int(input())
a = [0, 1]
i = 2
while 1:
	k = a[i - 1] + a[i - 2]
	a.append(k)
	if k >= n:
		break
	i += 1
if i >= 3:
	print(str(a[i - 2]) + ' ' + str(a[i - 2]) + ' ' + str(a[i - 3]))
if n == 1:
	print('0 0 1')
if n == 0:
	print('0 0 0')


n = int(input())
fib = [0, 1]
while fib[-1] < n:
	fib.append(fib[-1] + fib[-2])
if fib[-1] > n:
	tar = fib[-2]
	left = n - tar
else:
	tar = fib[-1]
	left = n - tar
dup = list(set(fib))
i = 0
a = ''
b = ''
while dup[i] <= left:
	if left - dup[i] in dup:
		a = dup[i]
		b = left - dup[i]
		break
	else:
		i += 1
if a == '':
	print("I'm too stupid to solve this problem")
else:
	print(tar, a, b)


p = [0, 1]
a = int(input())
if a == 0:
	print(0, 0, 0)
else:
	for i in range(1, 100000000):
		d = p[-1] + p[-2]
		p.append(d)
		if a == d:
			print(0, p[-2], p[-3])
			break


print(' '.join([str(x) for x in [0, 0, int(input())]]))


n = int(input())
ans = [0, 1, 1, 2]
if n == 0:
	print('0 0 0')
elif n == 1:
	print('0 0 1')
elif n == 2:
	print('0 1 1')
else:
	while ans[-1] + ans[-2] != n:
		ans.append(ans[-1] + ans[-2])
	print('{} {} {}'.format(ans[-4], ans[-3], ans[-1]))


def main(N):
	print(0, 0, N)

def text():
	with open('input.txt', 'r') as f:
		t = int(f.readline().rstrip())
		while t:
			N = int(f.readline().rstrip())
			arr = list(map(int, f.readline().rstrip().split()))
			main(N, arr)
			t -= 1

def normal():
	N = int(input())
	main(N)
normal()


n = int(input())
memo = {}

def fibonacci(n):
	if n < 2:
		memo[n] = n
		return n
	if n in memo:
		return memo[n]
	memo[n] = fibonacci(n - 1) + fibonacci(n - 2)
	return fibonacci(n - 1) + fibonacci(n - 2)
valid = True
if n == 2:
	res = [0, 1, 1]
elif n == 1:
	res = [0, 0, 1]
elif n == 0:
	res = [0, 0, 0]
else:
	i = 4
	found = False
	while not found:
		p_ans = fibonacci(i - 4) + fibonacci(i - 3) + fibonacci(i - 1)
		if p_ans == n:
			res = [fibonacci(i - 4), fibonacci(i - 3), fibonacci(i - 1)]
			found = True
		else:
			i += 1
if valid:
	print(' '.join(list(map(str, res))))
else:
	print("I'm too stupid to solve this problem")


n = int(input())
fib = [0, 1]
while fib[-1] + fib[-2] <= n:
	fib.append(fib[-1] + fib[-2])

def solve():
	for i in fib:
		for j in fib:
			for k in fib:
				if i + j + k == n:
					return (i, j, k)
				if i + j + k > n:
					break
			if i + j + k > n:
				break
		if i + j + k > n:
			break
print(*solve())


f = eval(input())
l = [0, 1]
while l[-1] < f:
	l.append(l[-1] + l[-2])
flag = 0
for i in l:
	if f - i in l:
		for j in l:
			if f - i - j in l:
				print(i, j, f - i - j)
				flag = 1
				break
	if flag:
		break
else:
	print("Sorry, I'm too stupid to solve this problem.")


import sys

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

def iinput():
	return int(input())

def rinput():
	return map(int, sys.stdin.readline().strip().split())

def get_list():
	return list(map(int, sys.stdin.readline().strip().split()))
n = iinput()
if n == 0:
	print(0, 0, 0)
elif n == 1:
	print(0, 0, 1)
elif n == 2:
	print(0, 1, 1)
elif n == 3:
	print(0, 1, 2)
else:
	f = 0
	s = 1
	while f + s != n:
		(f, s) = (s, f + s)
	print(0, f, s)


n = int(input())
if n == 0:
	print(0, 0, 0)
	exit(0)
else:
	print(0, 0, n)


n = int(input())
f = []
(a, b) = (0, 1)
while a <= n:
	f.append(a)
	(a, b) = (b, a + b)
for i in f:
	for j in f:
		for k in f:
			if i + j + k == n:
				print(i, j, k)
				exit()
print("I'm too stupid to solve this problem")


panda = int(input())
a = 1
b = 0
c = 0
d = 0
m = 0
n = 1
p = 0
if panda == 2:
	print('0 1 1')
elif panda == 0:
	print('0 0 0')
else:
	while p < panda:
		if p >= a:
			d = c
			c = b
			b = a
			a = p
		p = m + n
		m = n
		n = p
	print(d, c, a)


n = int(input())
hashmap = [0, 1]
for i in range(2, 48):
	hashmap.append(hashmap[i - 1] + hashmap[i - 2])
inde = hashmap.index(n)
if inde > 3:
	print(hashmap[inde - 1], hashmap[inde - 3], hashmap[inde - 4])
elif inde == 3:
	print(0, 1, 1)
elif inde == 2:
	print(0, 0, 1)
elif inde == 1:
	print(0, 0, 1)
else:
	print(0, 0, 0)


def fibonacci():
	fib = [1, 1]
	a = b = 1
	c = a + b
	fib.append(c)
	while c < 10 ** 9:
		a = b
		b = c
		c = a + b
		fib.append(c)
	return fib
listOfFib = fibonacci()
n = int(input())
if n == 0:
	print(0, 0, 0)
elif n == 1:
	print(0, 0, 1)
elif n == 2:
	print(1, 1, 0)
elif n == 3:
	print(1, 1, 1)
else:
	i = listOfFib.index(n)
	print(listOfFib[i - 1], listOfFib[i - 3], listOfFib[i - 4])


n = int(input())
fib = [0, 1]
i = 2
while True:
	fib.append(fib[i - 1] + fib[i - 2])
	if fib[i] >= n:
		break
	i += 1
for i in range(0, len(fib)):
	if fib[i] == n:
		if i >= 4:
			a = fib[i - 1]
			b = fib[i - 3]
			c = fib[i - 4]
			print(c, end=' ')
			print(b, end=' ')
			print(a)
			break
		elif n == 0:
			print('0 0 0')
			break
		elif n == 1:
			print('0 0 1')
			break
		elif n == 2:
			print('0 1 1')
			break
		else:
			print("I'm too stupid to solve this problem")
			break


a = input()
print(0, 0, a)


list = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025, 121393, 196418, 317811, 514229, 832040, 1346269, 2178309, 3524578, 5702887, 9227465, 14930352, 24157817, 39088169, 63245986, 102334155, 165580141, 267914296, 433494437, 701408733, 1134903170, 1836311903, 2971215073, 4807526976, 7778742049]
k = int(input())
if k == 0:
	print(0, 0, 0)
elif k == 1:
	print(0, 0, 1)
else:
	print(0, list[list.index(k) - 2], list[list.index(k) - 1])


def fibonacci(n):
	if n == 0:
		return '0 0 0'
	if n == 1:
		return '0 0 1'
	if n == 2:
		return '0 1 1'
	tab = [1, 1]
	while tab[-1] != n:
		tab.append(tab[-1] + tab[-2])
	res = [str(tab[-3]), str(tab[-3]), str(tab[-4])]
	ans = ' '.join(res)
	return ans
n = int(input())
print(fibonacci(n))


n = int(input())

def fabonacci(n):
	a = [0, 1]
	m = 1
	i = 1
	while m <= n:
		m = a[i] + a[i - 1]
		if m <= n:
			a.append(m)
		i += 1
	return a
b = fabonacci(n)
if n == 0:
	print(0, 0, 0)
elif n == 1:
	print(1, 0, 0)
else:
	print(0, b[-3], b[-2])


n = int(input())
if n:
	fi = [0, 1, 1]
	while fi[-1] <= n:
		fi.append(fi[-1] + fi[-2])
	print(fi[-2], end=' ')
	n -= fi[-2]
	i = 0
	while fi[i] <= n:
		i += 1
	n -= fi[i - 1]
	print(fi[i - 1], end=' ')
	i = 0
	while fi[i] <= n:
		i += 1
	print(fi[i - 1], end=' ')
else:
	print('0 0 0')


n = int(input())
a = [0, 1]
i = 0
if n == 0:
	print(0, 0, 0)
else:
	while a[-1] != n:
		a.append(a[i] + a[i + 1])
		i += 1
	print(0, a[len(a) - 3], a[len(a) - 2])


N = int(input())
A = []
a = 0
b = 1
ans = 0
A.append(0)
A.append(1)
while ans < N:
	ans = a + b
	A.append(ans)
	(a, b) = (b, ans)
flag = 0
A.pop()
L = len(A)
res = []
for i in range(L):
	if A[i] == N:
		res.append(A[i])
		res.append(A[i])
		res.append(A[i])
		flag = 1
		break
	for j in range(L):
		if A[i] + A[j] == N:
			res.append(A[i])
			res.append(A[j])
			res.append(0)
			flag = 1
			break
		for k in range(L):
			if A[i] + A[j] + A[k] == N:
				res.append(A[i])
				res.append(A[j])
				res.append(A[k])
				flag = 1
				break
if flag == 0:
	print('Nah I am too stupid to solve this')
else:
	print(res[0], res[1], res[2])


n = int(input())
f = [0, 1]
i = -1
for k in range(2, 90):
	f.append(f[k - 2] + f[k - 1])
	if f[k] == n:
		i = k
		break
a = f
if n >= 1:
	if n in a and i >= 4:
		print(str(a[i - 4]) + ' ' + str(a[i - 3]) + ' ' + str(a[i - 1]))
	elif n == 2:
		print('0 1 1')
	elif n == 1:
		print('0 0 1')
	else:
		print("I'm too stupid to solve this problem")
elif n == 0:
	print('0 0 0')


l = [0, 1, 1]
n = int(input())
a = 1
b = 1
c = 0
while c <= n:
	c = a + b
	a = b
	b = c
	l.append(c)
if n == 3:
	print(1, 1, 1)
elif n == 2:
	print(0, 1, 1)
elif n == 1:
	print(0, 0, 1)
elif n == 0:
	print(0, 0, 0)
else:
	print(l[len(l) - 6], l[len(l) - 5], l[len(l) - 3])


def fibonnaci_generator(size):
	if size == 0 or size == 1:
		fibo = 'ERROR WRONG INPUT'
	elif size == 2:
		fibo = [1, 1]
	else:
		fibo = [0, 1, 1]
		for i in range(1, size - 2):
			fibo.append(fibo[i] + fibo[i + 1])
	return fibo
n = int(input())
fib = fibonnaci_generator(46)
if n == 0:
	print(0, 0, 0)
elif n == 1:
	print(0, 0, 1)
elif n == 2:
	print(0, 1, 1)
elif n == 3:
	print(1, 1, 1)
else:
	i = fib.index(n)
	print(fib[i - 4], fib[i - 3], fib[i - 1])


def fib(n):
	a = []
	a.append(0)
	a.append(1)
	i = 0
	while a[i] + a[i + 1] < n:
		a.append(a[i] + a[i + 1])
		i += 1
	return a
n = int(input())

def check(n):
	a = fib(n)
	for i in range(len(a)):
		for j in range(len(a)):
			for k in range(len(a)):
				if a[i] + a[j] + a[k] == n:
					print(a[i], end=' ')
					print(a[j], end=' ')
					print(a[k])
					return 1
d = 0
d = check(n)
if d == 0:
	print("I'm too stupid to solve this problem")


a = input()
ans = '0 0 ' + a
print(ans)


from sys import stdin, setrecursionlimit, stdout
from collections import deque
from math import sqrt, floor, ceil, log, log2, log10, pi, gcd, sin, cos, asin
from heapq import heapify, heappop, heappush, heapreplace, heappushpop

def ii():
	return int(stdin.readline())

def fi():
	return float(stdin.readline())

def mi():
	return map(int, stdin.readline().split())

def fmi():
	return map(float, stdin.readline().split())

def li():
	return list(mi())

def si():
	return stdin.readline().rstrip()

def lsi():
	return list(si())
fib = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025, 121393, 196418, 317811, 514229, 832040, 1346269, 2178309, 3524578, 5702887, 9227465, 14930352, 24157817, 39088169, 63245986, 102334155, 165580141, 267914296, 433494437, 701408733, 1134903170]
test_case = 1
while test_case:
	test_case -= 1
	n = ii()
	if not n:
		ans = [0, 0, 0]
	elif n == 1:
		ans = [0, 0, 1]
	else:
		x = fib.index(n)
		ans = [0, fib[x - 2], fib[x - 1]]
	print(*ans)


n = int(input())
l = [0, 1]
a = 0
while a < n:
	i = len(l) - 1
	a = l[i] + l[i - 1]
	l.append(a)
if n == 0:
	print('0 0 0')
elif n == 1:
	print('1 0 0')
elif n == 2:
	print('1 1 0')
else:
	m = l.index(n)
	print(l[m - 1], end=' ')
	print(l[m - 3], end=' ')
	print(l[m - 4])


z = [0, 1]
x = int(input())
a = 1
b = 0
s = 0
while 1:
	s = a + b
	z.append(s)
	b = a
	a = s
	if s >= x:
		break
if x not in z:
	print('I' + chr(39) + 'm too stupid to solve this problem')
else:
	print('{} {} {}'.format(0, 0, x))


n = int(input())
s = 0
lst = [0]
a = 0
b = 1
while s <= n - 1:
	s = a + b
	lst.append(s)
	a = b
	b = s
k = 0
l = len(lst)
for i in range(l):
	y = n - lst[i]
	for j in range(l):
		x = y - lst[j]
		for _ in range(l):
			if x == lst[_]:
				print(lst[i], lst[j], lst[_])
				k = 1
				break
		if k == 1:
			break
	if k == 1:
		break
if k == 0:
	print("I'm too stupid to solve this problem")


numerin = input()
fibonacci = int(numerin)
print('0 0 ' + numerin)


n = 50
f = [0, 1, 1]
for i in range(len(f), n):
	f.append(f[i - 2] + f[i - 1])
k = int(input())
print('0 0 {}'.format(k))


import math
from bisect import bisect_left, bisect, bisect_right
from itertools import accumulate

def index(a, x):
	i = bisect_left(a, x)
	if i != len(a) and a[i] == x:
		return i
	raise ValueError

def find_lt(a, x):
	i = bisect_left(a, x)
	if i:
		return a[i - 1]
	raise ValueError

def find_le(a, x):
	i = bisect_right(a, x)
	if i:
		return a[i - 1]
	raise ValueError

def find_gt(a, x):
	i = bisect_right(a, x)
	if i != len(a):
		return a[i]
	raise ValueError

def find_ge(a, x):
	i = bisect_left(a, x)
	if i != len(a):
		return a[i]
	raise ValueError
st = ''

def func(n):
	if n == 1:
		print(0, 0, 1)
		return 0
	elif n == 0:
		print(0, 0, 0)
		return 0
	fibb = [0, 1, 1, 2]
	while fibb[-1] < n:
		fibb.append(fibb[-1] + fibb[-2])
	ind = len(fibb) - 1
	if ind > 2:
		print(fibb[ind - 2], fibb[ind - 2], fibb[ind - 3])
n = int(input())
func(n)


def fib(n, a, b):
	temp = b
	while b != n:
		temp = a
		a = b
		b = b + temp
	m = a - temp
	return (m, temp, temp)
n = int(input())
if n == 0:
	print(0, 0, 0)
elif n == 1:
	print(0, 0, 1)
else:
	(x, y, z) = fib(n, 0, 1)
	print(x, y, z)


n = int(input())
f = [0, 1]
i = 2
if n == 0:
	print('0 0 0')
elif n == 1:
	print('0 0 1')
elif n == 2:
	print('0 1 1')
else:
	while f[-1] != n:
		f.append(f[i - 1] + f[i - 2])
		i += 1
	print(str(f[-5]) + ' ' + str(f[-4]) + ' ' + str(f[-2]))


z = int(input())
all_fib = [0, 1, 1]
while all_fib[-1] < z:
	all_fib.append(all_fib[-2] + all_fib[-1])

def check(num):
	result = [0, 0, 0]
	for i in all_fib:
		for j in all_fib:
			for k in all_fib:
				if i + j + k == z:
					return (i, j, k)
	return result
x = check(z)
if x == [0, 0, 0]:
	print("I'm too stupid to solve this problem")
else:
	print(x[0], x[1], x[2])


n = int(input())
a = 0
b = 1
s = 0
if n == 0:
	b = 0
for i in range(47):
	s = a + b
	if n == s:
		print(0, a, b)
		break
	a = b
	b = s


f = [None] * 1001
f[0] = 0
f[1] = 1
for i in range(2, 1001):
	f[i] = f[i - 1] + f[i - 2]
a = input()
a = int(a)
if a == 1:
	print('0 0 1')
elif a == 0:
	print('0 0 0')
else:
	ans = '0'
	for i in range(1001):
		if f[i] == a:
			break
	ans = ans + ' ' + str(f[i - 1]) + ' ' + str(f[i - 2])
	print(ans)


number = input()
print(number + ' 0 0')


fn = int(input())
s = {0: [0, 0, 0], 1: [0, 0, 1], 2: [0, 1, 1]}
n1 = 1
n2 = 2
i = 0
while n1 + n2 <= fn:
	i = n1 + n2
	s[i] = [0, n1, n2]
	n1 = n2
	n2 = i
print(' '.join((str(x) for x in s[fn])))


p = 1000
fib = [0] * p
fib[1] = 1
for i in range(2, p):
	fib[i] = fib[i - 1] + fib[i - 2]
n = int(input())
if n == 1:
	print('1 0 0')
elif n == 0:
	print('0 0 0')
else:
	ind = fib.index(n)
	print(fib[ind - 1], fib[ind - 2], end=' ')
	print(0)


n = int(input())
a = 0
b = 1
c = 0
p = 0
if n == 0:
	print(0, 0, 0)
else:
	while True:
		c = a + b
		if c == n:
			break
		a = b
		b = c
	print(a, b, p)


def calc(foo):
	if foo == 2:
		print('0 1 1')
		return
	if foo == 3:
		print('1 1 1')
		return
	if foo == 0:
		print('0 0 0')
		return
	if foo == 1:
		print('1 0 0')
		return
	fibo = [0, 1]
	while fibo[-1] < foo and fibo[-1] + fibo[-2] < foo:
		fibo.append(fibo[-1] + fibo[-2])
	verifier = fibo[-1] + fibo[-3] + fibo[-4]
	if verifier != foo:
		print("I'm too stupid to solve this problem")
		return
	print(fibo[-1], fibo[-3], fibo[-4])
	return
num = int(input())
calc(num)


n = int(input())
fibl = [0, 1]

def fib(x):
	if x < len(fibl):
		return fibl[x]
	else:
		temp = fib(x - 1) + fib(x - 2)
		fibl.append(temp)
		return temp
j = 0
while True:
	if fib(j) == n:
		break
	j = j + 1
if n == 1:
	print(0, 0, 1)
elif n == 0:
	print(0, 0, 0)
else:
	print(0, fibl[j - 2], fibl[j - 1])


num = int(input())
stop = "I'm too stupid to solve this problem"
fibos = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025, 121393, 196418, 317811, 514229, 832040, 1346269, 2178309, 3524578, 5702887, 9227465, 14930352, 24157817, 39088169, 63245986, 102334155, 165580141, 267914296, 433494437, 701408733, 1134903170, 1836311903, 2971215073, 4807526976, 7778742049, 12586269025, 20365011074, 32951280099, 53316291173, 86267571272, 139583862445, 225851433717, 365435296162, 591286729879, 956722026041, 1548008755920, 2504730781961, 4052739537881, 6557470319842, 10610209857723, 17167680177565, 27777890035288, 44945570212853, 72723460248141, 117669030460994]
if num == 3:
	print(1, 1, 1)
	quit()
elif num == 0:
	print(0, 0, 0)
	quit()
elif num == 1:
	print(1, 0, 0)
	quit()
elif num == 2:
	print(1, 1, 0)
	quit()
try:
	start = fibos.index(num) - 2
	print(fibos[start], fibos[start], fibos[start - 1])
except:
	print(stop)


def search(n, f, m):
	l = []
	if n == 0:
		for i in range(m):
			l = [0 for i in range(m)]
		return l
	else:
		for i in range(len(f) - 1):
			if f[i] <= n and f[i + 1] > n:
				break
		return [f[i]] + search(n - f[i], f, m - 1)
n = int(input())
if n == 0:
	f = [0]
if n > 0:
	f = [1, 2]
	a = 1
	b = 2
	c = 3
	while c <= n:
		f.append(c)
		a = b
		b = c
		c = a + b
for i in search(n, f, 3):
	print(i, end=' ')
print()


n = int(input())
g = [0, 1]
if n < 2:
	print('0 0', n)
	exit()
while g[-1] != n:
	g.append(g[-1] + g[-2])
else:
	print(g[-3], g[-2], 0)


n = int(input())
if n == 0:
	print('0 0 0')
else:
	(prev, cur) = (0, 1)
	while cur != n:
		(cur, prev) = (cur + prev, cur)
	print(0, cur - prev, prev)


a = [0, 1]
while a[-1] < 10 ** 9:
	a.append(a[-1] + a[-2])
n = int(input())
no = True
for i in a:
	for j in a:
		for k in a:
			if i + j + k == n and no:
				print(i, j, k)
				no = False
if no:
	print("I'm too stupid to solve this problem")


n = int(input())
if n == 0:
	print('0 0 0')
elif n == 1:
	print('0 0 1')
elif n == 2:
	print('0 1 1')
elif n == 3:
	print('1 1 1')
else:
	fib = []
	(a, b, c) = (0, 1, 0)
	for i in range(47):
		c = a + b
		fib.append(b)
		a = b
		b = c
	for j in range(47):
		if fib[j] == n:
			print(fib[j - 4], fib[j - 3], fib[j - 1])


n = int(input())
(f1, f2) = (0, 1)
i = 0
while i < n:
	f1 = f2
	f2 = i
	i = f1 + f2
if n != 0:
	print(0, f1, f2)
else:
	print(0, 0, 0)


def f(num):
	global fib
	for i in fib:
		for j in fib:
			for k in fib:
				if i + j + k == num:
					print(i, j, k)
					return
	print("I'm too stupid to solve this problem")
n = int(input())
fib = [0, 1]
while fib[-1] + fib[-2] < 1000000000.0:
	fib.append(fib[-1] + fib[-2])
f(n)


n = int(input())
fib = [0, 1]
while True:
	if fib[-1] >= n:
		break
	else:
		fib.append(fib[-1] + fib[-2])
l = len(fib)

def solve():
	for a in range(l):
		for b in range(l):
			for c in range(l):
				if fib[a] + fib[b] + fib[c] == n:
					print(fib[a], fib[b], fib[c])
					return
	print("I'm too stupid to solve this problem")
solve()


fib = [0] * 100
fib[1] = 1
for i in range(2, 100):
	fib[i] = fib[i - 1] + fib[i - 2]
n = int(input())
if n in fib:
	if n == 0:
		print(0, 0, 0)
	elif n == 1:
		print(0, 0, 1)
	else:
		print(0, fib[fib.index(n) - 2], fib[fib.index(n) - 1])
else:
	print("I'm too stupid to solve this problem")


import sys

def rs():
	return sys.stdin.readline().rstrip()

def ri():
	return int(sys.stdin.readline())

def ria():
	return list(map(int, sys.stdin.readline().split()))

def ws(s):
	sys.stdout.write(s)
	sys.stdout.write('\n')

def wi(n):
	sys.stdout.write(str(n))
	sys.stdout.write('\n')

def wia(a, sep=' '):
	sys.stdout.write(sep.join([str(x) for x in a]))
	sys.stdout.write('\n')

def main():
	n = ri()
	if n == 0:
		wia([0, 0, 0])
		return
	f = [0, 1]
	while True:
		x = f[-1] + f[-2]
		if x == n:
			break
		f.append(x)
	wia([0, f[-2], f[-1]])
main()


def main():
	n = int(input())
	if n < 4:
		print(*((0, 0, 0), (0, 0, 1), (0, 1, 1), (0, 1, 2))[n])
	else:
		(a, b, c, d, e) = (0, 1, 1, 2, 3)
		while e != n:
			(a, b, c, d, e) = (b, c, d, e, d + e)
		print(a, b, d)
main()


n = int(input())
if n == 0:
	print(0, 0, 0)
elif n == 1:
	print(0, 0, 1)
elif n == 2:
	print(0, 1, 1)
elif n == 3:
	print(1, 1, 1)
else:
	p1 = 0
	p2 = 1
	i = 2
	while True:
		c = p1 + p2
		i += 1
		if c == n:
			break
		p1 = p2
		p2 = c
	print(p2, p2 - p1, p1 - (p2 - p1))


def Sol(n):
	if n == 0:
		print(0, 0, 0)
		return None
	(F0, F1) = (0, 1)
	while F0 + F1 != n:
		res = F1
		F1 = F1 + F0
		F0 = res
	print(F0, F0, F1 - F0)
	return None
Sol(int(input()))


import math
from collections import defaultdict
ml = lambda : map(int, input().split())
ll = lambda : list(map(int, input().split()))
ii = lambda : int(input())
ip = lambda : input()
fib = []
a = 0
b = 1
i = 0
while i < 50:
	fib.append(a)
	(a, b) = (b, a + b)
	i += 1
t = ii()
f = 0
ans = ["I'm too stupid to solve this problem"]
x = 0
y = 0
z = 0
for i in fib:
	for j in fib:
		for k in fib:
			if i + j + k == t:
				ans = [i, j, k]
				break
print(*ans)


n = int(input())
fibs = [0, 1]
while fibs[-1] < n:
	fibs.append(sum(fibs[-2:]))
if n <= 3:
	print(' '.join(['0'] * (3 - n) + ['1'] * n))
else:
	print(fibs[-5], fibs[-4], fibs[-2])


n = int(input())
re_list = [0]
(a, b) = (0, 1)
while b < n:
	re_list.append(b)
	(a, b) = (b, a + b)
if n == 0:
	print('0 0 0')
elif n == 1:
	print('0 0 1')
else:
	print(0, re_list[-2], re_list[-1])


from collections import deque
from math import log, sqrt, ceil

def ii():
	return int(input())

def si():
	return input()

def mi():
	return map(int, input().strip().split(' '))

def li():
	return list(mi())
n = ii()
if n <= 3:
	a = 0
	print(n, a, a)
else:
	f0 = 1
	f1 = 1
	f2 = 2
	f3 = 3
	f4 = f2 + f3
	while f4 < n:
		f0 = f1
		f1 = f2
		f2 = f3
		f3 = f4
		f4 = f2 + f3
	print(f0, f1, f3)


fib = [0] * 50
fib[0] = 0
fib[1] = 1
n = int(input())
if n == 0:
	print('0 0 0')
elif n == 1:
	print('0 0 1')
elif n == 2:
	print('0 1 1')
else:
	for i in range(2, 50):
		fib[i] = fib[i - 1] + fib[i - 2]
		if fib[i] == n:
			print('{} {} {}'.format(fib[i - 4], fib[i - 3], fib[i - 1]))
			break


def fib(n):
	if n == 0:
		print('0 0 0')
	elif n == 1:
		print('0 0 1')
	else:
		a = 0
		b = 1
		for i in range(1, n + 1):
			c = a + b
			if c != n:
				a = b
				b = c
			else:
				break
		print(b, end=' ')
		print(b - a, end=' ')
		print(2 * a - b, end=' ')
n = int(input())
fib(n)


buffer = [1, 1, 2, 3, 5]
n = int(input())
if n == 0:
	print(0, 0, 0)
elif n == 1:
	print(1, 0, 0)
elif n == 2:
	print(1, 0, 1)
elif n == 3:
	print(1, 1, 1)
else:
	while buffer[-1] != n:
		buffer.append(buffer[-1] + buffer[-2])
		del buffer[0]
	print(buffer[0], buffer[1], buffer[3])


n = int(input())
a = [0, 0, n]
print(*a)


n = int(input())
(a, c) = (0, 0)
b = 1
l = [0, 1]
while c < n:
	c = a + b
	if c <= n:
		l.append(c)
	a = b
	b = c
if n in l:
	print(0, 0, n)
else:
	print(" I'm too stupid to solve this problem ")