codeparrot/codecomplex huggingface dataset:
// Problem: 313_A. Ilya and Bank Account
// Time complexity: constant
import java.io.*;
import java.util.*;

public class TaskA  {
    public void run() {
        InputReader reader = new InputReader(System.in);
        PrintWriter writer = new PrintWriter(System.out, true);

        reader.nextLine();
        String statement = reader.next();

        if (!statement.startsWith("-")) {
            writer.println(statement);
        } else {
            try {
                int statement1 = Integer.parseInt(statement.substring(0, statement.length() - 1));
                int statement2 = Integer.parseInt(statement.substring(0, statement.length() - 2) + statement.charAt(statement.length() - 1));
                writer.println(Math.max(statement1, statement2));
            } catch (Exception e) {
                writer.println(statement);
            }
        }

        writer.close();
    }
    public static void main(String[] args) {
        new TaskA().run();
    }
    private class InputReader {
        BufferedReader reader;
        StringTokenizer token;

        private InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream));
        }

        private String next() {
            return token.nextToken();
        }

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

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

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

        private String nextLine() {
            String line = "";
            try {
                line = reader.readLine();
                token = new StringTokenizer(line, " ");

            } catch(IOException e) {

            }
            return line;
        }
    }
}
// Problem: 630_A. Again Twenty Five!
// Time complexity: constant
import java.util.Scanner;

public class A {
  public static void main(String[] args) {
    Scanner in = new Scanner(System.in);
    String inp = in.nextLine();
    System.out.println(25);
  }
}
// Problem: 630_A. Again Twenty Five!
// Time complexity: constant
import java.util.Scanner;

/**
 * Created by Gantushig on 2/18/2016.
 */

public class A {

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        long n = input.nextLong();
        System.out.println("25");
    }

}
// Problem: 630_A. Again Twenty Five!
// Time complexity: constant
public class P1 {
	
	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.InputStreamReader;

public class A {
	public static void main(String[] args) throws Exception {
		BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
		String l[] = bf.readLine().split(" ");
		System.out.println(25);
	}
}
// Problem: 630_A. Again Twenty Five!
// Time complexity: constant
import java.util.*;
public class a {
	public static void main(String[] args){
		Scanner br = new Scanner(System.in);
		long n = br.nextLong();
		System.out.println("25");
	}
}
// Problem: 630_A. Again Twenty Five!
// Time complexity: constant
	import java.io.BufferedReader;
	import java.io.IOException;
	import java.io.InputStreamReader;
	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.Collections;
	import java.util.Comparator;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.LinkedList;
	import java.util.List;
	import java.util.Map;
	import java.util.PriorityQueue;
	import java.util.Queue;
	import java.util.Random;
	import java.util.Set;
	import java.util.Stack;
	
	public class test {
		public static void main(String[] args) throws InterruptedException {
			//new careercup().run();
			//new CC().run();
			//System.out.println(Integer.MAX_VALUE);
			try{
				BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
				br.readLine();
				System.out.println(25);
				
			}catch(IOException io){
				io.printStackTrace();
			}
		}
		
	
	}
// Problem: 630_A. Again Twenty Five!
// Time complexity: constant
import java.io.*;
import java.util.*;

public class Main {
	
	void solve(Scanner in, PrintWriter out) {
		long a = in.nextLong();
		out.println(25);
	}
	void run() {
		Locale.setDefault(Locale.US);
		try (
				Scanner in = new Scanner(System.in);
				PrintWriter out = new PrintWriter(System.out);
		) {
			solve(in, out);
		  }	
	}
	
	public static void main(String args[]) {
		new Main().run();
	}

}
// Problem: 630_A. Again Twenty Five!
// Time complexity: constant
import java.io.InputStream;
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.BufferedWriter;
import java.io.PrintWriter;
import java.io.Writer;
import java.io.OutputStream;
import java.io.OutputStreamWriter;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Alex
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }
    static class TaskA {
        public void solve(int testNumber, InputReader in, OutputWriter out) {
            out.printLine(25);
        }

    }

    static class InputReader {
        private InputStream stream;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void close() {
            writer.close();
        }

        public void printLine(int i) {
            writer.println(i);
        }

    }
}
// Problem: 630_A. Again Twenty Five!
// Time complexity: constant
import java.io.IOException;

/**
 * Created by ww on 13.02.2016.
 */
public class rgb {


    public static void main(String[] args) throws IOException {
        System.out.print(25);
        return ;

    }
}
// Problem: 630_A. Again Twenty Five!
// Time complexity: constant
/*
     * Code Author: Akshay Miterani
     * DA-IICT
     */
    import java.io.*;
    import java.util.*;
    
     
    public class MainY {
     
    	static double eps=(double)1e-6;
    	static long mod=(int)1e9+7;
    	static boolean f=true;
    	public static void main(String args[]){
    		InputReader in = new InputReader(System.in);
    		OutputStream outputStream = System.out;
    		PrintWriter out = new PrintWriter(outputStream);
    		//----------My Code Starts Here----------
    		long n=in.nextLong();
    		if(n==1){
    			System.out.println("5");
    		}
    		else{
    			System.out.println("25");
    		}
    		out.close();
    		//---------------The End------------------
    	}
    	
    	static class Pair implements Comparable<Pair>{
    		int r1=-1;
    		int r2=-1;
    		int extra=0;
			@Override
			public int compareTo(Pair arg0) {
				// TODO Auto-generated method stub
				return 0;
			}
    	}
    	
    	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.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.util.*;


public class Main {

    private static void solve() throws IOException {
        long n = nextLong();
        out.println(25);
    }

    public static void main(String[] args) throws Exception {
        File file = new File("System.in");
        InputStream input = System.in;
        PrintStream output = System.out;
        if (file.exists() && file.canRead()) {
            input = new FileInputStream(file);
            output = new PrintStream("System.out");
        }
        br = new BufferedReader(new InputStreamReader(input));
        out = new PrintWriter(output);
        solve();
        out.close();
    }

    private static BufferedReader br;
    private static StringTokenizer st;
    private static PrintWriter out;

    private static boolean hasNextToken() throws IOException {
        while (st == null || !st.hasMoreTokens()) {
            String line = br.readLine();
            if (line == null) {
                return false;
            }
            st = new StringTokenizer(line);
        }
        return true;
    }

    private static String nextToken() throws IOException {
        return hasNextToken() ? st.nextToken() : null;
    }

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

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

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

}
// 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 A {
	static void solve(InputReader in, PrintWriter out) {
		long n = in.nextLong();
		out.print(25);
	}

	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);

		solve(in, out);

		out.close();
	}

	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 long nextLong() {
			return Long.parseLong(next());
		}

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

	}
}
// Problem: 630_A. Again Twenty Five!
// Time complexity: constant
import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;

public class main {
    public static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    public static PrintWriter pw = new PrintWriter(System.out);
    public static String line;
    public static StringTokenizer st;
    public static ArrayList<ArrayList<Integer>> adjList;

    public static void main(String[] args) throws Exception{
        String s = br.readLine();
        pw.print(25);
        pw.print("\n");
        pw.close();
        br.close();
    }
}
// Problem: 630_A. Again Twenty Five!
// Time complexity: constant

import java.util.Scanner;

/**
 * Feb 18, 2016 | 4:00:49 PM
 * <pre>
 * <u>Description</u>
 *
 * </pre>
 *
 * @author Essiennta Emmanuel (colourfulemmanuel@gmail.com)
 */
public class ProblemA{
    
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        sc.next();
        System.out.println(25);
        sc.close();
    }
}
// Problem: 630_A. Again Twenty Five!
// Time complexity: constant
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author ATailouloute
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        QuickScanner in = new QuickScanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA {
        public void solve(int testNumber, QuickScanner in, PrintWriter out) {
            long n = in.nextLong();
            out.println(IntegerUtils.pow(5L, n, 100));
        }

    }

    static class QuickScanner {
        BufferedReader br;
        StringTokenizer st;
        InputStream is;

        public QuickScanner(InputStream stream) {
            is = stream;
            br = new BufferedReader(new InputStreamReader(stream), 32768);
        }

        String nextToken() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return st.nextToken();
        }

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

    }

    static class IntegerUtils {
        public static long pow(long a, long base, long mod) {
            if (base == 0) return 1;
            if (base == 1) return a;
            if ((base & 1) == 1)
                return (a * pow(a, base - 1, mod)) % mod;
            return pow((a * a) % mod, base / 2, mod);
        }

    }
}
// Problem: 630_A. Again Twenty Five!
// Time complexity: constant
import java.util.*;
public class AgainTwentyfive {
	public static void main(String[] args)
	{
		System.out.println("25");
	}
}
// Problem: 630_A. Again Twenty Five!
// Time complexity: constant
/* package whatever; // don't place package name! */

import java.util.*;
;

/* Name of the class has to be "Main" only if the class is public. */
public class Main
{
	public static void main (String[] args) throws java.lang.Exception
	{
		// your code goes here
		Scanner s = new Scanner(System.in);
		long n = s.nextLong();
		System.out.println(25);
	}
}
// Problem: 630_A. Again Twenty Five!
// Time complexity: constant
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Egor Kulikov (egor@egork.net)
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA {
        public void solve(int testNumber, InputReader in, OutputWriter out) {
            out.printLine(25);
        }

    }

    static class InputReader {
        private InputStream stream;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void close() {
            writer.close();
        }

        public void printLine(int i) {
            writer.println(i);
        }

    }
}
// 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.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.StringTokenizer;

public class LuxuriousHouses {
	
	
	public static void main(String[] args) throws IOException {
		System.out.println(25);
		

		
	}
	
	static class Scanner {
		StringTokenizer st;
		BufferedReader br;

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

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

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

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

		public String nextLine() throws IOException {
			return br.readLine();
		}

		public boolean ready() throws IOException {
			return br.ready();
		}

	}
}
// Problem: 630_A. Again Twenty Five!
// Time complexity: constant
import java.io.*;
public class again_25 {
	public static void main(String ar[])throws IOException
	{
		long n;
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		n=Long.parseLong(br.readLine());
		System.out.println("25");
	}
}
// Problem: 630_A. Again Twenty Five!
// Time complexity: constant
import java.util.Scanner;

public class CF630_A {

    public static void main(String[] args) {
        try (Scanner s = new Scanner(System.in)) {
            long n = s.nextLong();

            System.out.println("25");
        }
    }
}
// Problem: 630_A. Again Twenty Five!
// Time complexity: constant

/**
 *
 * @author Mohammad Hadi
 */
public class A630 {
    public static void main(String[] args) {
        System.out.println(25);
    }
}
// Problem: 630_A. Again Twenty Five!
// Time complexity: constant
import java.util.*;
public class Contests {

	public static void main(String[] args) {
		Scanner clavier=new Scanner(System.in);
		long a=clavier.nextLong();
		clavier.close();
		if(a==1)
			System.out.println(5);
		else
			System.out.println(25);
	}

}
// Problem: 630_A. Again Twenty Five!
// Time complexity: constant
import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

import java.util.Set;
import java.util.Map.Entry;

import java.util.HashMap;
import java.util.Iterator;

public class test {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        String num = input.nextLine();

        System.out.println("25");
    }
}
// Problem: 630_A. Again Twenty Five!
// Time complexity: constant

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

public class Main {
	
	public static void main(String args[]) {
		new Main().run();
	}
	
	void run(){
		Locale.setDefault(Locale.US);
		try(Scanner in=new Scanner(System.in);
			PrintWriter out=new PrintWriter(System.out)){
			solve(in, out);
		}
		catch (Exception e) {
			e.printStackTrace();
		}
	}

	private void solve(Scanner in, PrintWriter out) {
		String a=in.nextLine();
		out.println("25");
	}
	
}
// Problem: 630_A. Again Twenty Five!
// Time complexity: constant
import java.util.Scanner;

public class A {
	
	public static void main(String[] args){
		Scanner in = new Scanner(System.in);
		
		long n = in.nextLong();
		
		System.out.println(25);
	}

}
// Problem: 630_A. Again Twenty Five!
// Time complexity: constant


public class pregunta1 {

	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.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class A {

	
	public static void main(String[] args) {
		System.out.println(25);
	}
}
// Problem: 630_A. Again Twenty Five!
// Time complexity: constant
import java.io. *;
import java.util. *;
 
public class Main  {
	
	
	
    void solve(Scanner in, PrintWriter out) {
        out.println(25);
        
    }
    void run() {
        Locale.setDefault(Locale.US);
        try (
                Scanner in = new Scanner(System.in);
                PrintWriter out = new PrintWriter(System.out);
        )
        {
            solve(in, out);
        }
         
    }
     
    public static void main(String args[]) {
     
        new Main().run();
    }
}
// Problem: 630_A. Again Twenty Five!
// Time complexity: constant
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collections;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;

public class Main 
{
	static ArrayList<Integer> Unique(ArrayList<Integer> x)
	{
		TreeSet<Integer> tmp=new TreeSet<Integer>();
		tmp.addAll(x);
		x.clear();
		x.addAll(tmp);
		return x;
	}
	public static void main(String[] args) 
	{
		InputReader in = new InputReader();
//		Scanner in=new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		while(in.hasNext())
		{
			long n=in.nextLong();
			out.println("25");
		}
		out.close();
	}
}

class node
{
	ArrayList<Integer> v=new ArrayList<Integer>();
	node(){}
	void push(Integer a)
	{
		v.add(a);
	}
}

class InputReader 
{
	BufferedReader buf;
	StringTokenizer tok;
	InputReader() 
	{
		buf = new BufferedReader(new InputStreamReader(System.in));
	}

	boolean hasNext() 
	{
		while (tok == null || !tok.hasMoreElements()) 
		{
			try 
			{
				tok = new StringTokenizer(buf.readLine());
			} 
			catch (Exception e) 
			{
				return false;
			}
		}
		return true;
	}

	String next() 
	{
		if (hasNext())
			return tok.nextToken();
		return null;
	}

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

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

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

	BigInteger nextBigInteger() 
	{
		return new BigInteger(next());
	}

	BigDecimal nextBigDecimal() 
	{
		return new BigDecimal(next());
	}
}
// Problem: 630_A. Again Twenty Five!
// Time complexity: constant
import java.util.Scanner;

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.PrintWriter;
import java.util.Scanner;
  
public class Main {
    Scanner in;
    PrintWriter out;
      
    void solve() {
    	out.print("25");
    }

      
    void run() {

            in = new Scanner(System.in);
            out = new PrintWriter(System.out);      

            solve();

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