One day Greg and his friends were walking in the forest. Overall there were n people walking, including Greg. Soon he found himself in front of a river. The guys immediately decided to get across the river. Luckily, there was a boat by the river bank, just where the guys were standing. We know that the boat can hold people with the total weight of at most k kilograms.Greg immediately took a piece of paper and listed there the weights of all people in his group (including himself). It turned out that each person weights either 50 or 100 kilograms. Now Greg wants to know what minimum number of times the boat needs to cross the river to transport the whole group to the other bank. The boat needs at least one person to navigate it from one bank to the other. As the boat crosses the river, it can have any non-zero number of passengers as long as their total weight doesn't exceed k.Also Greg is wondering, how many ways there are to transport everybody to the other side in the minimum number of boat rides. Two ways are considered distinct if during some ride they have distinct sets of people on the boat.Help Greg with this problem.

The first line contains two integers n, k (1 ≤ n ≤ 50, 1 ≤ k ≤ 5000) — the number of people, including Greg, and the boat's weight limit. The next line contains n integers — the people's weights. A person's weight is either 50 kilos or 100 kilos. You can consider Greg and his friends indexed in some way.

In the first line print an integer — the minimum number of rides. If transporting everyone to the other bank is impossible, print an integer -1. In the second line print the remainder after dividing the number of ways to transport the people in the minimum number of rides by number 1000000007 (109 + 7). If transporting everyone to the other bank is impossible, print integer 0.

NoteIn the first test Greg walks alone and consequently, he needs only one ride across the river.In the second test you should follow the plan:  transport two 50 kg. people;  transport one 50 kg. person back;  transport one 100 kg. person;  transport one 50 kg. person back;  transport two 50 kg. people. That totals to 5 rides. Depending on which person to choose at step 2, we can get two distinct ways.

using System;

public sealed class Program {

  const Int64 Mod = 1000000007;

  static void Add(ref Int64 cur, Int64 add) {
    cur = (cur + add) % Mod;
  }

  public Program () {
    Int32[] token = ReadArray();
    Int32 n = token[0], cap = token[1], i, cnt50 = 0, cnt100 = 0, a, b, c, d;
    token = ReadArray();
    Array.Sort(token);
    if (cap < 50 || cap < token[n - 1] || n != 1 && cap < token[0] + token[1]) {
      Console.WriteLine(-1);
      Console.WriteLine('0');
      return;
    }
    foreach (Int32 body in token) {
      if (body == 50) {
        ++cnt50;
      } else {
        ++cnt100;
      }
    }
    Int64[,] binomial = new Int64[n + 1, n + 1];
    for (i = 0; i <= n; ++i) {
      binomial[i, 0] = binomial[i, i] = 1;
    }
    for (a = 2; a <= n; ++a) {
      for (b = 1; b < a; ++b) {
        binomial[a, b] = (binomial[a - 1, b] + binomial[a - 1, b - 1]) % Mod;
      }
    }
    Int64[, ,] dp = new Int64[2, cnt50 + 1, cnt100 + 1];
    dp[0, cnt50, cnt100] = 1;
    for (i = 0; ; ++i) {
      if (i % 2 != 0 && dp[i % 2, cnt50, cnt100] != 0) {
        Console.WriteLine(i);
        Console.WriteLine(dp[i % 2, cnt50, cnt100]);
        return;
      }
      for (a = 0; a <= cnt50; ++a) {
        for (b = 0; b <= cnt100; ++b) {
          if (dp[i % 2, a, b] != 0) {
            for (c = 0; c <= a; ++c) {
              for (d = 0; d <= b && c * 50 + d * 100 <= cap; ++d) {
                if (c + d != 0) {
                  Add(ref dp[1 - i % 2, cnt50 - (a - c), cnt100 - (b - d)], dp[i % 2, a, b] * binomial[a, c] % Mod * binomial[b, d] % Mod);
                }
              }
            }
          }
        }
      }
    }
  }

  // stuff cutline

  public static void Main() {
#if DEBUG
    Console.SetIn(new System.IO.StreamReader("..\\..\\in.txt"));
#endif
    var root = new Program();
    Console.Out.Flush();
  }

  static Int32 ReadInt() {
    Boolean neg = false;
    Int32 ch, ans = 0;
    do {
      ch = Console.Read();
      neg |= ch == (Int32)'-';
    } while (!Char.IsDigit((Char)ch));
    do {
      ans = ans * 10 + (ch & 0xf);
      ch = Console.Read();
    } while (Char.IsDigit((Char)ch));
    return neg ? -ans : ans;
  }

  static Int32[] ReadArray() {
    return Array.ConvertAll<String, Int32>(Console.ReadLine().Split(), Int32.Parse);
  }

}

using System;

public sealed class Program {

  const Int64 Mod = 1000000007;

  static void Add(ref Int64 cur, Int64 add) {
    cur = (cur + add) % Mod;
  }

  public Program () {
    Int32 n = ReadInt(), cap = ReadInt(), i, cnt50 = 0, cnt100 = 0, a, b, c, d;
    for (i = 0; i < n; ++i) {
      if (ReadInt() == 50) {
        ++cnt50;
      } else {
        ++cnt100;
      }
    }
    Int64[,] binomial = new Int64[n + 1, n + 1];
    for (i = 0; i <= n; ++i) {
      binomial[i, 0] = binomial[i, i] = 1;
    }
    for (a = 2; a <= n; ++a) {
      for (b = 1; b < a; ++b) {
        binomial[a, b] = (binomial[a - 1, b] + binomial[a - 1, b - 1]) % Mod;
      }
    }
    Int64[, ,] dp = new Int64[n * 2 + 1, cnt50 + 1, cnt100 + 1];
    dp[0, cnt50, cnt100] = 1;
    for (i = 0; ; ++i) {
      if (i == n * 2) {
        Console.WriteLine(-1);
        Console.WriteLine('0');
        break;
      } else if (i % 2 != 0 && dp[i, cnt50, cnt100] != 0) {
        Console.WriteLine(i);
        Console.WriteLine(dp[i, cnt50, cnt100]);
        break;
      }
      for (a = 0; a <= cnt50; ++a) {
        for (b = 0; b <= cnt100; ++b) {
          if (dp[i, a, b] != 0) {
            for (c = 0; c <= a; ++c) {
              for (d = 0; d <= b && c * 50 + d * 100 <= cap; ++d) {
                if (c + d != 0) {
                  Add(ref dp[i + 1, cnt50 - (a - c), cnt100 - (b - d)], dp[i, a, b] * binomial[a, c] % Mod * binomial[b, d] % Mod);
                }
              }
            }
          }
        }
      }
    }
  }

  // stuff cutline

  public static void Main() {
#if DEBUG
    Console.SetIn(new System.IO.StreamReader("..\\..\\in.txt"));
#endif
    var root = new Program();
    Console.Out.Flush();
  }

  static Int32 ReadInt() {
    Boolean neg = false;
    Int32 ch, ans = 0;
    do {
      ch = Console.Read();
      neg |= ch == (Int32)'-';
    } while (!Char.IsDigit((Char)ch));
    do {
      ans = ans * 10 + (ch & 0xf);
      ch = Console.Read();
    } while (Char.IsDigit((Char)ch));
    return neg ? -ans : ans;
  }

  static Int32[] ReadArray() {
    return Array.ConvertAll<String, Int32>(Console.ReadLine().Split(), Int32.Parse);
  }

}


The HR manager was disappointed again. The last applicant failed the interview the same way as 24 previous ones. "Do I give such a hard task?" — the HR manager thought. "Just raise number 5 to the power of n and get last two digits of the number. Yes, of course, n can be rather big, and one cannot find the power using a calculator, but we need people who are able to think, not just follow the instructions."Could you pass the interview in the machine vision company in IT City?

The only line of the input contains a single integer n (2 ≤ n ≤ 2·1018) — the power in which you need to raise number 5.

Output the last two digits of 5n without spaces between them.

using System;

namespace A
{
    class Program
    {
        static void Main(string[] args)
        {
            ulong a = UInt64.Parse(Console.ReadLine());
            Console.Write("25");
        }
    }
}

using System;

namespace ConsoleApplication1
{
	class Program
	{
		static void Main(string[] args)
		{
			Console.WriteLine(25);
		}
	}
}

using System;

namespace CSharp
{
    public class _630A
    {
        public static void Main(string[] args)
        {
            string n = Console.ReadLine();
            Console.WriteLine(25);
        }
    }
}

using System;
using System.IO;
using System.Text;

namespace Again_Twenty_Five
{
    internal class Program
    {
        private static readonly StreamReader reader = new StreamReader(Console.OpenStandardInput(1024*10), Encoding.ASCII, false, 1024*10);
        private static readonly StreamWriter writer = new StreamWriter(Console.OpenStandardOutput(1024*10), Encoding.ASCII, 1024*10);

        private static void Main(string[] args)
        {
            writer.WriteLine("25");
            writer.Flush();
        }
    }
}

using System;

class A630 {
    public static void Main() {
        Console.WriteLine(25);
    }
}

using System;
using System.Linq;

namespace tren
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.ReadLine();
            Console.Write(25);
        }
    }
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Text
{
    class Program
    {
        static void Main(string[] args)
        {
                string read = Console.ReadLine();
                Console.WriteLine(25);

        }

    }
}

using System;

namespace Sample
{
      class Test{

         public static void Main(string[] args){

         Console.Write(25);
            }
     }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Globalization;
namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            string s = Console.ReadLine();
            Console.WriteLine(25);
        }
    }
}

using static System.Console;class a{static void Main(){ReadLine();WriteLine("25");}}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp61
{
    class Program
    {
        static void Main(string[] args)
        {
            long n = long.Parse(Console.ReadLine());
            Console.WriteLine(25);
        }
    }
}

using System;
using System.Collections.Generic;
using System.IO;

namespace prA {
    class Program {
#if ONLINE_JUDGE
        private static readonly StreamReader reader = new StreamReader(Console.OpenStandardInput(1024 * 10), System.Text.Encoding.ASCII, false, 1024 * 10);
        private static readonly StreamWriter writer = new StreamWriter(Console.OpenStandardOutput(1024 * 10), System.Text.Encoding.ASCII, 1024 * 10);
#else
        private static readonly StreamWriter writer = new StreamWriter(@"..\..\output");
        private static readonly StreamReader reader = new StreamReader(@"..\..\input");
#endif

        static void Main(string[] args) {
            writer.Write(25);
            writer.Flush();
#if !ONLINE_JUDGE
            writer.Close();
#endif
        }
        private static long Next() {
            int c;
            long res = 0;
            do {
                c = reader.Read();
                if(c == -1)
                    return res;
            } while(c != '-' && (c < '0' || c > '9'));
            long sign = 1;
            if(c == '-') {
                sign = -1;
                c = reader.Read();
            }
            res = c - '0';
            while(true) {
                c = reader.Read();
                if(c < '0' || c > '9')
                    return res * sign;
                res *= 10;
                res += c - '0';
            }
        }
    }
}

using System;
namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            var n = Console.ReadLine();

            Console.WriteLine(25);
        }
    }
}

/*
 * Created by SharpDevelop.
 * User: tagirov2
 * Date: 20.02.2016
 * Time: 09:56
 *

 */

using System;

class Program
{
	public static void Main(string[] args)
	{
		Int64 n = Int64.Parse (Console.ReadLine ());
		Console.WriteLine ("25");
	}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Again_Twenty_Five_
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.ReadLine();
            Console.WriteLine("25");
        }
    }
}

using System;
namespace _630A
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                string i = Console.ReadLine();
                Console.Write("25");
                Console.ReadKey();
            }
            catch
            {

            }
        }
    }
}

using static System.Console;class a{static void Main(){ReadLine();WriteLine(25);}}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _630A_Again_Twenty_Five_
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine(25.ToString());
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication3
{
    class Program
    {
        static void Main(string[] args)
        {
        int r;
           string xx;
           long n;
            xxx:
            string x;
            n=long.Parse(Console.ReadLine());
            if(n<2||n>(Math.Pow(10,18)*2))
            {
                goto xxx;
            }
            x = (Math.Pow(5, n)).ToString();

            r = x.Length;
            xx = x.Substring(r-2, 2);
            Console.WriteLine(25);

        }
    }
}

using System;

namespace CodeForces
{
    class Program
    {
        static void Main(string[] args)
        {
            long n = long.Parse(Console.ReadLine());
            Console.WriteLine("25");
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Experimental_Educational_Round
{
    class Program
    {
        static void Main(string[] args)
        {
            ulong n = ulong.Parse(Console.ReadLine());
            Console.WriteLine(25);

        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;

namespace Solution
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("25");
        }
    }
}

using System;

namespace A._Опять_двадцать_пять_
{
    class Program
    {
        static void Main(string[] args)
        {
            string trash = Console.ReadLine();
            Console.WriteLine("25");
        }
    }
}

using System;
using System.Collections.Generic;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
           Console.WriteLine("25");
        }
    }
}

using System;
using System.Numerics;
class MainClass {
  public static void Main (string[] args) {
    BigInteger  n =BigInteger.Parse(Console.ReadLine());
    Console.WriteLine("25");
  }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            string s = Console.ReadLine();
            Console.WriteLine(25);
            //Console.ReadLine();
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            string n = Console.ReadLine();
            Console.Write("25");
        }
    }
}

using System;

class A630 {
    public static void Main() {
        Console.WriteLine(25);
    }
}

        using System;
        using System.Collections.Generic;
        using System.Globalization;
        using System.Linq;
        using System.Text;
        using System.Threading;
        using System.Threading.Tasks;

        namespace Training_App
        {
            class Program
            {

        static void Main(string[] args)
        {
            String input = Console.ReadLine();

            Console.WriteLine(25);

        }

        public static ulong calculateFactorial(ulong n)
        {

            ulong result = 1;
            for (ulong i = 1; i <= n; i++)
            {
                result *= i;
            }
            return result;
        }

        public static ulong calculateGCD(ulong a , ulong b)
        {
            ulong reminder = 0;
            while(b!=0)
            {
                reminder = a%b;
                a = b;
                b = reminder;
            }

            return a;
        }

    }

            }

using System;

namespace ConsoleApp27
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine(25);
        }
    }
}

using System;

public class Program
{
	public static void Main()
	{
		double res = 25;
		double n = double.Parse(Console.ReadLine());
		double d = Math.Pow(5, n);
		if(n<100000000000000000){
			res = d % 100;
		}
		Console.WriteLine(res);
	}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Task1
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = Console.Read();

            Console.Write(25);
        }
    }
}

using System;

public class Class
{
    static int Main()
    {
        string n = Console.ReadLine();
        if(n == "1")
        {
            Console.WriteLine("5");
        }
        else
        {
            Console.WriteLine("25");
        }
        return 0;
    }
}

using System;

public class AgainTwentyFive630A
{
    public static void Main(String[] args)
    {
        Console.ReadLine();
        Console.WriteLine("25");
    }
}

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;

namespace AlgoHelper
{
    public class Pair
    {
        public int X { get; set; }
        public int Y { get; set; }

        public Pair(int x, int y)
        {
            X = x;
            Y = y;
        }

        public override bool Equals(object obj)
        {
            var pair = obj as Pair;
            return X + Y == pair.X + pair.Y;
        }

        public override int GetHashCode()
        {
            var hashCode = 1861411795;
            hashCode = hashCode * -1521134295 + X.GetHashCode();
            hashCode = hashCode * -1521134295 + Y.GetHashCode();
            return hashCode;
        }

        public override string ToString()
        {
            return $"X = {X} Y = {Y}";
        }
    }

    class Program
    {
        static void Main(string[] args)
        {

            string s = Console.ReadLine();
            Console.WriteLine(25);

         //   Console.ReadKey();
        }

        private static long max(long[] a, int l)
        {
            long max = long.MinValue;

            for (int i = 0; i < a.Length; i++)
            {
                if (i != l)
                {
                    max = Math.Max(a[i], max);
                }
            }

            return max;
        }

        private static long min(long[] a, int l)
        {
            long min = long.MaxValue;

            for (int i = 0; i < a.Length; i++)
            {
                if (i != l)
                {
                    min = Math.Min(a[i], min);
                }
            }

            return min;
        }

        static int anagram(string s)
        {
            int length = s.Length;

            if (length % 2 != 0) return -1;

            string firstPart = s.Substring(0, length / 2);
            string secondPart = s.Substring(length / 2);

            int[] firstFreq = frequency(firstPart);
            int[] secondFreq = frequency(secondPart);

            int count = 0;

            for (int i = 0; i < firstFreq.Length; i++)
            {
                if (firstFreq[i] != secondFreq[i]) count += Math.Abs(secondFreq[i] - firstFreq[i]);
            }

            return count / 2;
        }

        public static int NumDecodings(string s)
        {
            if (s.Length == 1) return 1;
            if (s.Length == 2)
            {
                int number = int.Parse(s);

                if (number <= 26)
                {
                    if (s.Contains("0")) return 1;
                    return 2;
                }

                return 0;
            }

            return NumDecodings(s.Substring(0, 1)) + NumDecodings(s.Substring(1));
        }

        static int makingAnagrams(string s1, string s2)
        {
            int length = s1.Length + s2.Length;

            int[] freqA = frequency(s1);
            int[] freqB = frequency(s2);

            Console.WriteLine(string.Join("|", freqA));
            Console.WriteLine(string.Join("|", freqB));

            int count = 0;

            for (int i = 0; i < freqA.Length; i++)
            {
                if (freqA[i] != freqB[i]) count++;
            }

            return length - count;
        }
        public static int firstMissingPositive(int[] a)
        {
            int missing = 1;

            HashSet<int> set = new HashSet<int>();

            for (int i = 0; i < a.Length; i++)
            {
                if (a[i] > missing)
                {
                    set.Add(a[i]);
                }
                else if (a[i] == missing)
                {
                    if (!set.Contains(missing + 1))
                    {
                        missing++;
                    }
                    else
                    {
                        missing = returnNewMax(++missing, set);
                    }
                }
            }

            return missing;
        }

        private static int returnNewMax(int n, HashSet<int> set)
        {
            while (set.Contains(n))
            {
                n++;
            }

            return n;
        }

        private static bool checkForAllZeroes(string s)
        {
            foreach (char c in s)
            {
                if (c != '0') return false;
            }

            return true;
        }

        private static int getHigherNumber(int n, int max)
        {
            int currentLength = maxLength(n);

            if (currentLength < max)
            {
                int diff = max - currentLength;
                int newNumber = n * (int)Math.Pow(10, diff);
                return newNumber;
            }

            return n;
        }

        private static int maxLength(int n)
        {
            return n.ToString().Length;
        }

        static int gemstones(string[] arr)
        {
            int[][] frequencies = new int[arr.Length][];

            for (int i = 0; i < frequencies.Length; i++)
            {
                frequencies[i] = frequency(arr[i]);
            }

            int count = 0;
            bool flag = true;

            for (int i = 0; i < frequencies[0].Length; i++) //26
            {
                for (int j = 0; j < frequencies.Length - 1; j++)
                {
                    if (frequencies[j][i] == 0 || frequencies[j + 1][i] == 0)
                    {
                        flag = false;
                        break;
                    }
                }

                if (flag) count++;
                flag = true;
            }

            return count;
        }

        private static bool isPalindrome(int[] a)
        {
            for (int i = 0; i < a.Length / 2; i++)
            {
                if (a[i] != a[a.Length - 1 - i]) return false;
            }

            return true;
        }

        private static bool hasSubstring(string a, string b)
        {
            int[] freqA = frequency(a);
            int[] freqB = frequency(b);

            for (int i = 0; i < freqA.Length; i++)
            {
                if (freqA[i] != 0 && freqA[i] == freqB[i]) return true;
            }

            return false;
        }

        private static int LowerBound(int[] a, int target)
        {
            int lo = 0;
            int hi = a.Length - 1;
            int ans = -1;

            while (lo <= hi)
            {
                int med = hi - (hi - lo) / 2;

                if (target == a[med])
                {
                    ans = med;
                    hi = med - 1;
                }
                else if (target > a[med])
                {
                    lo = med + 1;
                }

                else hi = med - 1;
            }

            return ans;
        }

        private static int[] frequency(string s)
        {
            int[] a = new int[26];

            foreach (char c in s)
            {
                a[c - 'a']++;
            }

            return a;
        }

        public static int max(int[] a, int i)
        {
            if (i == a.Length - 1) return a[a.Length - 1];
            return Math.Max(a[i], max(a, i + 1));
        }

        private static bool isPrime(int n)
        {
            if (n < 2) return false;

            for (int i = 2; i * i <= n; i++)
            {
                if (n % i == 0) return false;
            }

            return true;
        }

        private static void Swap(ref char a, ref char b)
        {
            char temp = a;
            a = b;
            b = temp;
        }
    }
}

using System;
namespace codeforces
{

    class Program
    {
        static void Main(string[] args)
        {
            double n = double.Parse(Console.ReadLine());
            Console.WriteLine(25);

        }
    }
}

using System;

namespace A
{
	class MainClass
	{
		public static void Main (string[] args)
		{
			Console.ReadLine();
			Console.WriteLine("25");
		}
	}
}

using System;
using System.Globalization;

namespace Codeforces
{
    internal static class Program
    {
        private static void Main()
        {
            var n = long.Parse(Console.ReadLine());

            var result = 25;

            Console.WriteLine(result);
        }

        private static string ToString(double d)
        {
            return d.ToString(CultureInfo.InvariantCulture);
        }

        private static string Right(string s, int n)
        {
            return s.Length < n ? s : s.Substring(s.Length - n);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace A.Again_Twenty_Five_
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.ReadLine();
            Console.WriteLine(25);

        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Numerics;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp2
{
	class Program
	{
		static void Main(string[] args)
		{
			try
			{

				var number = int.Parse(Console.ReadLine());
				var result = Math.Pow(5, number);
				var resultStr = result.ToString();

				Console.WriteLine(resultStr.Length > 2 ? resultStr.Substring(resultStr.Length - 2) : resultStr);
			}
			catch (Exception e)
			{
				Console.WriteLine(25);
			}
		}
	}
}

using System;
using System.Collections.Generic;
using System.Linq;

namespace sample
{
    class Program
    {
        static void Main(string[] args)
        {
            string input = Console.ReadLine();
            Console.WriteLine(25);
        }

    }
}

using System;

namespace A._Опять_двадцать_пять_
{
    class Program
    {
        static void Main(string[] args)
        {
            string trash = Console.ReadLine();
            Console.WriteLine("25");
        }
    }
}

using System;

namespace _630
{
    class Program
    {
        static void Main()
        {
           Console.WriteLine(25);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Numerics;
using E = System.Linq.Enumerable;

namespace Prob01 {
    class Program {
        protected IOHelper io;

        public Program(string inputFile, string outputFile) {
            io = new IOHelper(inputFile, outputFile, Encoding.Default);

            io.WriteLine(25);

            io.Dispose();
        }

        static void Main(string[] args) {
            Program myProgram = new Program(null, null);
        }
    }

    class IOHelper : IDisposable {
        public StreamReader reader;
        public StreamWriter writer;

        public IOHelper(string inputFile, string outputFile, Encoding encoding) {
            if (inputFile == null)
                reader = new StreamReader(Console.OpenStandardInput(), encoding);
            else
                reader = new StreamReader(inputFile, encoding);

            if (outputFile == null)
                writer = new StreamWriter(Console.OpenStandardOutput(), encoding);
            else
                writer = new StreamWriter(outputFile, false, encoding);

            curLine = new string[] { };
            curTokenIdx = 0;
        }

        string[] curLine;
        int curTokenIdx;

        char[] whiteSpaces = new char[] { ' ', '\t', '\r', '\n' };

        public bool hasNext() {
            if (curTokenIdx >= curLine.Length) {
                //Read next line
                string line = reader.ReadLine();
                if (line != null)
                    curLine = line.Split(whiteSpaces, StringSplitOptions.RemoveEmptyEntries);
                else
                    curLine = new string[] { };
                curTokenIdx = 0;
            }

            return curTokenIdx < curLine.Length;
        }

        public string NextToken() {
            return hasNext() ? curLine[curTokenIdx++] : null;
        }

        public int NextInt() {
            return int.Parse(NextToken());
        }

        public double NextDouble() {
            string tkn = NextToken();
            return double.Parse(tkn, System.Globalization.CultureInfo.InvariantCulture);
        }

        public void Write(double val, int precision) {
            writer.Write(val.ToString("F" + precision, System.Globalization.CultureInfo.InvariantCulture));
        }

        public void Write(object stringToWrite) {
            writer.Write(stringToWrite);
        }

        public void WriteLine(double val, int precision) {
            writer.WriteLine(val.ToString("F" + precision, System.Globalization.CultureInfo.InvariantCulture));
        }

        public void WriteLine(object stringToWrite) {
            writer.WriteLine(stringToWrite);
        }

        public void Dispose() {
            try {
                if (reader != null) {
                    reader.Dispose();
                }
                if (writer != null) {
                    writer.Flush();
                    writer.Dispose();
                }
            } catch { };
        }

        public void Flush() {
            if (writer != null) {
                writer.Flush();
            }
        }
    }
}

using System;

class Program_630A
{
    private static void Main()
    {
        Console.ReadLine();

        Console.WriteLine(25);
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Text.RegularExpressions;

class PairVariable:IComparable<PairVariable>
{
    public int a, b;
    public PairVariable()
    {
        a = b = 0;
    }
    public PairVariable(string s)
    {
        string[] q = s.Split();
        a = int.Parse(q[0]);
        b = int.Parse(q[1]);
    }
    public PairVariable(int a, int b)
    {
        this.a = a;
        this.b = b;
    }
    public int CompareTo(PairVariable pv)
    {
        if (this.a > pv.a)
        {
            return 1;
        }
        else if (this.a < pv.a)
        {
            return -1;
        }
        else
        {
            if (this.b >= pv.b)
            {
                return 1;
            }
            else
            {
                return -1;
            }
        }
    }

}
namespace ConsoleApplication252
{

    class Program
    {

        static bool P(int n)
        {
            for (int i = 2; i <= Math.Sqrt(n); i++)
            {
                if (n % i == 0)
                {
                    return false;
                }
            }
            return true;
        }

        static void Main()
        {
            string[] z = Console.ReadLine().Split();
            //int n = int.Parse(z[0]);

            /*string[] ss = Console.ReadLine().Split();
            int[] m = new int[n];
            int sum = 0;
            for (int i = 0; i < n; i++)
            {
                m[i] = int.Parse(ss[i]);
            }
            Array.Sort(m);
            for (int i = 0; i < n; i++)
            {
                for (int e = 0; e < n; e++)
                {
                    if (i != e)
                    {
                        if (m[i] == m[e])
                        {
                            m[e]++;
                            sum++;
                        }
                    }
                }
            }*/
            Console.WriteLine(25);

        }
    }
}

using System;
class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("25");
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;

namespace ConsoleApplication5
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine(25);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication4
{
    class Program
    {
        static void Main(string[] args)
        {
             Int64 n;
            n =Convert.ToInt64( Console.ReadLine());
            Console.WriteLine("25");
        }
    }
}

using System;
class Program {
    public static void Main(string[] args) {
        Console.ReadLine();
        Console.WriteLine(25);
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.ReadLine();
            Console.WriteLine(25);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication29
{
    class Program
    {

        static void Main(string[] args)
        {
            long n = long.Parse(Console.ReadLine());
            Console.Write(25);

        }
    }
}

using System;
class Demo
{
    static void Main()
    {
        Console.ReadLine();
        Console.WriteLine(25);
    }
}

using System;
using System.Collections.Generic;
using System.IO.Pipes;
using System.Linq;
using System.Text;

namespace codeforces
{
	class Program
	{
		public class User
		{
			public int c;

			public int r;
		}

		public class Point
		{
			public int x;

			public int y;
		}

		public class Comparer : IComparer<User>
		{
			public int Compare(User x, User y)
			{
				if (x.c < y.c || (x.c == y.c && x.r < y.r))
					return -1;
				return 1;
			}
		}

		public static long getGcd(long a, long b)
		{
			if (b == 0)
				return a;
			return getGcd(b, a % b);
		}

		public static void WriteYESNO(bool x, string yes = "YES", string no = "NO")
		{
			if (x)
				Console.WriteLine(yes);
			else
			{
				Console.WriteLine(no);
			}
		}

		public static string GetString()
		{
			return Console.ReadLine();
		}

		public static List<int> getList()
		{
			var s = Console.ReadLine();
			return s.Split(' ').Select(int.Parse).ToList();
		}

		public static int Min(int x, int y)
		{
			return Math.Min(x, y);
		}

		public static int Max(int x, int y)
		{
			return Math.Max(x, y);
		}

		public static int Abs(int x)
		{
			return Math.Abs(x);
		}

		public static int getInt()
		{
			var s = Console.ReadLine();
			return int.Parse(s);
		}

		public static bool Equal(int x, int y, int x1, int y1)
		{
			return x == x1 && y == y1;
		}

		public class Vertex
		{
			public List<int> edges;

			public int ct;

			public Vertex()
			{
				ct = 0;
				edges = new List<int>();
				for (var i = 0; i < 26; ++i)
					edges.Add(0);
			}
		}

		private static void Main(string[] args)
		{
/*			var input = new StreamReader("input.txt");
			var output = new StreamWriter("output.txt");*/

			Console.WriteLine(25);
			/*			input.Close();
			output.Close();*/
		}
	}
}

using System;

namespace _A
{
	class MainClass
	{
		public static void Main (string[] args)
		{
			Console.ReadLine ();
			Console.WriteLine ("25");
			Console.ReadLine ();
		}
	}
}

using System;

namespace _630
{
    class Program
    {
        static void Main()
        {
           Console.WriteLine(25);
        }
    }
}

using System;
using System.IO;
using System.Collections.Generic;
using System.Numerics;

namespace helveic2019
{
    class Program
    {
        static void Main(string[] args)
        {
            //Console.SetIn(new StreamReader("input.txt"));
            //solve_helvetic2019A();
            solve_volbitA();
        }

        public static void solve_volbitC()
        {
            int n = Convert.ToInt32(Console.ReadLine());

            BigInteger res = new BigInteger();

            for (int i = 1; i <= n; i++)
            {
                res += BigInteger.Pow(2, i);
            }

            Console.WriteLine(res);
        }

        public static void solve_volbitA()
        {
            long n = Convert.ToInt64(Console.ReadLine());

            int res = 25;

            Console.WriteLine(res);
        }

        public static void solve_helvetic2019A()
        {
            string[] sb = Console.ReadLine().Split(' ');
            int s = Convert.ToInt32(sb[0]);
            int b = Convert.ToInt32(sb[1]);

            string[] a = Console.ReadLine().Split(' ');
            int[] ships = Array.ConvertAll(a, int.Parse);
            Dictionary<int, int> dp = new Dictionary<int, int>();
            List<KeyValuePair<int, int>> bases = new List<KeyValuePair<int, int>>();

            for (int i = 0; i < b; i++)
            {
                string[] dg = Console.ReadLine().Split(' ');
                int d = Convert.ToInt32(dg[0]);
                int g = Convert.ToInt32(dg[1]);
                bases.Add(new KeyValuePair<int, int>(d, g));
            }
            Array.Sort(ships);
            bases.Sort((x, y) => x.Key.CompareTo(y.Key));

        }
    }
}

using System;

namespace ConsoleApplication1
{
	class Program
	{
		static void Main(string[] args)
		{
			Console.WriteLine(25);
		}
	}
}

using System;
using System.Linq;
using static System.Console;
namespace test
{
    class Program
    {
        private static int[] numbers;
        static void Main()
        {
            WriteLine(25);
        }
        public static void reader()
        {
            numbers = Console
                .ReadLine()
                .Split(new Char[] {' '}, StringSplitOptions.RemoveEmptyEntries)
                .Select(item => int.Parse(item))
                .ToArray();
        }

    }
}

using System;
using System.IO;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Reflection;
using System.Threading;
using System.Diagnostics;
using System.Linq;
using System.Globalization;

class Solution
{
    public TextInput cin;
    public TextOutput cout;
    public TextOutput cerr;
    public void Solve()
    {
        cout.WriteLine("25");
    }
}

#region Core
static class Program
{
    public static readonly TextInput cin = new TextInput(Console.In);
    public static readonly TextOutput cout = new TextOutput(Console.Out);
    public static readonly TextOutput cerr = new TextOutput(Console.Error);
#if !DEBUG
    static void Main()
    {
        new Solution
        {
            cin = cin,
            cout = cout,
            cerr = cerr
        }.Solve();
    }
#endif
}
public class SDictionary<TKey, TValue> : Dictionary<TKey, TValue>
{
    public new TValue this[TKey key]
    {
        get
        {
            TValue res;
            base.TryGetValue(key, out res);
            return res;
        }
        set
        {
            base[key] = value;
        }
    }
}
public static class Ext
{

    #region Prewriten
    public static void Foreach<T>(this IEnumerable<T> elements, Action<T> action)
    {
        foreach(var element in elements)
        {
            action(element);
        }
    }
    public static void Foreach<T>(this IEnumerable<T> elements, Action<T, int> action)
    {
        var index = 0;
        foreach(var element in elements)
        {
            action(element, index++);
        }
    }
    public static void Do(int from, int n, Action<int> action)
    {
        for (var i = from; i < n; i++) action(i);
    }
    public static IEnumerable<T> Init<T>(int n) where T : new()
    {
        for (var i = 0; i < n; i++)
        {
            yield return new T();
        }
    }
    public static IEnumerable<T> Init<T>(int n, T defaultValue = default(T))
    {
        for (var i = 0; i < n; i++)
        {
            yield return defaultValue;
        }
    }
    public static IEnumerable<T> Init<T>(int n, Func<int, T> builder)
    {
        for (var i = 0; i < n; i++)
        {
            yield return builder(i);
        }
    }
    public static bool IsEmpty(this string s)
    {
        return string.IsNullOrEmpty(s);
    }
    public static string Safe(this string s)
    {
        return s.IsEmpty() ? string.Empty : s;
    }
    public static void Swap<T>(ref T a, ref T b)
    {
        T c = a;
        a = b;
        b = c;
    }
    public static long Gcd(long a, long b)
    {
        while (a > 0)
        {
            b %= a;
            Swap(ref a, ref b);
        }
        return b;
    }
    public static int[] ZFunction(string s)
    {
        var z = new int[s.Length];
        for (int i = 1, l = 0, r = 0; i < s.Length; ++i)
        {
            if (i <= r)
            {
                z[i] = Math.Min(r - i + 1, z[i - l]);
            }
            while (i + z[i] < s.Length && s[z[i]] == s[i + z[i]])
            {
                z[i]++;
            }
            if (i + z[i] - 1 > r)
            {
                l = i;
                r = i + z[i] - 1;
            }
        }
        return z;
    }
    public static long Pow(long a, long p)
    {
        var b = 1L;
        while (p > 0)
        {
            if ((p & 1) == 0)
            {
                a *= a;
                p >>= 1;
            }
            else
            {
                b *= a;
                p--;
            }
        }
        return b;
    }
    #endregion
}

public delegate bool TryParseDelegate<T>(string s, NumberStyles style, IFormatProvider format, out T value);
public class TextInput
{
    private static Dictionary<Type, Delegate> primitiveParsers = new Dictionary<Type, Delegate>
        {
            { typeof(sbyte), new TryParseDelegate<sbyte>(sbyte.TryParse) },
            { typeof(short), new TryParseDelegate<short>(short.TryParse) },
            { typeof(int),  new TryParseDelegate<int>(int.TryParse) },
            { typeof(long), new TryParseDelegate<long>(long.TryParse) },

            { typeof(byte), new TryParseDelegate<byte>(byte.TryParse) },
            { typeof(ushort), new TryParseDelegate<ushort>(ushort.TryParse) },
            { typeof(uint), new TryParseDelegate<uint>(uint.TryParse) },
            { typeof(ulong), new TryParseDelegate<ulong>(ulong.TryParse) },

            { typeof(float), new TryParseDelegate<float>(float.TryParse) },
            { typeof(double), new TryParseDelegate<double>(double.TryParse) },
            { typeof(decimal), new TryParseDelegate<decimal>(decimal.TryParse) },

            { typeof(char), new TryParseDelegate<char>(CharParser) },
            { typeof(string), new TryParseDelegate<string>(StringParser) }
        };
    private static bool CharParser(string s, NumberStyles style, IFormatProvider format, out char res)
    {
        res = char.MinValue;
        if (string.IsNullOrEmpty(s))
        {
            return false;
        }
        else
        {
            res = s[0];
            return true;
        }
    }
    private static bool StringParser(string s, NumberStyles style, IFormatProvider format, out string res)
    {
        res = s == null ? string.Empty : s;
        return true;
    }

    private string line = null;
    private int pos = 0;

    public IFormatProvider FormatProvider { get; set; }
    public NumberStyles NumberStyle { get; set; }
    public TextReader TextReader { get; set; }

    public TextInput(string path) : this(path, NumberStyles.Any, CultureInfo.InvariantCulture)
    {
    }
    public TextInput(string path, NumberStyles numberStyle, IFormatProvider formatProvider) : this(new StreamReader(path), numberStyle, formatProvider)
    {

    }
    public TextInput(TextReader textReader) : this(textReader, NumberStyles.Any, CultureInfo.InvariantCulture)
    {

    }
    public TextInput(TextReader textReader, NumberStyles numberStyle, IFormatProvider formatProvider)
    {
        TextReader = textReader;
        NumberStyle = numberStyle;
        FormatProvider = formatProvider;
    }

    public bool IsEof
    {
        get
        {
            return line == null && TextReader.Peek() == -1;
        }
    }
    public void SkipWhiteSpace()
    {
        while (!IsEof)
        {
            if (line != null && pos < line.Length && !char.IsWhiteSpace(line[pos]))
            {
                return;
            }
            if (line == null || pos >= line.Length)
            {
                Next();
                continue;
            }
            while (pos < line.Length && char.IsWhiteSpace(line[pos]))
            {
                pos++;
            }
        }
    }
    private void SkipWhiteSpace(bool force)
    {
        if (force)
        {
            SkipWhiteSpace();
        }
        else
        {
            SkipWhiteSpace();
        }
    }

    public T[] ReadArray<T>()
    {
        var length = Read<int>();
        return ReadArray<T>(length);
    }
    public T[] ReadArray<T>(int length)
    {
        var array = new T[length];

        var parser = GetParser<T>();
        var style = NumberStyle;
        var format = FormatProvider;

        for (var i = 0; i < length; i++)
        {
            array[i] = Read<T>(parser, style, format);
        }
        return array;
    }

    public bool TryReadArray<T>(out T[] array)
    {
        return TryReadArray<T>(GetParser<T>(), NumberStyle, FormatProvider, out array);
    }
    public bool TryReadArray<T>(out T[] array, int length)
    {
        return TryReadArray<T>(GetParser<T>(), NumberStyle, FormatProvider, out array, length);
    }
    public bool TryReadArray<T>(T[] array, int offset, int length)
    {
        return TryReadArray<T>(GetParser<T>(), NumberStyle, FormatProvider, array, offset, length);
    }
    public bool TryReadArray<T>(TryParseDelegate<T> parser, NumberStyles style, IFormatProvider format, out T[] array)
    {
        var length = 0;
        if (!TryRead<int>(out length))
        {
            array = null;
            return false;
        }
        array = new T[length];
        return TryReadArray<T>(parser, style, format, array, 0, length);
    }
    public bool TryReadArray<T>(TryParseDelegate<T> parser, NumberStyles style, IFormatProvider format, out T[] array, int length)
    {
        array = new T[length];
        return TryReadArray<T>(parser, style, format, array, 0, length);
    }
    public bool TryReadArray<T>(TryParseDelegate<T> parser, NumberStyles style, IFormatProvider format, T[] array, int offset, int length)
    {
        var result = true;
        for (var i = 0; i < length && result; i++)
        {
            result &= TryRead<T>(parser, style, format, out array[offset + i]);
        }
        return result;
    }

    private TryParseDelegate<T> GetParser<T>()
    {
        var type = typeof(T);
        return (TryParseDelegate<T>)primitiveParsers[type];
    }
    public T Read<T>()
    {
        return Read<T>(GetParser<T>());
    }
    public T Read<T>(NumberStyles style, IFormatProvider format)
    {
        return Read<T>(GetParser<T>(), style, format);
    }
    public T Read<T>(TryParseDelegate<T> parser)
    {
        return Read<T>(parser, NumberStyle, FormatProvider);
    }
    public T Read<T>(TryParseDelegate<T> parser, NumberStyles style, IFormatProvider format)
    {
        T result;
        if (!TryRead(parser, style, format, out result))
        {
            throw new FormatException();
        }
        return result;
    }
    public bool TryRead<T>(out T value)
    {
        return TryRead(GetParser<T>(), out value);
    }
    public bool TryRead<T>(NumberStyles style, IFormatProvider format, out T value)
    {
        return TryRead(GetParser<T>(), style, format, out value);
    }
    public bool TryRead<T>(TryParseDelegate<T> parser, out T value)
    {
        return parser(ReadToken(), NumberStyle, FormatProvider, out value);
    }
    public bool TryRead<T>(TryParseDelegate<T> parser, NumberStyles style, IFormatProvider format, out T value)
    {
        return parser(ReadToken(), style, format, out value);
    }
    public string ReadToken()
    {
        SkipWhiteSpace(false);
        if (IsEof)
        {
            throw new EndOfStreamException();
        }

        if (pos >= line.Length || char.IsWhiteSpace(line[pos])) return string.Empty;

        var start = pos;
        while (pos < line.Length && !char.IsWhiteSpace(line[pos]))
        {
            pos++;
        }
        return line.Substring(start, pos - start);
    }
    public string ReadLine()
    {
        if (IsEof)
        {
            throw new EndOfStreamException();
        }
        if (line == null || pos >= line.Length)
        {
            Next();
        }

        var ans = line.Substring(pos);
        pos = line.Length;
        return ans;
    }

    private void Next()
    {
        line = TextReader.ReadLine();
        pos = 0;
    }
}

public class TextOutput
{
    public IFormatProvider FormatProvider { get; set; }
    public TextWriter TextWriter { get; set; }

    public TextOutput(string path) : this(path, CultureInfo.InvariantCulture)
    {
    }
    public TextOutput(string path, IFormatProvider formatProvider) : this(new StreamWriter(path), formatProvider)
    {

    }
    public TextOutput(TextWriter textWriter) : this(textWriter, CultureInfo.InvariantCulture)
    {

    }
    public TextOutput(TextWriter textWriter, IFormatProvider formatProvider)
    {
        TextWriter = textWriter;
        FormatProvider = formatProvider;
    }

    public TextOutput WriteArray<T>(params T[] array)
    {
        return WriteArray(array, true);
    }
    public TextOutput WriteArray<T>(T[] array, bool appendLine)
    {
        return WriteArray(array, 0, array.Length, appendLine);
    }
    public TextOutput WriteArray<T>(T[] array, int offset, int length, bool appendLine = true)
    {
        var sb = new StringBuilder();
        for (var i = 0; i < length; i++)
        {
            sb.Append(Convert.ToString(array[offset + i], FormatProvider));
            if (i + 1 < length)
            {
                sb.Append(' ');
            }
        }
        return appendLine ? WriteLine(sb.ToString()) : Write(sb.ToString());
    }

    public TextOutput WriteLine(object obj)
    {
        return WriteLine(Convert.ToString(obj, FormatProvider));
    }
    public TextOutput WriteLine(string text, params object[] args)
    {
        return WriteLine(string.Format(FormatProvider, text, args));
    }
    public TextOutput WriteLine(string text)
    {
        TextWriter.WriteLine(text);
        return this;
    }
    public TextOutput WriteLine(char[] buffer)
    {
        TextWriter.WriteLine(buffer);
        return this;
    }
    public TextOutput WriteLine(char[] buffer, int offset, int length)
    {
        TextWriter.WriteLine(buffer, offset, length);
        return this;
    }
    public TextOutput WriteLine()
    {
        TextWriter.WriteLine();
        return this;
    }

    public TextOutput Write(object obj)
    {
        return Write(Convert.ToString(obj, FormatProvider));
    }
    public TextOutput Write(string text, params object[] args)
    {
        return Write(string.Format(FormatProvider, text, args));
    }
    public TextOutput Write(string text)
    {
        TextWriter.Write(text);
        return this;
    }
    public TextOutput Write(char[] buffer)
    {
        TextWriter.Write(buffer);
        return this;
    }
    public TextOutput Write(char[] buffer, int offset, int length)
    {
        TextWriter.Write(buffer, offset, length);
        return this;
    }
}
#endregion

using System;
using System.Numerics;
class MainClass {
  public static void Main (string[] args) {
    BigInteger  n =BigInteger.Parse(Console.ReadLine());
    Console.WriteLine("25");
  }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace TwentyFive
{
    class Program
    {
        static void Main(string[] args)
        {
            string s = Console.ReadLine();
            Console.Write(25);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using static System.Console;

public class Program
{
    private static void Main()
    {
        ReadLine();
        WriteLine(25);

    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CodeForces1
{
    class Program
    {
        static void Main(string[] args)
        {
            long i;
            i=long.Parse(Console.ReadLine());
            Console.WriteLine(25);
        }
    }
}

using System;

namespace _630A
{
    class Program
    {
        static void Main(string[] args)
        {
            string str = Console.ReadLine();
            Console.WriteLine(25);
        }
    }
}

using System;

namespace Codeforces
{
    internal static class Program
    {
        private static void Main()
        {
            Console.ReadLine();
            Console.WriteLine(25);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Problem_Solving
{
    class Program
    {

        static void Main(string[] args)
        {
           Console.ReadLine();
            Console.WriteLine(25);
        }

    }

}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("");
            int num = Convert.ToInt32(Console.ReadLine());
            if (num >= 2) {
                Console.WriteLine("25");
            }
            else
                return;
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("");
            Console.WriteLine("25");
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("");
            String str = Console.ReadLine();
            int num = Convert.ToInt32(str);
            while (num < 2)
            {
                Console.WriteLine("");
                str = Console.ReadLine();
                num = Convert.ToInt32(str);
            }
            String powNumberStr = Convert.ToInt32(Math.Pow(5,num)).ToString().Trim();
            String result = powNumberStr.Substring(powNumberStr.Length - 2, 2);
            Console.WriteLine("{0}", result);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("");
            int num = Convert.ToInt32(Console.ReadLine().Trim());
            if (num >= 2) {
                Console.WriteLine("25");
            }
            else
                return;
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("");
            String str = Console.ReadLine();
            long num = Convert.ToInt32(str);
            while (num < 2)
            {
                Console.WriteLine("");
                str = Console.ReadLine();
                num = Convert.ToInt32(str);
            }
            String powNumberStr = Convert.ToInt32(Math.Pow(5,num)).ToString();
            String result = powNumberStr.Substring(powNumberStr.Length - 2, 2);
            Console.WriteLine("{0}", result);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("");
            int num = Convert.ToInt32(Console.ReadLine().Trim());
            if (num >= 2 && num <= int.MaxValue) {
                Console.WriteLine("25");
            }
            else
                return;
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("");
            String str = Console.ReadLine();
            int num = Convert.ToInt32(str);
            String powNumberStr = Convert.ToInt32(Math.Pow(5,num)).ToString();
            String result = powNumberStr.Substring(powNumberStr.Length - 2, 2);
            Console.WriteLine("{0}", result);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("");
            String str = Console.ReadLine();
            int num = Convert.ToInt32(str);
            while (num < 2)
            {
                Console.WriteLine("");
                str = Console.ReadLine();
                num = Convert.ToInt32(str);
            }
            Console.WriteLine("25");
        }
    }
}

using System;
namespace _630A
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                int n = int.Parse(Console.ReadLine());
                if (n == 0)
                {
                    Console.Write("1");
                }
                else if (n > 1)
                    Console.Write("25");
                else
                    Console.Write("5");
                Console.ReadKey();
            }
            catch
            {

            }
        }
    }
}

using System;
namespace _630A
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                long n = int.Parse(Console.ReadLine());
                Console.Write(5*5);
                Console.ReadKey();
            }
            catch
            {

            }
        }
    }
}

using System;
namespace _630A
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                long n = int.Parse(Console.ReadLine());
                if (n == 0)
                {
                    Console.Write("1");
                }
                else if (n > 1)
                    Console.Write("25");
                else
                    Console.Write("5");
                Console.ReadKey();
            }
            catch
            {

            }
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication3
{
    class Program
    {
        static void Main(string[] args)
        {
          int r;
           string xx;
            Double n;
            xxx:
            string x;
            n=Double.Parse(Console.ReadLine());
            if(n<2||n>(Math.Pow(10,18)*2))
            {
                goto xxx;
            }
            x = (Math.Pow(5, n)).ToString();

            r = x.Length;
            xx = x.Substring(r-2, 2);
            Console.WriteLine(xx);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp2
{
	class Program
	{
		static void Main(string[] args)
		{
			var number = int.Parse(Console.ReadLine());

			Console.WriteLine(Math.Pow(5, number));
		}
	}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Numerics;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp2
{
	class Program
	{
		static void Main(string[] args)
		{
			try
			{

				var number = int.Parse(Console.ReadLine());
				var result = Math.Pow(5, number);
				var resultStr = result.ToString();

				Console.WriteLine(resultStr.Length > 2 ? resultStr.Substring(resultStr.Length - 2) : resultStr);
			}
			catch (Exception e)
			{

			}
		}
	}
}

using System;

class MainClass {
  public static void Main (string[] args) {
    long n = long.Parse(Console.ReadLine());
    string k = Math.Pow(5 , n).ToString();
    string num1 =k[k.Length- 1].ToString();
    string num2 =k[k.Length- 2].ToString();
    Console.WriteLine(num2+num1);
  }
}

using System;
using System.IO;
using System.Collections.Generic;
using System.Numerics;

namespace helveic2019
{
    class Program
    {
        static void Main(string[] args)
        {
            //Console.SetIn(new StreamReader("input.txt"));
            //solve_helvetic2019A();
            solve_volbitA();
        }

        public static void solve_volbitC()
        {
            int n = Convert.ToInt32(Console.ReadLine());

            BigInteger res = new BigInteger();

            for (int i = 1; i <= n; i++)
            {
                res += BigInteger.Pow(2, i);
            }

            Console.WriteLine(res);
        }

        public static void solve_volbitA()
        {
            long n = Convert.ToInt32(Console.ReadLine());

            int res = 1;
            if (n > 1)
            {
                res = 2;
            }

            Console.WriteLine(res);
        }

        public static void solve_helvetic2019A()
        {
            string[] sb = Console.ReadLine().Split(' ');
            int s = Convert.ToInt32(sb[0]);
            int b = Convert.ToInt32(sb[1]);

            string[] a = Console.ReadLine().Split(' ');
            int[] ships = Array.ConvertAll(a, int.Parse);
            Dictionary<int, int> dp = new Dictionary<int, int>();
            List<KeyValuePair<int, int>> bases = new List<KeyValuePair<int, int>>();

            for (int i = 0; i < b; i++)
            {
                string[] dg = Console.ReadLine().Split(' ');
                int d = Convert.ToInt32(dg[0]);
                int g = Convert.ToInt32(dg[1]);
                bases.Add(new KeyValuePair<int, int>(d, g));
            }
            Array.Sort(ships);
            bases.Sort((x, y) => x.Key.CompareTo(y.Key));

        }
    }
}

using System;

namespace ConsoleApp27
{
    class Program
    {
        static void Main(string[] args)
        {
            UInt64 a = (UInt64 )Math.Pow(5,UInt64.Parse(Console.ReadLine()));
            Console.WriteLine( a / 10 % 10 + "" + a % 10);
        }
    }
}

using System;

public class Program
{
	public static void Main()
	{
		var n = Convert.ToInt64(Console.ReadLine());
		var d = Math.Pow(5, n);
		var res = d % 100;
		Console.WriteLine(res);
	}
}

using System;

public class Program
{
	public static void Main()
	{
		double res = 25;
		double n = double.Parse(Console.ReadLine());
		double d = Math.Pow(5, n);
		if(n!=1000000000000000000){
			res = d % 100;
		}
		Console.WriteLine(res);
	}
}

using System;

public class Program
{
	public static void Main()
	{
		int n = Convert.ToInt32(Console.ReadLine());
		int ans = 0;
		for(int i=1; i<n; i++){
			ans += (5 * 5);
		}
		Console.WriteLine(ans);
	}
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;

class TEST{
	static void Main(){
		Sol mySol =new Sol();
		mySol.Solve();
	}
}

class Sol{
	public void Solve(){
		long N=rl();
		long ret=1;
		long x=5;
		while(N>0){
			if((N&1)==1){
				ret*=x;
				ret%=100;
			}
			x*=x;
			N>>=1;
		}
		Console.WriteLine(ret);

	}

	public Sol(){

	}

	static String rs(){return Console.ReadLine();}
	static int ri(){return int.Parse(Console.ReadLine());}
	static long rl(){return long.Parse(Console.ReadLine());}
	static double rd(){return double.Parse(Console.ReadLine());}
	static String[] rsa(char sep=' '){return Console.ReadLine().Split(sep);}
	static int[] ria(char sep=' '){return Array.ConvertAll(Console.ReadLine().Split(sep),e=>int.Parse(e));}
	static long[] rla(char sep=' '){return Array.ConvertAll(Console.ReadLine().Split(sep),e=>long.Parse(e));}
	static double[] rda(char sep=' '){return Array.ConvertAll(Console.ReadLine().Split(sep),e=>double.Parse(e));}
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;

class TEST{
	static void Main(){
		Sol mySol =new Sol();
		mySol.Solve();
	}
}

class Sol{
	public void Solve(){
		long N=rl();
		long ret=1;
		long x=5;
		while(N>0){
			if((N&1)==1){
				ret*=x;
				ret%=100;
			}
			x*=x;
			N>>=1;
		}
		Console.WriteLine("{0:D02}",ret);

	}

	public Sol(){

	}

	static String rs(){return Console.ReadLine();}
	static int ri(){return int.Parse(Console.ReadLine());}
	static long rl(){return long.Parse(Console.ReadLine());}
	static double rd(){return double.Parse(Console.ReadLine());}
	static String[] rsa(char sep=' '){return Console.ReadLine().Split(sep);}
	static int[] ria(char sep=' '){return Array.ConvertAll(Console.ReadLine().Split(sep),e=>int.Parse(e));}
	static long[] rla(char sep=' '){return Array.ConvertAll(Console.ReadLine().Split(sep),e=>long.Parse(e));}
	static double[] rda(char sep=' '){return Array.ConvertAll(Console.ReadLine().Split(sep),e=>double.Parse(e));}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication10
{
    class Program
    {
        static void Main(string[] args)
        {
         // string[] ar=  Console.ReadLine().Split(' ');
            Console.WriteLine(Math.Pow(5,Int64.Parse(Console.ReadLine())));
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace A.Again_Twenty_Five_
{
    class Program
    {
        static void Main(string[] args)
        {
            int x = int.Parse(Console.ReadLine());
            Console.WriteLine(Math.Pow(5,x));
        }
    }
}

using System;

namespace ConsoleApp
{
    class Program
    {
        static void Main()
        {
            int x1 = Convert.ToInt32(Console.ReadLine());

            Console.WriteLine(Math.Pow(5, x1));

        }
    }
}