codeparrot/codecomplex huggingface dataset:
// Problem: 199_A. Hexadecimal's theorem
// Time complexity: constant
import java.util.*;

public class Main {
    final int INF = Integer.MAX_VALUE / 2;
    private void doit(){
        Scanner sc = new Scanner(System.in);
        //while(sc.hasNext()){
            int n = sc.nextInt();
            if(n == 0){
                System.out.println("0 0 0");
            }
            else if(n == 1){
                System.out.println("0 0 1");
            }
            else{
                //create a fib
                ArrayList<Integer> fibList = new ArrayList<Integer>();
                int pre = 0;
                int next = 1;
                fibList.add(pre);
                fibList.add(next);
                while(next != n){
                    int temp = next;
                    next +=pre;
                    fibList.add(next);
                    pre = temp;
                }
                int len = fibList.size();
                int a = fibList.get(len-4);
                int b = fibList.get(len-3);
                int c = fibList.get(len-3);
                System.out.println(a + " " + b + " " + c);
            }
        //}
    }

    public static void main(String[] args) {
        Main obj = new Main();
        obj.doit();
    }
}
// Problem: 199_A. Hexadecimal's theorem
// Time complexity: constant
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
//package CodeForces3;

import java.util.ArrayList;
import java.util.Scanner;

/**
 *
 * @author DELL
 */
public class HexadecimalsTheorem {

    public void solve() {
        Scanner sc = new Scanner(System.in);
        long n = sc.nextLong();

        ArrayList<Long> a = new ArrayList<Long>();

        a.add(0l);
        a.add(1L);
        a.add(1L);

        int i = 1, j = 2;

        while ((a.get(i) + a.get(j)) <= n) {
            a.add((a.get(i) + a.get(j)));
            i++;
            j++;
        }

        if (a.contains(n)) {
            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 {
                System.out.println(a.get(j - 4) + " " + a.get(j - 3) + " " + a.get(j - 1));

            }

        } else {
            System.out.println("I'm too stupid to solve this problem");
        }


    }

    public static void main(String[] args) {
        new HexadecimalsTheorem().solve();
    }
}
// Problem: 199_A. Hexadecimal's theorem
// Time complexity: constant
import java.io.*;
import java.util.*;
import java.math.*;

public class MAIN
{
	public static void main(String args[])
	{
		Scanner sn=new Scanner(System.in);
		int n,n1,n2,n3;

		int 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,514229,832040,1346269,2178309,3524578,5702887,9227465,14930352,24157817,39088169,63245986,102334155,165580141,267914296,433494437,701408733,1134903170};

		n=sn.nextInt();


		if(n==2)
		{
			n1=n2=1;
			n3=0;
		}
		else if(n==1)
		{
			n3=n2=0;
			n1=1;
		}
		else if(n==0)
		{
			n1=n2=n3=0;
		}
		else if(n==3)
		{
			n1=n2=n3=1;
		}
		else
		{
			int index=bsearch(arr,0,arr.length-1,n);
			n1=arr[index-1];
			n2=arr[index-3];
			n3=arr[index-4];
		}

		System.out.println(n3+" "+n2+" "+n1);

	}

	static int bsearch(int arr[],int l,int h,int n)
	{
		if(l>h)
		return -1;

		int mid=(l+h)/2;

		if(n==arr[mid])
		return mid;
		else if(n>arr[mid])
		return(bsearch(arr,mid+1,h,n));
		else
		return(bsearch(arr,l,mid-1,n));
	}
}
// Problem: 199_A. Hexadecimal's theorem
// Time complexity: constant
import java.io.*;
import java.util.*;


public class Contest1_1{
    
    public static void main(String ar[]) throws Exception { 
        
        BufferedReader buff = new BufferedReader(new InputStreamReader(System.in));
        int input = Integer.parseInt(buff.readLine());
        if(input==0){
            System.out.println("0 0 0");
        }else if(input==1){
            System.out.println("0 0 1");
        }else if(input==2){
            System.out.println("0 1 1");
        }else if(input==3){
            System.out.println("1 1 1");
        }else {
            int output[] = checkFibo(input);
            int get[] = checkFibo(output[1]);
            output[0] = get[1];
            output[1] = get[2];
            System.out.print(output[0]);
            System.out.print(" " + output[1]);
            System.out.println(" " + output[2]);    
        }
    }
    
    public static int[] checkFibo(int input){
        int output[] = new int[3];
        int fibo_1 = 0;
        int fibo_2 = 1;
        int temp = 0;
        while(fibo_2!=input){
            temp = fibo_2;
            output[1] = fibo_1;
            output[2] = fibo_2;
            fibo_2 += fibo_1;
            fibo_1 = temp;
        }
        return output;
    }   
}
// Problem: 199_A. Hexadecimal's theorem
// Time complexity: constant
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;

public class Hexadecimaltheorem {
	public static void main(String[] args) {
		BufferedReader buf = new BufferedReader(
				new InputStreamReader(System.in));
		int x;
		ArrayList<Integer> arr = new ArrayList<Integer>();
		arr.add(0);
		arr.add(1);
		try {
			while ((x = Integer.parseInt(buf.readLine())) != -1) {
				if (x == 1) {

					System.out.println(arr.get(0) + " " + arr.get(0) + " "
							+ arr.get(1));
				} else if (x == 0) {
					System.out.println(arr.get(0) + " " + arr.get(0) + " "
							+ arr.get(0));
				} else {
					int i = 1;
					while (x > arr.get(arr.size() - 1)) {
						arr.add(arr.get(i) + arr.get(i - 1));
						i++;
					}
					System.out.println(arr.get(0) + " " + arr.get(i - 2) + " "
							+ arr.get(i - 1));
				}
			}
		} catch (NumberFormatException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}
// Problem: 199_A. Hexadecimal's theorem
// Time complexity: constant
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.util.StringTokenizer;

public class CF125D2A {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("0 0 " + sc.nextInt());
    }
}
// Problem: 199_A. Hexadecimal's theorem
// Time complexity: constant
import java.util.Scanner;

public class ProblemA {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        long n = sc.nextLong();
        long[] answer = new long[3];
        if (n == 1) {
            answer[0] = 0;
            answer[1] = 0;
            answer[2] = 1;
        } else if (n > 1) {
            long f1 = 0;
            long f2 = 1;
            long m = 0;
            while (m < n) {
                answer[0] = answer[1];
                answer[1] = f1;
                answer[2] = f2;
                m = f1 + f2;
                f1 = f2;
                f2 = m;
            }
            answer[2] = answer[1];
        }
        System.out.println(answer[0] + " " + answer[1] + " " + answer[2]);
    }
}
// Problem: 199_A. Hexadecimal's theorem
// Time complexity: constant
import java.util.*;

public class A {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        System.out.println("0 0 " + n);
    }
}
// Problem: 199_A. Hexadecimal's theorem
// Time complexity: constant
import java.io.*;

import java.util.*;
import java.util.concurrent.ArrayBlockingQueue;

import javax.print.attribute.HashAttributeSet;

public class CodeForces {

	public void solve() throws IOException {
		int n = nextInt();
		int arr[]=new int[1000];
		arr[0]=0;
		arr[1]=1;
		arr[2]=1;
		if(n==0){
			out.print("0 0 0");
		}
		else if(n==1){
			out.print("0 0 1");
		} else {
			int c=2;
			while(arr[c]!=n){
				c++;
				arr[c]=arr[c-1]+arr[c-2];
			}
			out.print(arr[c-2]+" "+arr[c-2]+" "+arr[c-3]);
		}
		
		
	}

	public static void main(String[] args) {
		new CodeForces().run();
	}
	
	

	int NOD(int a, int b) {
		while (a != 0 && b != 0) {
			if (a >= b)
				a = a % b;
			else
				b = b % a;
		}
		return a + b;
	}

	BufferedReader reader;
	StringTokenizer tokenizer;
	PrintWriter out;
	boolean isOuterFile = false;

	public void run() {
		try {
			if (isOuterFile) {
				reader = new BufferedReader(new FileReader("input.txt"));
				out = new PrintWriter(new BufferedWriter(new FileWriter("output.txt")));
				out = new PrintWriter(System.out);
			} else {
				reader = new BufferedReader(new InputStreamReader(System.in));
				out = new PrintWriter(System.out);
			}

			tokenizer = null;	
			// long t=new Date().getTime();
			solve();
			// writer.println(t-new Date().getTime());
			reader.close();
			out.close();
		} catch (Exception e) {
			e.printStackTrace();
			System.exit(1);
		}
	}

	int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}

	double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}

	String nextToken() throws IOException {
		while (tokenizer == null || !tokenizer.hasMoreTokens()) {
			tokenizer = new StringTokenizer(reader.readLine());
		}
		return tokenizer.nextToken();
	}
}
// Problem: 199_A. Hexadecimal's theorem
// Time complexity: constant


import java.util.Scanner;

/**
 *
 * @author Gitesh
 */
public class JavaApplication2 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        Scanner s=new Scanner(System.in);
        
                int n;
                      n=s.nextInt();
                      System.out.print(n+" "+"0 0");            
}
}
// Problem: 199_A. Hexadecimal's theorem
// Time complexity: constant

import java.util.Scanner;

public class HexadecimalTheorem {
    public static void main(String[] args) {
        Scanner read = new Scanner(System.in);
        int num = read.nextInt();
        int zero, one, two, three;
        zero = 0;
        one = 1;
        two = 1;
        three = 2;
        if(num == 0)
            System.out.println("0 0 0");
        else if(num == 1)
            System.out.println("0 0 1");
        else{
            while(num != three){
                zero = one;
                one = two;
                two = three;
                three = three + one;
            }
            System.out.println(zero + " " + one + " " + one);
        }
    }
}
// Problem: 199_A. Hexadecimal's theorem
// Time complexity: constant
import java.util.Scanner;


public class Main {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int x = scan.nextInt();
    solve(x);

    }
    public static void solve (int x){
        int z = 0 ;
        System.out.print(z+" ");
        System.out.print(z+" ");
        System.out.print(x);
        
    }

}
// Problem: 199_A. Hexadecimal's theorem
// Time complexity: constant

import java.util.Scanner;

public class A {

    public static void main(String args[]) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int f1 = 0;
        int f2 = 1;
        int f3 = 1;
        while (f3 < n) {
            f1 = f2;
            f2 = f3;
            f3 = f1 + f2;
        }
        if (n == 0) {
            System.out.println(0 + " " + 0 + " " + 0);
        } else if (f3 == n) {
            System.out.println(f1 + " " + f1 + " " + (f2 - f1));
        } else {
            System.out.println("I'm too stupid to solve this problem");
        }
    }
}
// Problem: 199_A. Hexadecimal's theorem
// Time complexity: constant
import java.io.*;
import java.util.StringTokenizer;

/**
 * Author: Maksim Novik
 * Date: 30.06.12
 * Time: 22:34
 */
public class Round125ProblemA {

    public static void main(String[] args) {
        InputStream in = System.in;
        OutputStream out = System.out;
        InputReader reader = new InputReader(in);
        PrintWriter writer = new PrintWriter(out);
        solve(reader, writer);
        writer.close();
    }

    static void solve(InputReader in, PrintWriter out) {
        long fib = in.nextLong();
        out.write("" + 0  + " " + 0 + " " + fib);
    }

    static class InputReader {
        private BufferedReader reader;
        private StringTokenizer tokenizer;

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

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

        public long nextLong() {
            return Long.parseLong(next());
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

    }
}
// Problem: 199_A. Hexadecimal's theorem
// Time complexity: constant
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class Solver {

    StringTokenizer st;
    BufferedReader in;
    PrintWriter out;

    public static void main(String[] args) throws NumberFormatException, IOException {
        Solver solver = new Solver();
        solver.open();
        solver.solve();
        solver.close();
    }

    public void open() throws IOException {
        in = new BufferedReader(new InputStreamReader(System.in));
        out = new PrintWriter(System.out);
    }

    public String nextToken() throws IOException {
        while (st == null || !st.hasMoreTokens()) {
            st = new StringTokenizer(in.readLine());
        }
        return st.nextToken();
    }

    public int nextInt() throws NumberFormatException, IOException {
        return Integer.parseInt(nextToken());
    }

    public long nextLong() throws NumberFormatException, IOException {
        return Long.parseLong(nextToken());
    }

    public double nextDouble() throws NumberFormatException, IOException {
        return Double.parseDouble(nextToken());
    }

    public void solve() throws NumberFormatException, IOException {
        int n = nextInt();
        out.println(0+" "+0+" "+n);
    }

    public void close() {
        out.flush();
        out.close();
    }

}
// Problem: 199_A. Hexadecimal's theorem
// Time complexity: constant

import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Scanner;


public class Main {

    public static void main(String[] args) {

        Scanner in = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out);
        
        int n = in.nextInt();
        
        out.println(n+" 0 0");
        
        in.close();
        out.close();
        
    }

}
// Problem: 199_A. Hexadecimal's theorem
// Time complexity: constant
import java.io.*;
import java.util.*;

public class program{
	public static void main(String args[]) throws Exception{
		Scanner sc=new Scanner(System.in);
		int n=sc.nextInt();
		if(n==0){
			System.out.println("0 0 0");
			return;
		}
		else if(n==1){
			System.out.println("0 0 1");
			return;
		}
		else if(n==2){
			System.out.println("0 1 1");
			return;
		}
		else{
			int ppp=0;
			int pp=1;
			int c=2;
			while(true){
				if(ppp+pp+c==n){
					System.out.println(ppp+" "+pp+" "+c);
					return;
				}
				else{
					c=c+pp+ppp;
					int temp=pp;
					pp=pp+ppp;
					ppp=temp;
				}
			}
		}
	}
}
// Problem: 199_A. Hexadecimal's theorem
// Time complexity: constant
import java.util.LinkedList;
import java.util.Scanner;

public class HexadecimalsTheorem {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int num = in.nextInt();
        LinkedList<Integer> result = new LinkedList<Integer>();
        int temp0 = 1;
        int temp1 = 1;
        int temp2 = 0;
        result.add(0);
        result.add(0);
        result.add(0);
        result.add(temp0);
        result.add(temp1);
        if (num == 2) {
            System.out.println(0 + " " + 1 + " " + 1);
        } else if (num == 0) {
            System.out.println(0 + " " + 0 + " " + 0);
        } else {
            while (temp2 < num) {
                temp2 = temp1 + temp0;
                result.add(temp2);
                temp0 = temp1;
                temp1 = temp2;
            }
            int length = result.size();
            System.out.println(result.get(length - 5) + " "
                    + result.get(length - 4) + " " + result.get(length - 2));
        }
    }

}
// Problem: 199_A. Hexadecimal's theorem
// Time complexity: constant
import java.io.*;
import java.util.*;
import java.util.regex.*;

public class A {
	static Scanner scan = new Scanner (System.in);
	static PrintStream out = System.out;
	
	static void go (int n) {
		if (n == 0) {
			System.out.println (0 + " " + 0 + " " + 0);
			return;
		}
		int a = 0, b = 1;
		int c = a + b; 
		while (n > c) {
			a = b;
			b = c;
			c = a + b;
		}
		System.out.println (0 + " " + a + " " + b);
	}
	
	public static void main (String[] args) {
		int n = scan.nextInt();
		go (n);
	
	} 
			
	
}
// Problem: 199_A. Hexadecimal's theorem
// Time complexity: constant
import java.util.Arrays;
import java.util.Scanner;

public class A {

    public static void main(String[] args) {
        long 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, 1836311903, 2971215073L, 4807526976L, 7778742049L, 12586269025L, 20365011074L, 32951280099L, 53316291173L, 86267571272L, 139583862445L, 225851433717L, 365435296162L, 591286729879L, 956722026041L, 1548008755920L, 2504730781961L, 4052739537881L, 6557470319842L, 10610209857723L };
        int i = Arrays.binarySearch(fib, new Scanner(System.in).nextLong());
        if (i < 4)
            if (i == 3)
                System.out.println("0 1 1");
            else if (fib[i] == 1)
                System.out.println("0 0 1");
            else
                System.out.println("0 0 0");
        else
            System.out.println(fib[i - 4] + " " + fib[i - 3] + " " + fib[i - 1]);
    }

}
// Problem: 199_A. Hexadecimal's theorem
// Time complexity: constant
import java.io.*;
import java.util.*;
import java.util.regex.*;



public class Main {
	static Scanner scan = new Scanner (System.in);
	static PrintStream out = System.out;

	static int n;
	static void solve () {
		System.out.println (0 + " " + 0 + " " + n);
	}
	
	public static void main (String[] args) {
		n = scan.nextInt();
		solve ();
	}
}
// Problem: 199_A. Hexadecimal's theorem
// Time complexity: constant
import java.io.*;
import java.util.*;
public class Main{
    public static void main(String[] args) throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        List<Integer> fibs = new ArrayList<Integer>();
        int fib0 = 0;
        int fib1 = 1;
        int fibN = fib0+fib1;
        fibs.add(fib0);
        fibs.add(fib1);
        while(fibN < 1000000000){
            fibs.add(fibN);
            fib0 = fib1;
            fib1 = fibN;
            fibN = fib0+fib1;
        }
        int n = Integer.parseInt(br.readLine());
        
        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{
        int i = fibs.indexOf(n);
        System.out.println(fibs.get(i-4)+" "+fibs.get(i-3)+" "+fibs.get(i-1));
    }}
        }
}
}
// Problem: 199_A. Hexadecimal's theorem
// Time complexity: constant
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class A125D2 {

	public static void main(String[] args) throws Exception {
		InputReader in = new InputReader(System.in);
		System.out.println(0 + " " + 0 + " " + in.nextInt());
	}

	static class InputReader {
		private BufferedReader reader;
		private StringTokenizer tokenizer;

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

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

		public int nextInt() {
			return Integer.parseInt(next());
		}
	}
}
// Problem: 199_A. Hexadecimal's theorem
// Time complexity: constant
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */


import java.util.Scanner;

/**
 *
 * @author dilshan
 */
public class Test {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int n = s.nextInt();
        int k = 1;
        int t = 0;
        int y = 2;
        int[] a = new int[100000];
        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{
                    a[0] = 0;
                    a[1] = 1;
                    a[y] = a[y - 2] + a[y - 1];
                    while (a[y - 1] < n) {

                        a[y] = a[y - 2] + a[y - 1];
                        ++y;


                    }
                    System.out.println(a[y - 2] + " " + a[y - 4] + " " + a[y - 5]);
            }
        //System.out.println(y);
        


    }
}
// Problem: 199_A. Hexadecimal's theorem
// Time complexity: constant
import java.util.*;
public class Hexadecimal {
 public static void main(String args[]){
	 Scanner input = new Scanner(System.in);
	 int n = input.nextInt();
	 System.out.print("0 0 " + n);
 }
}
// Problem: 199_A. Hexadecimal's theorem
// Time complexity: constant

import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Main {
public static void main(String args[]) throws Exception
    {
     
     BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
     int n=Integer.parseInt(br.readLine());
     System.out.println("0 0 "+n);}

}
// Problem: 199_A. Hexadecimal's theorem
// Time complexity: constant
import java.io.*;
import java.util.*;

public class C125 {
	public static void main(String[] args) throws IOException {
		BufferedReader r = new BufferedReader(new InputStreamReader(System.in));
		String s = r.readLine();
		int n = new Integer(s);
		System.out.println("0 0 "+n);
	}
}
// Problem: 199_A. Hexadecimal's theorem
// Time complexity: constant
import java.io.InputStreamReader;
import java.util.Scanner;

public class Hexadecimal {

    public static void main(String [] args){
        Scanner s = new Scanner(new InputStreamReader(System.in));

        int x = s.nextInt();

       System.out.println(x + " " + 0 + " " + 0);
    }
}