codeparrot/codecomplex huggingface dataset:
// Problem: 630_A. Again Twenty Five!
// Time complexity: constant
public class Main {
  public static void main(String[] args){
    System.out.println("25");
  }
}
// Problem: 630_A. Again Twenty Five!
// Time complexity: constant
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class Main {
	public static void main(String args[]) {
		InputStream intputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(intputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskA solver = new TaskA();
		solver.solve(in, out);
		out.close();
	}

	static class TaskA {
		public void solve(InputReader in, PrintWriter out) {
			out.println(25);
		}
	}

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

		public InputReader(InputStream stream) {
			reader = new BufferedReader(new InputStreamReader(stream), 32768);
			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());
		}
		
		public double nextDouble() {
			return Double.parseDouble(next());
		}
		
		public long nextLong() {
			return Long.parseLong(next());
		}
		
		public String nextLine() {
			try {
				return reader.readLine();
			} catch (IOException e) {
				return null;
			}
		}
	}
}
// Problem: 630_A. Again Twenty Five!
// Time complexity: constant
import java.io.*;
import java.util.*;
import java.math.*;
import static java.lang.Math.*;
import static java.lang.Integer.parseInt;
import static java.lang.Long.parseLong;
import static java.lang.Double.parseDouble;
import static java.lang.String.*;
    
public class Main {
    
    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
                                            //(new FileReader("input.in"));
        StringBuilder out = new StringBuilder();
        StringTokenizer tk;
        
        
        long n = parseLong(in.readLine());
        
        System.out.println("25");
    }
    
}
// Problem: 630_A. Again Twenty Five!
// Time complexity: constant
import java.util.Scanner;

/**
 * Created by mmaikovych on 18.02.16.
 */
public class EER_A {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        scanner.nextLine();
        System.out.println(25);
    }
}
// Problem: 630_A. Again Twenty Five!
// Time complexity: constant
import java.util.*;
public class ProA {
	static long n;

	public static void main(String[] args) {
		Scanner in=new Scanner(System.in);
		n=in.nextLong();
		System.out.println(25);
	}
}
// Problem: 630_A. Again Twenty Five!
// Time complexity: constant
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.StringTokenizer;


public class A {

	static StringTokenizer st;
	static BufferedReader br;
	static PrintWriter pw;
	public static void main(String[] args) throws IOException {
		br = new BufferedReader(new InputStreamReader(System.in));
		pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
		BigInteger a = new BigInteger(next());
		System.out.println(BigInteger.valueOf(5).modPow(a, BigInteger.valueOf(100)));
		pw.close();
	}
	private static int nextInt() throws IOException {
		return Integer.parseInt(next());
	}
	private static long nextLong() throws IOException {
		return Long.parseLong(next());
	}
	private static double nextDouble() throws IOException {
		return Double.parseDouble(next());
	}
	private static String next() throws IOException {
		while (st==null || !st.hasMoreTokens())
			st = new StringTokenizer(br.readLine());
		return st.nextToken();
	}
}
// Problem: 630_A. Again Twenty Five!
// Time complexity: constant

import java.util.Scanner;

/*
 * 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.
 */

/**
 *
 * @author Madi
 */
public class A630 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        
        String s = sc.nextLine();
        System.out.println("25");
    }
}
// Problem: 630_A. Again Twenty Five!
// Time complexity: constant
import java.io.*;
import static java.lang.Math.*;

import java.lang.reflect.Array;
import java.util.*;
import java.lang.*;

public class Main {
    final static boolean debug = false;
    final static String fileName = "";
    final static boolean useFiles = false;

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

class InputReader {
    public BufferedReader reader;
    public StringTokenizer tokenizer;

    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream), 32768);
        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 double nextDouble() {
        return Double.parseDouble(next());
    }

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

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

    public byte nextByte() {
        return Byte.parseByte(next());
    }
}

class Task {
    public void solve() {
        out.println(25);
    }

    private InputReader in;
    private PrintWriter out;

    Task(InputReader in, PrintWriter out) {
        this.in = in;
        this.out = out;
    }
}
// Problem: 630_A. Again Twenty Five!
// Time complexity: constant
import java.io.*;


public class Main {
    private StreamTokenizer in;
    private PrintWriter out;


    public static void main(String[] args) throws IOException {
        //long time = System.currentTimeMillis();

        new Main().run();
        //time = System.currentTimeMillis() - time;
        //System.out.println(time + " ms");

    }


    private void run() throws IOException {
        //in = new StreamTokenizer(new BufferedReader(new InputStreamReader(new FileInputStream("input.txt"))));
        //BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream("input.txt")));
        //out = new PrintWriter(new File("output.txt"));

        in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
        //BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        out = new PrintWriter(new OutputStreamWriter(System.out));
        out.print(25);


        out.flush();

    }


    int nextInt() throws IOException {
        in.nextToken();
        return (int) in.nval;
    }
}
// Problem: 630_A. Again Twenty Five!
// Time complexity: constant
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.InputStream;
import java.math.BigInteger;
import java.util.Arrays;
/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author Erasyl Abenov
 * 
 * 
 */
public class Main {
    public static void main(String[] args) throws IOException {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
            try (PrintWriter out = new PrintWriter(outputStream)) {
                TaskB solver = new TaskB();
                solver.solve(1, in, out);
            }
    }
}
class TaskB {
    public void solve(int testNumber, InputReader in, PrintWriter out) throws IOException{
        String n = in.next();
        out.println(25);
    }
}
   
       
class InputReader {
    private final BufferedReader reader;
    private StringTokenizer tokenizer;
    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream));
        tokenizer = null;
    }
        
    public String nextLine() {
        try {
            return reader.readLine();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
        
    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            tokenizer = new StringTokenizer(nextLine());
        }
        return tokenizer.nextToken();
    }
        
    public int nextInt() {
        return Integer.parseInt(next());
    }
    public BigInteger nextBigInteger(){
        return new BigInteger(next());
    }
    public long nextLong() {
        return Long.parseLong(next());
    }
    public double nextDouble() {
        return Double.parseDouble(next());
    }
}
// Problem: 630_A. Again Twenty Five!
// Time complexity: constant
import java.io.*;
import java.util.*;
public class a {
public static void main(String[] args) throws IOException {
	input.init(System.in);
	PrintWriter out = new PrintWriter(System.out);
	long n = input.nextLong();
	if(n == 1) out.println(5);
	else out.println(25);
	out.close();
}

public static class input {
	static BufferedReader reader;
	static StringTokenizer tokenizer;

	static void init(InputStream input) {
		reader = new BufferedReader(new InputStreamReader(input));
		tokenizer = new StringTokenizer("");
	}

	static String next() throws IOException {
		while (!tokenizer.hasMoreTokens())
			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());
	}
}
}
// Problem: 630_A. Again Twenty Five!
// Time complexity: constant
import java.io.*;
import java.util.*;

public class A {
    public static void main(String[] args) throws Exception {
	// TODO Auto-generated method stub
	BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
	PrintWriter out = new PrintWriter(System.out);
	String s = bf.readLine();
	out.println(25);
	
	out.flush();
	out.close();

    }
}
// Problem: 630_A. Again Twenty Five!
// Time complexity: constant
import java.util.*;
public class TwentyFive {
	
	public static void main(String[] args)
	{
		System.out.println("25");
	}
}
// Problem: 630_A. Again Twenty Five!
// Time complexity: constant
import java.io.BufferedReader;
import java.io.Closeable;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.StringTokenizer;

public class A {
	
	public static void main(String[] args) {
		try (final Scanner sc = new Scanner(System.in)) {
			System.out.println(25);
		}
	}
	
	public static class Scanner implements Closeable {
		private BufferedReader br;
		private StringTokenizer tok;

		public Scanner(InputStream is) {
			br = new BufferedReader(new InputStreamReader(is));
		}

		private void getLine() {
			try {
				while (!hasNext()) {
					tok = new StringTokenizer(br.readLine());
				}
			} catch (IOException e) { /* ignore */
			}
		}

		private boolean hasNext() {
			return tok != null && tok.hasMoreTokens();
		}

		public String next() {
			getLine();
			return tok.nextToken();
		}

		public int nextInt() {
			return Integer.parseInt(next());
		}
		
		public long nextLong() {
			return Long.parseLong(next());
		}

		public void close() {
			try {
				br.close();
			} catch (IOException e) { /* ignore */
			}
		}
	}
}
// Problem: 630_A. Again Twenty Five!
// Time complexity: constant
/*
 * Code Author: Sanket Udgirkar.
 * DA-IICT
 */
import java.util.*;
import java.io.*;
public class Tester
{
	public static long mod=(long)1e9+7;
	
	public static void main(String[] args) 
	{
		InputReader s=new InputReader(System.in);
        OutputStream outputStream = System.out;
        //PrintWriter out=new PrintWriter(outputStream);
        
       String str=s.nextLine();
       System.out.println("25");
        
        
        //out.close();
	}   
	
	static long gcd(long a,long b)
	{
		if(b==0)
			return a;
		a%=b;
		return gcd(b,a);
	}
	
	static long exp(long a, long b)
	{
		if(b==0)
			return 1;
		if(b==1)
			return a;
		if(b==2)
			return a*a;
		
		if(b%2==0)
			return exp(exp(a,b/2),2);
		else
			return a*exp(exp(a,(b-1)/2),2);
	}
	
	static class Pair implements Comparable<Pair>
	{
		long x,f;
		Pair(long ii, long cc)
		{
			x=ii;
			f=cc;
		}
		
		public int compareTo(Pair o) 
		{
			return Long.compare(this.x, o.x);
		}
		
	}

    public static class InputReader 
    {
    	public BufferedReader reader;
    	public StringTokenizer tokenizer;
     
    	public InputReader(InputStream inputstream) 
    	{
    	      reader = new BufferedReader(new InputStreamReader(inputstream));
    	      tokenizer = null;
    	}
    	    
    	public String nextLine()
    	{
    	    String fullLine=null;
    	    while (tokenizer == null || !tokenizer.hasMoreTokens()) 
    	    {
    	        try {
    	              fullLine=reader.readLine();
    	            } 
    	        catch (IOException e) 
    	        {
    	              throw new RuntimeException(e);
    	        }
    	        return fullLine;
    	     }
    	     return fullLine;
    	}
    		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: 630_A. Again Twenty Five!
// Time complexity: constant
import java.util.*;
public class A630 {
	public static void main(String[] args)
	{
		Scanner scan = new Scanner(System.in);
		long n = scan.nextLong();
		System.out.println(25);
	}
}
// Problem: 199_A. Hexadecimal's theorem
// Time complexity: constant
import java.io.PrintWriter;
import java.util.Scanner;


public class HexadecimalTheorem {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int n = in.nextInt();
		PrintWriter out = new PrintWriter(System.out);
		out.printf("%d %d %d%n", 0, 0, n);
		out.flush();
	}

}
// Problem: 199_A. Hexadecimal's theorem
// Time complexity: constant
/**
 * Created by IntelliJ IDEA.
 * User: SONY
 * Date: 27.05.12
 * Time: 18:25
 * To change this template use File | Settings | File Templates.
 */

import java.io.*;
import java.util.*;

public class TaskA extends Thread {
    public TaskA(String inputFileName, String outputFileName) {
        try {
            if (inputFileName != null) {
                this.input = new BufferedReader(new FileReader(inputFileName));
            } else {
                this.input = new BufferedReader(new InputStreamReader(System.in));
            }
            if (outputFileName != null) {
                this.output = new PrintWriter(outputFileName);
            } else {
                this.output = new PrintWriter(System.out);
            }
            this.setPriority(Thread.MAX_PRIORITY);
        } catch (Throwable e) {
            System.err.println(e.getMessage());
            e.printStackTrace();
            System.exit(666);
        }
    }

    private void solve() throws Throwable {
        long n = nextLong();
        output.println("0 0 " + n);
    }

    public void run() {
        try {
            solve();
        } catch (Throwable e) {
            System.err.println(e.getMessage());
            e.printStackTrace();
            System.exit(666);
        } finally {
            output.close();
        }
    }

    public static void main(String... args) {
        new TaskA(null, null).start();
    }

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

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

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

    private String next() throws IOException {
        while (tokens == null || !tokens.hasMoreTokens()) {
            tokens = new StringTokenizer(input.readLine());
        }
        return tokens.nextToken();
    }

    private StringTokenizer tokens;
    private BufferedReader input;
    private PrintWriter output;
}
// Problem: 199_A. Hexadecimal's theorem
// Time complexity: constant
import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;

public class A {
    public static void main(String[] args) throws FileNotFoundException {
        Scanner s = new Scanner(System.in);
        int T = s.nextInt();
        System.out.println("0 0 "+T);
        /*if(T==0) {

            return;
        }
        if(T==1) {
            System.out.println("0 0 0");
            return;
        }
        System.out.println();*/
    }
}
// Problem: 199_A. Hexadecimal's theorem
// Time complexity: constant
import java.util.Scanner;

public class A{
	public static void main(String[] args){
		Scanner s = new Scanner(System.in);
		int n = s.nextInt();

		int prev2=0;
		int prev1=1;
		int prev=1;
		int curr = 2;
		if(n == 0) {System.out.println("0 0 0"); return;}
		else if(n == 1) {System.out.println("0 0 1");return;}
		while(true){
			if(curr == n) break;
			prev2 = prev1;
			prev1 = prev;
			int temp = prev + curr;
			prev = curr;
			curr = temp;
		}
		System.out.println(prev2 + " " + prev1 + " " + prev1);
	}
}
// Problem: 199_A. Hexadecimal's theorem
// Time complexity: constant
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;

public class CF125A {

	private void work() throws IOException {
		Scanner sc = new Scanner(new BufferedReader(new InputStreamReader(
				System.in)));
		int n = sc.nextInt();
		System.out.printf("%d %d %d\n", 0, 0, n);
		System.out.close();
	}

	public static void main(String[] args) throws IOException {
		new CF125A().work();
	}

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

public class Main {
	public static void main(String[] args) throws IOException {
		(new Main()).solve();
	}

	public void Main() {
	}

	void solve() throws IOException {
		// BufferedReader in = new BufferedReader(new
		// InputStreamReader(System.in));
		// Scanner in = new Scanner(System.in);
		MyReader in = new MyReader();
		PrintWriter out = new PrintWriter(System.out);
		// Scanner in = new Scanner(new FileReader("input.txt"));
		// PrintWriter out = new PrintWriter("output.txt");

		int n = in.nextInt();
		out.print("0 0 ");
		out.print(n);

		out.close();
	}

};

class MyReader {
	private BufferedReader in;
	String[] parsed;
	int index = 0;

	public MyReader() {
		in = new BufferedReader(new InputStreamReader(System.in));
	}

	public int nextInt() throws NumberFormatException, IOException {
		if (parsed == null || parsed.length == index) {
			read();
		}
		return Integer.parseInt(parsed[index++]);
	}

	public long nextLong() throws NumberFormatException, IOException {
		if (parsed == null || parsed.length == index) {
			read();
		}
		return Long.parseLong(parsed[index++]);
	}

	public String nextString() throws IOException {
		if (parsed == null || parsed.length == index) {
			read();
		}
		return parsed[index++];
	}

	private void read() throws IOException {
		parsed = in.readLine().split(" ");
		index = 0;
	}

	public String readLine() throws IOException {
		return in.readLine();
	}
};
// Problem: 199_A. Hexadecimal's theorem
// Time complexity: constant
import java.util.Scanner;


public class CF125D2A {

    /**
     * @param args
     */
    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;

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

/**
 *
 * @author scawn
 */
public class Main {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        Scanner cin = new Scanner (System.in);
        int n = cin.nextInt();
        long res = 2;
        long[] a = new long[4];
        a[0] = 0;
        a[1] = 1;
        a[2] = 1;
        a[3] = 2;
        if (n == 1){
            System.out.println("0 0 1");
            return;
        }
        if (n == 2){
            System.out.println("0 1 1");
            return;
        }
        if (n == 0){
            System.out.println("0 0 0");
            return;
        }
//        if (n == 1 || n == 2 || n == 0){
//            System.out.println("I'm too stupid to solve this problem");
//            return;
//        }
        if (n == 3){
            System.out.println("1 1 1");
            return;
        }
        do{
            a[3] = res;
            res = a[2] + a[3];
            if (res == n){
                System.out.println (a[0] + " " + a[1] + " " + a[3]);
                return;
            }
            a[0] = a[1];
            a[1] = a[2];
            a[2] = a[3];
            
        }while (true);
    }
}
// Problem: 199_A. Hexadecimal's theorem
// Time complexity: constant
import java.util.Scanner;


public class Main {
    public static void main(String[] args) {
        Scanner r = new Scanner(System.in);
        
        int N = r.nextInt();
        
        System.out.println(N + " " + 0 + " " + 0);
    }
}
// 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));
    }
}