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
import java.io.*;
import java.util.ArrayList;
import java.util.StringTokenizer;

public class HexadecimalsTheorem {
    static InputReader r = new InputReader(System.in);
    static PrintWriter pw = new PrintWriter(System.out);

    public static void main(String[] args) {
        int n = r.nextInt();
        pw.println(n + " 0 0");
        /*
        if (n == 0) {
            pw.println("0 0 0");
        } else {
            ArrayList<Integer> fibonacci = new ArrayList<>();
            fibonacci.add(1);
            fibonacci.add(2);
            int i = 2;
            while (fibonacci.get(i - 1) <= n) {
                fibonacci.add(fibonacci.get(i - 1) + fibonacci.get(i - 2));
                i++;
            }
            int x = -1;
            int y = 0;
            int z = 0;
            for (Integer integer : fibonacci) {

                for (Integer integer1 : fibonacci) {
                    if (fibonacci.contains(n - integer - integer1)) {
                        x = integer;
                        y = integer1;
                        z = n - integer - integer1;
                    }
                }
            }
            if (x == -1) {
                pw.println("I'm too stupid to solve this problem");
            } else {
                pw.println(x + " " + y + " " + z);
            }
        }

         */
        pw.close(); // flushes the output once printing is done
    }

    static class InputReader {
        BufferedReader reader;
        StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        String next() { // reads in the next string
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() { // reads in the next int
            return Integer.parseInt(next());
        }

        public long nextLong() { // reads in the next long
            return Long.parseLong(next());
        }

        public double nextDouble() { // reads in the next double
            return Double.parseDouble(next());
        }
    }
}
