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
/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
//package cf8;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.StringTokenizer;

/**
 *
 * @author varun
 */
public class CF8 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) throws IOException {
        // TODO code application logic here
        Reader.init(System.in);
        int n = Reader.nextInt();
        boolean flag = true;
        ArrayList<Integer> fib = new ArrayList<Integer>();
        fib.add(0);
        fib.add(1);
        int i = 2;
        if(n!=0){
            while(flag){
                if(fib.get(i-1) + fib.get(i-2) == n){
                    fib.add(fib.get(i-1) + fib.get(i-2));
                    flag=false;
                }
                else{
                    fib.add(fib.get(i-1) + fib.get(i-2));
                }
                i++;
            }
        }
        
        if(n==0){
            System.out.println(0 + " " + 0 + " " + 0);
        }
        else if(n==1){
            System.out.println(0 + " " + 0 + " " + 1);
        }
        else if(n==2){
            System.out.println(0 + " " + 1 + " " + 1);
        }
        else if(n==3){
            System.out.println(1 + " " + 1 + " " + 1);
        }
        else{
            System.out.println(fib.get(fib.size()-2) + " " + fib.get(fib.size()-4) + " " +  fib.get(fib.size()-5));
        }
            
    }
    
}

class Reader {
    static BufferedReader reader;
    static StringTokenizer tokenizer;

    /** call this method to initialize reader for InputStream */
    static void init(InputStream input) {
        reader = new BufferedReader(
                     new InputStreamReader(input) );
        tokenizer = new StringTokenizer("");
    }

    /** get next word */
    static String next() throws IOException {
        while ( ! tokenizer.hasMoreTokens() ) {
            //TODO add check for eof if necessary
            tokenizer = new StringTokenizer(
                   reader.readLine() );
        }
        return tokenizer.nextToken();
    }

    static int nextInt() throws IOException {
        return Integer.parseInt( next() );
    }
	
    static double nextDouble() throws IOException {
        return Double.parseDouble( next() );
    }
    static long nextLong() throws IOException {
        return Long.parseLong( next() );
    }
}