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);
  }

}


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();
		Console.WriteLine(25);

	}

	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;

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;

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

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 static System.Console;class a{static void Main(){ReadLine();WriteLine("25");}}

using static System.Console;class a{static void Main(){ReadLine();WriteLine(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;
using System.Collections.Generic;
using System.Linq;
using static System.Console;

public class Program
{
    private static void Main()
    {
        ReadLine();
        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.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;
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;
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;

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 ConsoleApplication4
{
    class Program
    {
        static void Main(string[] args)
        {
             Int64 n;
            n =Convert.ToInt64( 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);

        }
    }
}

/*
 * 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;
using System.Globalization;
namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            string s = Console.ReadLine();
            Console.WriteLine(25);
        }
    }
}

using System;

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

using System;
namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            var n = 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 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;
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;

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.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;
        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;
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;

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

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

using System;

namespace ConsoleApplication1
{
	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;
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;
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.Linq;

namespace tren
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.ReadLine();
            Console.Write(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 A.Again_Twenty_Five_
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.ReadLine();
            Console.WriteLine(25);

        }
    }
}

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;

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.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 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.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;
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;
class Program
{
    static void Main(string[] args)
    {
        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.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;

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;
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;
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;
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.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.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;

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

using System;
namespace codeforces
{

    class Program
    {
        static void Main(string[] args)
        {
            double n = double.Parse(Console.ReadLine());
            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.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 CSharp
{
    public class _630A
    {
        public static void Main(string[] args)
        {
            string n = Console.ReadLine();
            Console.WriteLine(25);
        }
    }
}

using System;

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

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;
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)
        {
            ulong a = UInt64.Parse(Console.ReadLine());
            Console.Write("25");
        }
    }
}

using System;

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

using System;

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

using System;

namespace A
{
	class MainClass
	{
		public static void Main (string[] args)
		{
			Console.ReadLine();
			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.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));

        }
    }
}