namespace o
{
    using System;

    class Program
    {
        static void Main(string[] args)
        {
            int n = int.Parse(Console.ReadLine());
            int[,] arr = new int[n, n];
            for (int i = 0; i < n; i++)
            {
                for (int j = 0; j < n; j++)
                {
                    if (j == 0 || i == 0)
                    {
                        arr[i, j] = 1;
                    }
                    else
                    {
                        arr[i, j] = arr[i - 1, j] + arr[i, j - 1];
                    }
                }
            }
            Console.WriteLine(arr[n - 1, n - 1]);
        }
    }
}

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

namespace ConsoleApp4
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = int.Parse(Console.ReadLine());
            int[,] array = new int[n, n];
            for(int i = 0; i < n; i++)
            {
                array[0, i] = 1;
                array[i, 0] = 1;
            }
            for(int i = 1; i < n; i++)
            {
                for(int a = 1; a < n; a++)
                {
                    array[i, a] = array[i, a - 1] + array[i - 1, a];
                }
            }
            Console.WriteLine(array[n - 1, n - 1]);
            Console.ReadLine();

        }
    }
}

using System;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = Int32.Parse(Console.ReadLine());
            int[,] z = new int[n,n];
            for (int i = 0; i < n; i++)
            {
                for (int j = 0; j < n; j++)
                {
                    if (i==0 || j==0)
                    {
                        z[i,j] = 1;
                    }
                    else
                    {
                        z[i,j] = z[i - 1,j] + z[i,j - 1];
                    }

                }
            }

            Console.WriteLine(z[n - 1,n - 1]);

        }
    }
}

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

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

            var upper = new int[n];
            var lower = new int[n];

            for(int i=0;i<n;i++)
            {
                upper[i] = lower[i] = 1;
            }

            for (int i = 1; i < n; i++)
            {
                if (i % 2 != 0)//upper
                {
                    for (int j = 0; j < n-1; j++)
                    {
                        lower[j + 1] = lower[j] + upper[j + 1];
                    }
                }
                else
                {
                    for (int j = 0; j < n - 1; j++)
                    {
                        upper[j + 1] = upper[j] + lower[j + 1];
                    }
                }
            }
            Console.WriteLine((n % 2 != 0) ? upper[n - 1] : lower[n - 1]);
        }
    }
}

using System;
using System.Linq;
public class Program
{

    public static void Main()
    {
		int[,] arr = new int[10,10];
		int a = int.Parse(Console.ReadLine());
		for (int i = 0; i < a; i++) {
			for (int j = 0; j < a; j++) {
				if (i == 0) {
					arr[i,j] = 1;
				} else if (j == 0) {
					arr[i,j] = 1;
				} else {
					arr[i,j] = arr[i - 1,j] + arr[i,j - 1];
				}
			}
		}
		Console.WriteLine(arr[a - 1,a - 1]);
    }
}

using System;
using System.Linq;

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

             var n = int.Parse(Console.ReadLine());
            var arr = new int[n * n];
            for (int i = 0; i < n; i++)
            {
                arr[i] = 1;
            }
            for (int i = n; i < arr.Length; i += n)
            {
                arr[i] = 1;
            }

            for (int i = n + 1; i < arr.Length; ++i)
            {
                if (arr[i] != 1)
                {
                    arr[i] = arr[i - 1] + arr[i - n];
                }
            }

            Console.WriteLine(arr.Last());
        }

    }
}

using System;

namespace zadanie
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = Convert.ToInt32(Console.ReadLine());

            int[,] res = new int[n,n];

            for (int i = 0 ;i<n;i++)
            {
                res[i, 0] = 1;
                res[0, i] = 1;
            }

            for (int i = 1;i<n;i++)
            {
                for(int j = 1;j<n;j++)
                {
                    res[i, j] = res[i, j - 1] + res[i - 1, j];
                }
            }
            Console.WriteLine(res[n-1, n-1]);

        }

    }
}

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

class Solution
{
    static void Main(string[] args)
    {
        int n = Convert.ToInt32(Console.ReadLine());
        int[,] arr = new int[n,n];
        int maxval = 1;
        if (n == 1) Console.Write(maxval);
        else
        {
            for(int i=0;i<n;i++)
            {
                for(int j=0;j<n;j++)
                {
                    if (i == 0 || j == 0) arr[i, j] = 1;
                    else arr[i, j] = arr[i - 1, j] + arr[i, j - 1];
                    if (arr[i, j] > maxval) maxval = arr[i, j];
                }
            }
            Console.Write(maxval);
        }
    }
}

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

namespace CodeForcesProblems
{
    class A509_MaximumInTable
    {
        public static void Main()
        {
            //while(true)
            //{
                var n = int.Parse(Console.ReadLine());
                var table = new int[n,n];
                // table = 0;
               // table[0] ={ {1,1,1,1,1 }, }
                for (int i = 0; i < n; i++)
                    table[0,i] = 1;

                for (int i = 0; i < n; i++)
                    table[i,0] = 1;

                for(int i =1;i<n;i++)
                {
                    for (int j = 1; j < n; j++)
                        table[i, j] = table[i-1,j] + table[i,j-1];

                }
                Console.WriteLine(table[n-1,n-1]);
          //  }
        }
    }
}

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

namespace ProjectEuler
{
    class Program
    {
        static void Main(string[] args)
        {
            int length = Convert.ToInt32(Console.ReadLine());
            int[,] array = new int[length, length];

                for (int k = 0; k < length; k++)
                {
                    array[0, k] = 1;
                    array[k, 0] = 1;

                }

            for (int i = 1; i < length; i++)
            {
                for (int j = 1; j < length; j++)
                {

                    array[i, j] = array[i - 1, j] + array[i, j - 1];
                }
            }
            Console.WriteLine(array[length - 1, length - 1]);
        }
    }
}

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

namespace Testerka
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = Convert.ToInt32(Console.ReadLine());
            int[,] a = new int[n, n];
            for (int i = 0; i < n; i++)
            {
                a[i, 0] = 1;
                a[0, i] = 1;
            }
            for (int i = 1; i < n; i++)
            {
                for (int j = 1; j < n; j++)
                {
                    a[i, j] = a[i, j - 1] + a[i - 1, j];
                }
            }
            Console.WriteLine(a[n - 1, n - 1]);
        }

    }
}

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

namespace Problema_MAXIMO_NA_TABELA
{
    class Program
    {
        static void Main(string[] args)
        {
            int n, m = 0;

            n = int.Parse(Console.ReadLine());

            int[,] Matriz = new int[n,n];

            //Matriz para "setar" os valores na primeira linha e primeiras counas
            for(int x=0;x< n;x++)
            {
                for(int y=0;y< n;y++)
                {
                    Matriz[x, 0] = 1;
                    Matriz[0, y] = 1;
                }
            }

            //Matriz pa
            for (int i = 1; i < n; i++)
            {
                for (int j = 1; j < n; j++)
                {
                    Matriz[i, j] = Matriz[i - 1, j] + Matriz[i, j - 1];
                }
            }

            for (int a = 0; a < n; a++)
            {
                for (int b = 0; b < n; b++)
                {

                    m = Matriz[a, b];
                }

            }
            Console.WriteLine(m);

        }
    }
}

using System;
using System.Collections.Generic;

namespace Code
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = int.Parse(Console.ReadLine());
            int[,] arr = new int[n, n];
            int max = int.MinValue;

            for (int i = 0; i < n; i++)
            {
                for (int j = 0; j < n; j++)
                {
                    if (i == 0 || j == 0)
                    {
                        arr[i, j] = 1;
                    }
                    else
                    {
                        arr[i, j] = arr[i - 1, j] + arr[i, j - 1];
                    }
                    if (max < arr[i, j]) max = arr[i, j];
                }
            }
            Console.WriteLine(max);
        }
    }
}

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

namespace CodeForseProblems
{
    class Program
    {
        static void Main(string[] args)
        {
            //string input = Console.ReadLine();
            int n = Int32.Parse(Console.ReadLine());
            int[] table = new int[n * n];
            int row = 1;
            int above = 0, left = 1;
            for(int i = 0; i < (n*n);)
            {
                for (int x = 0; x < n; x++)
                {
                    if (row <= 1)
                    {
                        table[i] = left + above;
                    }
                    else
                        if(row > 1)
                    {
                        above = table[i - n];
                        table[i] = left + above;
                        left = table[i];
                    }
                    i++;
                }
                above = 0;
                left = 0;
                row++;
            }

            Console.WriteLine(table.Max());
        }

    }
}

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

namespace contest
{
    public class Program
    {
        static void Main(string[] args)
        {
            var n = Console.ReadLine();
            Console.WriteLine(Solve(n));
        }

        public static string Solve(string ns)
        {
            var n = int.Parse(ns);
            var table = new int[n, n];
            for (int i = 0; i < n; i++)
            {
                table[0, i] = 1;
                table[i, 0] = 1;
            }
            for (int i = 1; i < n; i++)
            {
                for (int j = 1; j < n; j++)
                {
                    table[i, j] = table[i - 1, j] + table[i, j - 1];
                }
            }
            return table[n - 1, n - 1].ToString();
        }
    }
}

using System;

namespace A
{
    class Program
    {
        static void Main()
        {
            int n = Convert.ToInt32(Console.ReadLine()), i = 0, j = 0;
            int[,] m = new int[n, n];
            for (i = 0; i < n; i++) { m[i, 0] = 1; m[0, i] = 1; }
            for (i = 1; i < n; i++)
                for (j = 1; j < n; j++) { m[i, j] = m[i - 1, j] + m[i, j - 1]; }
            if (n == 1) Console.WriteLine(1);
            else Console.WriteLine(m[i - 1, j - 1]);
        }
    }
}

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

namespace ConsoleApplication56
{
    class Program
    {
        static void Main(string[] args)
        {
            int a = Convert.ToInt32(Console.ReadLine());
            int[,] mas = new int[a, a];
            for (int i = 0; i < a; i++)
            {
                mas[0, i] = 1;
                mas[i, 0] = 1;
            }
            for (int i = 1; i < a; i++)
            {
                for (int j = 1; j < a; j++)
                {
                    mas[i, j] = mas[i - 1,j] + mas[i, j - 1];
                }
            }
            Console.WriteLine(mas[a-1,a-1]);
        }
    }
}

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

namespace BulkaProga
{
    class Program
    {
        static void Main(string[] args)
        {
            int count = int.Parse(Console.ReadLine());
            List<List<int>> table = new List<List<int>>();
            List<int> line = new List<int>();
            for (int i = 0; i < count; ++i)
            {
                line.Add(1);
            }
            table.Add(line);
            for (int i = 1; i < count; ++i)
            {
                line = new List<int>() { 1 };
                for (int j = 1; j < count; ++j)
                {
                    line.Add(table[i - 1][j] + line[j - 1]);
                }
                table.Add(line);
            }
            Console.WriteLine(table.Last().Last());
        }
    }
}

using System;

// Codeforces problem 509A "Максимум в таблице"
// http://codeforces.com/problemset/problem/509/A
namespace _509_A
{
	class Program
	{
		static void Main(string[] args)
		{
			#region Read data
			int n = Convert.ToInt32(Console.ReadLine());
			#endregion
			#region Process data
			int[,] table = new int[n, n];
			for (int i = 0; i < n; i++)
			{
				table[i, 0] = 1;
				table[0, i] = 1;
			}
			for (int i = 1; i < n; i++)
			{
				for (int j = 1; j < n; j++)
				{
					table[i, j] = table[i - 1, j] + table[i, j - 1];
				}
			}
			#endregion
			#region Write results
			Console.WriteLine(table[n - 1, n - 1]);
			Console.ReadLine();
			#endregion
		}
	}
}

using System;

namespace CSharp___Maximum_in_table
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = Convert.ToInt32(Console.ReadLine());
            int[,] table = new int[n, n];   //[row, column]
            for (int i = 0; i < n; i++)
            {
                table[0, i] = 1;
            }
            for (int i = 0; i < n; i++)
            {
                table[i, 0] = 1;
            }
            for (int row = 1; row < n; row++)
            {
                for (int col = 1; col < n; col++)
                {
                    table[row, col] = table[row, col-1]+table[row-1,col];
                }
            }
            Console.WriteLine(table[n - 1, n - 1]);
        }
    }
}

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

namespace ConsoleApplication20
{
    class Program
    {
        static void Main(string[] args)
        {
            reader = Console.In;
            writer = Console.Out;
            var init = ReadInt();

            var matrix = new int [init,init];
            int ans = 0;

            for (int i = 0; i < init; i++)
            {
                for (int j = 0; j < init; j++)
                {
                    if (i == 0 || j == 0)
                    {
                        matrix[i, j] = 1;
                    }
                    else
                        matrix[i, j] = matrix[i - 1, j] + matrix[i, j - 1];
                    ans = Math.Max(matrix[i,j],ans);
                }
            }

            Console.WriteLine(ans);
        }

        private static Queue<string> currentLineTokens = new Queue<string>();
        protected static TextReader reader;
        protected static TextWriter writer;
        private static string[] ReadAndSplitLine()
        {
            return reader.ReadLine().Split(new[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
        }

        public static string ReadToken()
        {
            if (currentLineTokens.Count == 0)
                currentLineTokens = new Queue<string>(ReadAndSplitLine());
            return currentLineTokens.Dequeue();
        }

        public static int ReadInt()
        {
            return int.Parse(ReadToken());
        }

        public static int[] ReadIntArray()
        {
            return ReadAndSplitLine().Select(int.Parse).ToArray();
        }
    }
}

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

namespace CSharpPrograms.Codeforces
{
    class _509A
    {
        static void Main()
        {
            int n = Convert.ToInt32(Console.ReadLine());
            int[,] arr = new int[n, n];
            for (int i = 0; i < n; i++)
                arr[i, 0] = arr[0, i] = 1;
            int max = 1;
            for (int i = 1; i < n; i++)
            {
                for (int j = 1; j < n; j++)
                {
                    arr[i, j] = arr[i, j - 1] + arr[i - 1, j];
                    max = Math.Max(arr[i, j], max);
                }
            }
            Console.WriteLine(max);
        }
    }
}

using System;

namespace _509A
{
    class Program
    {
        static void Main(string[] args)
        {
            var isInt = int.TryParse(Console.ReadLine(),out int tableDim);
            int[,] arr = new int[11,11];
            if (isInt)
            {
                for (int i = 1; i <= tableDim; i++)
                {
                    for (int j = 1; j <= tableDim; j++)
                    {
                        if (i == 1)
                        {
                            arr[i,j] = 1;
                        }
                        else
                        {
                            arr[i, j] = arr[i - 1, j] + arr[i, j - 1];
                        }
                    }
                }
                Console.WriteLine(arr[tableDim, tableDim]);
            }
        }
    }
}

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

namespace ConsoleApplication29
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = Convert.ToInt32(Console.ReadLine());
            int[,] a = new int[n, n];
            for (int i = 0; i < n; i++)
            {
                for (int j = 0; j < n; j++)
                {
                    a[i, 0] = 1;
                    a[0, j] = 1;
                }
            }
            for (int i = 1; i < n; i++)
            {
                for (int j = 1; j < n; j++)
                {
                    a[i, j] = a[i - 1, j] + a[i, j - 1];
                }
            } int max = int.MinValue;
            for (int i = 0; i < n; i++)
            {
                for (int j = 0; j < n; j++)
                {
                    if (a[i, j] > max) { max = a[i, j]; }
                }
            } Console.WriteLine(max);
        }
    }
}

using System;
using System.Linq;
using System.Collections;
using System.Collections.Generic;
public class Test
{

	public static void Main()
	{
		int n = Convert.ToInt32(Console.ReadLine());
		int[,] matris = new int[n, n];
		for (int i = 0; i < n; i++)
		{
			for (int j = 0; j < n; j++)
			{
				if (i == 0) matris[i, j] = 1;
				else if (j == 0) matris[i, j] = 1;
				else matris[i, j] = matris[i - 1, j] + matris[i, j - 1];
			}
		}
		Console.Write(matris[n - 1, n - 1]);
	}
}

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

namespace problem_solv
{
    class Program
    {
        static void Main(string[] args)
        {
            int num = Convert.ToInt32(Console.ReadLine());
            int[,] arr = new int[num, num];
            for(int row = 0; row < num; row++)
            {
                for(int col = 0; col < num; col++)
                {
                    if(row == 0 || col == 0)
                    {
                        arr[row, col] = 1;
                    }
                    else
                    {
                        arr[row, col] = arr[row - 1, col] + arr[row, col - 1];
                    }
                }
            }

            Console.WriteLine(arr.Cast<int>().Max());
        }
    }
}

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

namespace CodeForces_509A_Maximum_in_Table
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = int.Parse(Console.ReadLine());
            int[,] a = new int[n, n];
            for(int i=0;i<n;i++)
            {
                for(int j=0;j<n;j++)
                {
                    if(i==0||j==0)
                    {
                        a[i, j] = 1;
                    }
                    else
                    {
                        a[i, j] = a[i - 1, j] + a[i, j - 1];
                    }
                }
            }
            Console.WriteLine(a[n - 1, n - 1]);

        }
    }
}

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

namespace algorithms_700_01
{
    class Program
    {
        static void Main(string[] args)
        {
            var squareLength = int.Parse(Console.ReadLine());
            var grid = new int[squareLength, squareLength];
            for (int i = 0; i < squareLength; i++)
                for (int j = 0; j < squareLength; j++)
                    grid[i, j] = (i == 0 || j == 0) ? 1 : grid[i, j - 1] + grid[i - 1, j];
            Console.WriteLine(grid[squareLength - 1, squareLength - 1]);
        }
    }
}

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

namespace GameCF
{
    class Program
    {
        static void Main(string[] args)
        {
            string input = Console.ReadLine();
            int n = Int32.Parse(input);
            int [,] arr = new  int[n,n];
            for (int i = 0; i < n; i++) { arr[0, i] = 1; arr[i, 0] = 1; }
            for (int i = 1; i < n; i++)
            {
                for (int j = 1; j < n; j++)
                {
                    arr[i, j] = arr[i, j - 1] + arr[i - 1, j];
                }
            }
            Console.WriteLine(arr[n - 1, n - 1]);
        }
    }
}

using System;
using System.Globalization;
using System.IO.Pipes;
using System.Linq;
using System.Runtime.InteropServices;

namespace ContestV
{
    internal class Program
    {
        static void Print(string[,] m)
        {
            for (int i = 0; i < m.GetLength(0); i++)
            {
                for (int j = 0; j < m.GetLength(1); j++)
                {
                    if (m[i, j] != "#")
                    {
                        Console.Write(".");
                    }
                    else
                    {
                        Console.Write(m[i,j]);
                    }
                }
                Console.WriteLine();
            }
        }
        private static void Main(string[] args)
        {
            int n = Convert.ToInt32(Console.ReadLine());

            int[,] a = new int[n,n];

            for (int j = 0; j < n; j++)
            {
                a[0, j] = 1;
            }

            for (int i = 1; i < n; i++)
            {
                for (int j = 0; j < n; j++)
                {
                    a[i, j] = a[i - 1, j];

                    if (j - 1 > -1) a[i, j] += a[i, j - 1];
                }
            }

         Console.WriteLine(a[n-1,n-1]);
        }
    }
}

using System;

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

            int upper = n + (n-1) - 1;
            int lower = upper/2;

            long result = fact(upper)/(fact(lower)*fact(upper - lower));
            Console.WriteLine("{0}", result);
        }

        static long fact(long n)
        {
            long num = 1;
            while(n > 1)
            {
                num *= n;
                n -= 1;
            }
            return num;
        }
    }
}

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

namespace Contesa
{
    class Program
    {
        static void Main(string[] args)
        {
            int num = int.Parse(Console.ReadLine());
            int[,] matrix = new int[num, num];
            if (num > 1)
            {
                for (int i = 0; i < num; i++)
                {
                    matrix[0, i] = 1;
                    matrix[i, 0] = 1;
                }
                for (int row = 1; row < num; ++row)
                {
                    for (int col = 1; col < num; ++col)
                    {

                        matrix[row, col] = matrix[row - 1, col] + matrix[row, col - 1];
                    }
                }
                Console.WriteLine(matrix[num - 1, num - 1]);
            }
            else
                Console.WriteLine(1);

        }

    }
}

using System;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = int.Parse(Console.ReadLine());
            int[,] table = new int[n, n];

            for (int i = 0; i < n; i++)
            {
                table[0, i] = 1;
                table[i, 0] = 1;
            }

            for (int i = 1; i < n; i++)
            {
                for (int j = 1; j < n; j++)
                {
                    table[i, j] = table[i, j - 1] + table[i - 1, j];
                }
            }

            Console.WriteLine(table[n-1, n-1]);
        }
    }
}

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

namespace _509A
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = Convert.ToInt32(Console.ReadLine());

            int[,] table = new int[n, n];
            for (int i = 0; i < n; ++i)
            {
                table[0, i] = 1;
                table[i, 0] = 1;
            }

            for (int i = 1; i < n; ++i)
            {
                for (int j = 1; j < n; ++j)
                {
                    table[i, j] = table[i - 1, j] + table[i, j - 1];
                }
            }

            Console.WriteLine(table[n - 1, n - 1]);
        }
    }
}

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

namespace _509A
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = Convert.ToInt32(Console.ReadLine());
            int sum = 0;
            sum = elem(n, n);
            Console.Write(sum);
            Console.ReadLine();
        }
        static int elem(int row, int col)
        {
            if (row == 1 || col == 1)
            {
                return 1;
            }
            else
            {
                return elem(row - 1, col) + elem(row, col - 1);
            }
        }
    }
}

//#define SINGLE_PAGE
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Contest
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = Convert.ToInt32(Console.ReadLine());
            int[][] Matrix = new int[10][];
            for (int row = 0; row < 10; row++)
            {
                Matrix[row] =  new int[10];
                for (int column = 0; column < 10; column++)
                {
                    if (row == 0 || column == 0)
                        Matrix[row][column] = 1;
                    else
                    {
                        Matrix[row][column] = Matrix[row][column-1] + Matrix[row-1][column];
                    }
                }
            }

            Console.WriteLine(Matrix[n-1][n-1]);

            return ;
        }

    }

}

using System;

namespace Issue_509A
{
    class Program
    {
        public static void Main(string[] args) {
            var n = ReadInt();

            var matrix = new int[n, n];

            for (int i = 0; i < n; ++i) {
                matrix[0, i] = 1;
                matrix[i, 0] = 1;
            }

            for (int i = 1; i < n; ++i) {
                for (int j = 1; j < n; ++j) {
                    matrix[i, j] = matrix[i, j - 1] + matrix[i - 1, j];
                }
            }

            Console.WriteLine(matrix[n - 1, n - 1]);
        }

        private static bool IsInputError = false;
        private static bool IsEndOfLine = false;

        private static int ReadInt() {
            const int zeroCode = (int) '0';

            var result = 0;
            var isNegative = false;
            var symbol = Console.Read();
            IsInputError = false;
            IsEndOfLine = false;

            while (symbol == ' ') {
                symbol = Console.Read();
            }

            if (symbol == '-') {
                isNegative = true;
                symbol = Console.Read();
            }

            for ( ;
                (symbol != -1) && (symbol != ' ');
                symbol = Console.Read()
            ) {
                var digit = symbol - zeroCode;

                // if symbol == \n
                if (symbol == 13) {
                    // skip next \r symbol
                    Console.Read();
                    IsEndOfLine = true;
                    break;
                }

                if (digit < 10 && digit >= 0) {
                    var cache1 = result << 1;
                    var cache2 = cache1 << 2;
                    result = cache1 + cache2 + digit;
                } else {
                    IsInputError = true;
                    break;
                }
            }

            return isNegative ? ~result + 1 : result;
        }
    }
}

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

namespace CF_MaxTable
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = int.Parse(Console.ReadLine());
            int[,] A = new int[n, n];
            for(int i=0;i<n;i++)
            {
                for(int j=0;j<n;j++)
                {
                    if(i==0 || j==0)
                    {
                        A[i, j] = 1;
                    }
                    else
                    {
                        A[i, j] = A[i - 1, j] + A[i, j - 1];
                    }
                }
            }
            Console.WriteLine(A[n - 1, n - 1]);
        }
    }
}

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) {
            int n = Next();
            int[,] map = new int[n, n];
            for(int x = 0; x < n; x++) {
                for(int y = 0; y < n; y++) {
                    if(x == 0 || y == 0)
                        map[x, y] = 1;
                    else
                        map[x, y] = map[x - 1, y] + map[x, y - 1];
                }
            }
            writer.WriteLine(map[n - 1, n - 1]);

            writer.Flush();
#if !ONLINE_JUDGE
            writer.Close();
#endif
        }
        private static int Next() {
            int c;
            int res = 0;
            do {
                c = reader.Read();
                if(c == -1)
                    return res;
            } while(c != '-' && (c < '0' || c > '9'));
            int 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;

public class Program
{
	public static void Main()
	{
		int n = int.Parse(Console.ReadLine());
		var a = new int[n, n];
		for (int i = 0; i < n; i++)
		{
			a[0, i] = 1;
		}
		for (int i = 1; i < n; i++)
		{
			a[i, 0] = 1;
			for (int j = 1; j < n; j++)
			{
				a[i, j] = a[i - 1, j] + a[i, j - 1];
			}
		}
		Console.WriteLine(a[n - 1, n - 1]);
	}
}

using System;
using System.Linq;

namespace tren
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = int.Parse(Console.ReadLine()), index = 0;
            int[,] tab = new int[n, n];
            int[] max = new int[n * n];
            max[0] = 1;
            for (int i = 0; i < n; i++)
            {
                for(int j = 0; j < n; j++)
                {
                    if (i == 0 || j == 0) tab[i, j] = 1;
                    else {
                        tab[i, j] = tab[i - 1, j] + tab[i, j - 1];
                        max[index++] = tab[i, j];
                    }
                }
            }
            Console.Write(max.Max());
        }
    }
}

using System;

namespace ConsoleApplication1
{
    public class Program
    {
        private static void Main(string[] args)
        {
            int n = Convert.ToInt32(Console.ReadLine());
            Int32[,] table=new int[n,n];
            for (int i = 0; i < n; i++)
            {
                table[0, i] = 1;
                table[i, 0] = 1;

            }
            for (int i = 1; i < n; i++)
            {

                    for (int j = 1; j < n; j++)
                    {
                        table[i, j] = table[i, j - 1] + table[i - 1, j];

                    }

            }
            Console.WriteLine(table[n-1,n-1]);
        }
    }
}

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

namespace Problem_509A
{
    class Program
    {
        static void Main(string[] args)
        {
            int n;
            n=int.Parse(Console.ReadLine());
            int m=GetMaximumInTable(n);
            Console.WriteLine(m);

        }

        private static int GetMaximumInTable(int n)
        {
            int[,] table = new int [n,n];
            for (int j = 0; j < n; j++)
            {
                for (int i = 0; i < n; i++)
                {
                    table[i, 0] = 1;
                    table[0, i] = 1;
                    if (i > 0 && j > 0)
                    {
                        table[i, j] = table[i - 1, j] + table[i, j - 1];
                    }
                }
            }
            return table[n - 1, n - 1];
        }
    }
}

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

namespace ConsoleApplication1
{
    class Program
    {
        static void Main()
        {
            int n = Int32.Parse(Console.ReadLine()), max = 1;
            int[,] arr = new int[n, n];
            for (int i = 0; i < n; i++) {
                arr[i, 0] = 1;
                arr[0, i] = 1;
            }
            for (int i = 1; i < n; i++) {
                for (int j = 1; j < n; j++) {
                    arr[i, j] = arr[i, j - 1] + arr[i - 1, j];
                    if (arr[i, j] > max) max = arr[i, j];
                }
            }
            Console.WriteLine(max);
            //Console.ReadKey();
        }
    }
}

using System;

public class CodeForces
{
    public static void Main(string[] args)
    {
        int n = int.Parse(Console.ReadLine());
        int[] c = new int[n];
        for (int i = 0; i < n; ++i)
        {
            c[i] = 1;
        }
        int l = n;
        while (l > 1)
        {
            for (int i = 1; i < n; ++i)
            {
                c[i] = c[i - 1] + c[i];
            }
            --l;
        }
        Console.WriteLine(c[n - 1]);
    }
}

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

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = int.Parse(Console.ReadLine());
            long[,] temp = new long[n, n];
            for (int i = 0; i < n; i++)
            {
                temp[i, 0] = 1;
                temp[0, i] = 1;
            }
            for (int i = 1; i < n; i++)
                for (int j = 1; j < n; j++)
                    temp[i, j] = temp[i - 1, j] + temp[i, j - 1];
            Console.WriteLine(temp[n - 1, n - 1]);
        }
    }
}

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

namespace Problem509A {
    class Program {
        static void Main(string[] args) {
            int[,] matrix = generateMatrix();   //input is <= 10
            int input = Convert.ToInt32(Console.ReadLine());
            int maxValue = matrix[input, input];

            Console.WriteLine(maxValue);

        }

        private static int[,] generateMatrix() {
            int[,] matrix = new int[12, 12];
            for (int i = 1; i <= 11; i++) {
                int row = i;
                for (int j = 1; j <= 11; j++) {
                    if (row == 1) {
                        matrix[row, j] = 1;
                    } else {
                        matrix[row, j] = matrix[row - 1, j] + matrix[row, j - 1];
                    }
                }
            }

            return matrix;
        }
    }
}

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)
        {
            var n = int.Parse(Console.ReadLine());
            var arr = new int[n, 2];
            for (int i = 0; i < n; i++)
            {
                arr[i, 0] = 1;
            }
            for (var tn = 1; tn < n; tn++)
            {
                arr[0, 1] = 1;
                for (int i = 1; i < n; i++)
                {
                    arr[i, 1] = arr[i - 1, 1] + arr[i, 0];
                }
                for (int i = 0; i < n; i++)
                {
                    arr[i, 0] = arr[i, 1];
                }
            }
            if (n == 1) { Console.WriteLine(1); }
            else Console.WriteLine(arr[n-1,1]);
        }
    }
}

using System;

namespace MemoryFrozen
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = Convert.ToInt32(Console.ReadLine());

            switch (n)
            {
                case 1:
                    {
                        Console.Write(1);
                        break;
                    }
                case 2:
                    {
                        Console.Write(2);
                        break;
                    }
                case 3:
                    {
                        Console.Write(6);
                        break;
                    }
                case 4:
                    {
                        Console.Write(20);
                        break;
                    }
                case 5:
                    {
                        Console.Write(70);
                        break;
                    }
                case 6:
                    {
                        Console.Write(252);
                        break;
                    }
                case 7:
                    {
                        Console.Write(924);
                        break;
                    }
                case 8:
                    {
                        Console.Write(3432);
                        break;
                    }
                case 9:
                    {
                        Console.Write(12870);
                        break;
                    }
                case 10:
                    {
                        Console.Write(48620);
                        break;
                    }
            }
        }
    }
}

using System;

namespace MemoryFrozen
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = Convert.ToInt32(Console.ReadLine());

            int[] a = new int[11];

            int j = n;

            while (j > 0)
            {
                for (int i = 0; i < n; i++)
                {
                    if (j == n || i == 0)
                    {
                        a[i] = 1;
                    }
                    else
                    {
                        a[i] = a[i] + a[i - 1];
                    }
                }
                j--;
            }

            Console.WriteLine(a[n - 1]);

        }
    }
}

using System;
using System.Collections.Generic;

namespace Olymp
{
    public class Program
    {
        static void Z1A ()
        {
            uint n, m, a;
            string str = Console.ReadLine ();
            string [] strs = str.Split (' ');
            n = UInt32.Parse (strs [0]);
            m = UInt32.Parse (strs [1]);
            a = UInt32.Parse (strs [2]);

            uint nn = n / a;
            if (n % a > 0)
                nn++;
            uint nm = m / a;
            if (m % a > 0)
                nm++;
            ulong result = (ulong)nn * (ulong)nm;
            Console.WriteLine (result);
        }

        static void Z4A ()
        {
            int w = Int32.Parse (Console.ReadLine ());
            if (w % 2 == 0 && w > 2)
                Console.WriteLine ("YES");
            else
                Console.WriteLine ("NO");
        }

        static void Z158A ()
        {
            int n, k;
            string [] strs = Console.ReadLine ().Split (' ');
            n = Int32.Parse (strs [0]);
            k = Int32.Parse (strs [1]);
            strs = Console.ReadLine ().Split (' ');
            int max = 0;
            int i;
            for (i = 0; i < k; i++) {
                max = Int32.Parse (strs [i]);
                if (max == 0) {
                    Console.WriteLine (i);
                    return;
                }
            }
            int sum = k;
            for (; i < n; i++) {
                if (Int32.Parse (strs [i]) < max)
                    break;
                sum++;
            }
            Console.WriteLine (sum);
        }

        static void Z71A ()
        {
            int n = Int32.Parse (Console.ReadLine ());
            string str;
            for (int i = 0; i < n; i++) {
                str = Console.ReadLine ();
                if (str.Length > 10) {
                    Console.WriteLine (str [0] + (str.Length - 2).ToString () + str [str.Length - 1]);
                } else {
                    Console.WriteLine (str);
                }

            }
        }

        static void Z118A ()
        {
            string str = Console.ReadLine ();
            str = str.ToLower ();
            str = str.Replace ("a", "");
            str = str.Replace ("o", "");
            str = str.Replace ("y", "");
            str = str.Replace ("e", "");
            str = str.Replace ("u", "");
            str = str.Replace ("i", "");
            for (int i = 0; i < str.Length; i++) {
                Console.Write ("." + str [i]);
            }

        }

        static void Z50A ()
        {

            string   [] strs = Console.ReadLine ().Split (' ');
            int N = Int32.Parse (strs [0]);
            int M = Int32.Parse (strs [1]);
            int result = 0;
            result = (N / 2) * M;
            N %= 2;
            M /= 2;
            result += M * N;
            Console.WriteLine (result);

        }

        static void Z158B ()
        {
            int n = Int32.Parse (Console.ReadLine ());
            string[] strs = Console.ReadLine ().Split (' ');
            int[] com = new int[4];
            for (int i = 0; i < 4; i++) {
                com [i] = 0;
            }
            int temp = 0;
            for (int i = 0; i < n; i++) {
                temp = Int32.Parse (strs [i]);
                com [temp - 1]++;
            }
            int sum = com [3];
            temp = Math.Min (com [2], com [0]);
            com [2] -= temp;
            com [0] -= temp;
            sum += temp;
            sum += com [2];
            sum += com [1] / 2;
            com [1] %= 2;
            sum += com [1];
            com [0] -= com [1] * 2;
            if (com [0] > 0) {

                sum += com [0] / 4;
                com [0] %= 4;
                if (com [0] > 0)
                    sum++;
            }
            Console.WriteLine (sum);

        }

        static void Z231A ()
        {

            int n = Int32.Parse (Console.ReadLine ());
            string[] strs;
            int sum = 0;

            for (int i = 0; i < n; i++) {
                strs = Console.ReadLine ().Split (' ');
                if (Int32.Parse (strs [0]) + Int32.Parse (strs [1]) + Int32.Parse (strs [2]) > 1)
                    sum++;
            }
            Console.WriteLine (sum);
        }

        static void Z282A ()
        {

            int n = Int32.Parse (Console.ReadLine ());
            int x = 0;
            string str;
            for (int i = 0; i < n; i++) {
                str = Console.ReadLine ();
                str = str.Replace ("X", "");
                if (str == "++") {
                    x++;
                } else {
                    x--;
                }
            }
            Console.WriteLine (x);
        }

        static  void Z116A ()
        {

            int n = Int32.Parse (Console.ReadLine ());
            int a = 0, b = 0;
            int sum = 0;
            int max = 0;
            string [] strs;
            for (int i = 0; i < n; i++) {
                strs = Console.ReadLine ().Split (' ');
                a = Int32.Parse (strs [0]);
                b = Int32.Parse (strs [1]);
                sum -= a;
                sum += b;
                if (sum > max) {
                    max = sum;
                }
            }
            Console.WriteLine (max);
        }

        static void Z131A ()
        {
            bool caps = true;
            string str = Console.ReadLine ();
            char first = str [0];
            for (int i = 1; i < str.Length; i++) {
                if (str [i] < 'A' || str [i] > 'Z')
                    caps = false;
            }
            if (caps) {
                str = str.ToLower ();
                if (first >= 'a' && first <= 'z')
                    first = first.ToString ().ToUpper () [0];
                else
                    first = first.ToString ().ToLower () [0];
                str = first + str.Substring (1);

            }
            Console.WriteLine (str);
        }

        static void Z96A ()
        {
            string str = Console.ReadLine ();
            int n = 0;
            char ch = 'w';
            for (int i = 0; i < str.Length; i++) {
                if (ch == str [i])
                    n++;
                else {
                    if (n >= 7) {
                        Console.WriteLine ("YES");
                        return;
                    }
                    ch = str [i];
                    n = 1;
                }
            }
            if (n < 7)
                Console.WriteLine ("NO");
            else
                Console.WriteLine ("YES");
        }

        static void Z266A ()
        {

            string str = Console.ReadLine ();
            str = Console.ReadLine ();
            int n = 0;
            int m = 0;
            char ch = ' ';
            for (int i = 0; i < str.Length; i++) {
                if (ch == str [i])
                    n++;
                else {
                    m += n;
                    ch = str [i];
                    n = 0;
                }
            }
            m += n;
            Console.WriteLine (m);
        }

        static void Z133A ()
        {
            string str = Console.ReadLine ();
            for (int i = 0; i < str.Length; i++) {
                if (str [i] == 'H' || str [i] == 'Q' || str [i] == '9') {

                    Console.WriteLine ("YES");
                    return;
                }

            }
            Console.WriteLine ("NO");

        }

        static void Z112A ()
        {
            string str1 = Console.ReadLine ();
            str1 = str1.ToLower ();
            string str2 = Console.ReadLine ();
            str2 = str2.ToLower ();
            int n = String.Compare (str1, str2);
            if (n != 0)
                Console.WriteLine (n / Math.Abs (n));
            else
                Console.WriteLine (0);
        }

        static void Z339A ()
        {
            int [] ch = new int[3];
            for (int i = 0; i < 3; i++) {
                ch [i] = 0;
            }
            string str = Console.ReadLine ();
            bool flag = false;
            for (int i = 0; i < str.Length; i++) {
                if (flag)
                    i++;
                else
                    flag = true;
                ch [Int32.Parse (str [i].ToString ()) - 1]++;
            }
            int j = 0;
            flag = false;
            while (j<3) {
                ch [j]--;

                if (ch [j] >= 0) {
                    if (flag) {
                        Console.Write ("+");
                    } else
                        flag = true;
                    Console.Write (j + 1);
                } else
                    j++;
            }
        }

        static void Z281A ()
        {
            string str = Console.ReadLine ();
            string f = str [0].ToString ();
            f = f.ToUpper ();
            str = f [0] + str.Substring (1);
            Console.Write (str);
        }

        static void Z82A ()
        {
            string[] names = new    string[5];
            names [0] = "Sheldon";
            names [1] = "Leonard";
            names [2] = "Penny";
            names [3] = "Rajesh";
            names [4] = "Howard";
            int n = Int32.Parse (Console.ReadLine ());
            int m = 5;
            while (m<n) {
                n -= m;
                m *= 2;
            }
            m /= 5;
            int i = 0;
            while (m<n) {
                n -= m;
                i++;
            }
            Console.Write (names [i]);
        }

        static void Z160A ()
        {
            int n = Int32.Parse (Console.ReadLine ());
            string[] str = Console.ReadLine ().Split (' ');
            List<int> moneys = new List<int> ();
            int sum = 0;
            for (int i = 0; i < n; i++) {
                moneys.Add (Int32.Parse (str [i]));
                sum += moneys [i];
            }

            int[] armon = moneys.ToArray ();
            Array.Sort (armon);
            int blz = 0;
            int j = armon.Length - 1;
            int ni = 0;
            while (blz<=sum&&j>=0) {
                blz += armon [j];
                sum -= armon [j];
                j--;
                ni++;
            }
            Console.WriteLine (ni);
        }

        static void Z148A ()
        {
            int k = Int32.Parse (Console.ReadLine ());
            int l = Int32.Parse (Console.ReadLine ());
            int m = Int32.Parse (Console.ReadLine ());
            int n = Int32.Parse (Console.ReadLine ());
            int d = Int32.Parse (Console.ReadLine ());
            int sum = 0;

            for (int i = 1; i <= d; i++) {
                if (i % k == 0 || i % l == 0 || i % m == 0 || i % n == 0)
                    sum++;
            }
            Console.WriteLine (sum);
        }

        static void Z236A ()
        {
            string str = Console.ReadLine ();
            int n = 0;
            string ne = "";
            bool k;
            for (int i = 0; i < str.Length; i++) {
                k = false;
                for (int j = 0; j < ne.Length; j++) {
                    if (str [i] == ne [j]) {
                        k = true;
                    }
                }
                if (!k) {
                    ne += str [i];
                    n++;
                }
            }
            if (n % 2 == 0) {
                Console.WriteLine ("CHAT WITH HER!");
            } else {
                Console.WriteLine ("IGNORE HIM!");
            }
        }

        static int gdc (int left, int right)
        {
            while (left>0&&right>0) {
                if (left > right) {
                    left %= right;
                } else
                    right %= left;
            }
            return left + right;
        }

        static void Z119A ()
        {
            string[] str = Console.ReadLine ().Split (' ');
            int[] ab = new int[2];

            ab [0] = Int32.Parse (str [0]);
            ab [1] = Int32.Parse (str [1]);
            int n = Int32.Parse (str [2]);
            int i = 0;
            int m;
            while (true) {
                if (n == 0) {
                    Console.WriteLine ((i + 1) % 2);
                    return;
                }
                m = gdc (ab [i], n);
                n -= m;
                i = (i + 1) % 2;

            }

        }

        static void Z110A ()
        {
            string str = Console.ReadLine ();
            int n = 0;
            for (int i = 0; i < str.Length; i++) {
                if (str [i] == '4' || str [i] == '7') {
                    n++;
                }
            }
            if (n == 4 || n == 7) {
                Console.WriteLine ("YES");
            } else {
                Console.WriteLine ("NO");
            }
        }

        static void Z467A ()
        {
            int n = Int32.Parse (Console.ReadLine ());
            int res = 0;
            string [] strs;
            for (int i = 0; i < n; i++) {
                strs = Console.ReadLine ().Split (' ');
                if (Int32.Parse (strs [1]) - Int32.Parse (strs [0]) >= 2) {
                    res++;
                }
            }
            Console.WriteLine (res);
        }

        static void Z271A ()
        {
            int n = Int32.Parse (Console.ReadLine ());
            int [] ye = new int[4];
            n++;
            for (int i = 0; i < 4; i++) {
                ye [i] = n / 1000;
                n %= 1000;
                n *= 10;
            }
            bool flag = true;
            while (flag) {
                for (int i = 0; i < 4; i++) {
                    for (int j = 0; j < i; j++) {
                        if (ye [i] == ye [j]) {
                            ye [i]++;

                            for (int k = i+1; k < 4; k++) {
                                ye [k] = 0;
                            }
                            i--;
                        }
                    }
                }
                flag = false;
                for (int i = 1; i < 4; i++) {
                    if (ye [i] == 10) {
                        ye [i] %= 10;
                        ye [i - 1]++;
                        flag = true;
                    }
                }
            }
            for (int i = 0; i < 4; i++) {
                Console.Write (ye [i]);
            }

        }

        static void Z58A ()
        {
            string str = Console.ReadLine ();
            str.ToLower ();
            string sstr = "hello";
            int j = 0;
            for (int i = 0; i < str.Length; i++) {
                if (sstr [j] == str [i])
                    j++;
                if (j == sstr.Length) {
                    Console.WriteLine ("YES");
                    return;
                }
            }
            Console.WriteLine ("NO");
        }

        static void Z472A ()
        {
            int n = Int32.Parse (Console.ReadLine ());
            if (n % 2 == 0) {
                Console.Write ("4 ");
                Console.Write (n - 4);
            } else {
                Console.Write ("9 ");
                Console.Write (n - 9);
            }
        }

        static void Z460A ()
        {
            int res = 0;
            int days = 0;
            string[] strs = Console.ReadLine ().Split (' ');
            int nosk = Int32.Parse (strs [0]);
            int nd = Int32.Parse (strs [1]);
            while (nosk!=0) {
                days += nosk;
                res += nosk;
                nosk = 0;
                nosk = days / nd;
                days %= nd;
            }
            Console.Write (res);
        }

        static void Z379A ()
        {
            string[] strs = Console.ReadLine ().Split (' ');
            int a = Int32.Parse (strs [0]);
            int b = Int32.Parse (strs [1]);
            int ogaroks = 0;
            int h = 0;
            while (a!=0) {
                h += a;
                ogaroks += a;
                a = ogaroks / b;
                ogaroks %= b;
            }
            Console.WriteLine (h);
        }

        static bool IsLucky (int n)
        {
            while (n>0) {
                int m = n % 10;
                if (m != 4 && m != 7) {
                    return false;
                }
                n /= 10;
            }
            return true;
        }

        static void Z122A ()
        {
            int n = Int32.Parse (Console.ReadLine ());
            for (int i = 2; i <= n; i++) {
                if (n % i == 0 && IsLucky (i)) {
                    Console.WriteLine ("YES");
                    return;
                }
            }
            Console.WriteLine ("NO");
        }

        static void Z136A ()
        {
            int n = Int32.Parse (Console.ReadLine ());
            int[] pod = new int[n];
            string[] strs = Console.ReadLine ().Split (' ');
            for (int i = 0; i < n; i++) {
                pod [Int32.Parse (strs [i]) - 1] = i + 1;
            }
            for (int i = 0; i < n; i++) {
                Console.Write (pod [i].ToString () + " ");
            }
        }

        static void Z228A ()
        {
            string[] strs = Console.ReadLine ().Split (' ');
            List<int> n = new List<int> ();
            for (int i = 0; i < 4; i++) {
                bool flag = true;
                for (int j = 0; j < n.Count; j++) {
                    if (Int32.Parse (strs [i]) == n [j]) {
                        flag = false;
                        break;
                    }
                }
                if (flag) {
                    n.Add (Int32.Parse (strs [i]));
                }
            }
            Console.WriteLine (4 - n.Count);
        }

        static void Z263A ()
        {
            string[] strs;
            int x = 0, y = 0;
            for (int i = 0; i < 5; i++) {
                strs = Console.ReadLine ().Split (' ');
                for (int j = 0; j < 5; j++) {
                    if (strs [j] == "1") {
                        x = j + 1;
                        y = i + 1;
                    }
                }

            }
            Console.WriteLine ((Math.Abs (3 - x) + Math.Abs (3 - y)));
        }

        static void Z266B ()
        {
            string[] strs = Console.ReadLine ().Split (' ');
            int n = Int32.Parse (strs [0]);
            int t = Int32.Parse (strs [1]);
            string str = Console.ReadLine ();
            char[] chs = new char[str.Length];
            for (int i = 0; i < str.Length; i++) {
                chs [i] = str [i];
            }
            for (int i = 0; i < t; i++) {
                int j = 0;
                while (j+1<n) {
                    if (chs [j] == 'B' && chs [j + 1] == 'G') {
                        char ch = chs [j];
                        chs [j] = chs [j + 1];
                        chs [j + 1] = ch;
                        j += 2;
                    } else {
                        j++;
                    }
                }
            }
            for (int i = 0; i < chs.Length; i++) {
                Console.Write (chs [i]);
            }

        }

        static void Z41A ()
        {
            string str1 = Console.ReadLine ();
            string str2 = Console.ReadLine ();
            if (str1.Length != str2.Length) {
                Console.WriteLine ("NO");
                return;
            }
            for (int i = 0; i < str1.Length; i++) {
                if (str1 [i] != str2 [str2.Length - i - 1]) {

                    Console.WriteLine ("NO");
                    return;
                }
            }
            Console.WriteLine ("YES");
        }

        static void Z144A ()
        {
            int n = Int32.Parse (Console.ReadLine ());
            string[] strs = Console.ReadLine ().Split (' ');
            int[] rost = new int[n];
            int max = 0;
            int min = n - 1;
            for (int i = 0; i < n; i++) {
                rost [i] = Int32.Parse (strs [i]);
                if (rost [i] > rost [max])
                    max = i;
            }
            int sum = 0;
            while (max!=0) {
                int temp = rost [max];
                rost [max] = rost [max - 1];
                rost [max - 1] = temp;
                sum++;
                max--;
            }

            for (int i = n-1; i >=0; i--) {

                if (rost [i] < rost [min]) {
                    min = i;
                }
            }
            while (min!=rost.Length-1) {
                int temp = rost [min];
                rost [min] = rost [min + 1];
                rost [min + 1] = temp;
                sum++;
                min++;
            }
            Console.WriteLine (sum);
        }

        static void Z451A ()
        {
            string[] names = new string[2];
            names [0] = "Akshat";
            names [1] = "Malvika";
            string[] strs = Console.ReadLine ().Split (' ');
            int n = Int32.Parse (strs [0]);
            int m = Int32.Parse (strs [1]);
            n = Math.Min (n, m) - 1;
            n %= 2;
            Console.WriteLine (names [n]);

        }

        static void Z344A ()
        {
            int n = Int32.Parse (Console.ReadLine ());
            int ostr = 1;
            string str = Console.ReadLine ();
            char ch = str [1];
            for (int i = 1; i < n; i++) {
                str = Console.ReadLine ();
                if (ch == str [0]) {
                    ostr++;
                }
                ch = str [1];
            }
            Console.WriteLine (ostr);
        }

        static void Z486A ()
        {
            long n = Int64.Parse (Console.ReadLine ());
            long sum = n / 2;
            sum -= (n % 2) * n;
            Console.WriteLine (sum);
        }

        static void Z500A ()
        {
            string[] str = Console.ReadLine ().Split (' ');
            int n = Int32.Parse (str [0]);
            int t = Int32.Parse (str [1]);
            int[] a = new int[n - 1];
            str = Console.ReadLine ().Split (' ');
            int j = 0;
            t--;
            for (int i = 0; i < n-1; i++) {
                a [i] = Int32.Parse (str [i]);
                if (i == j)
                    j += a [i];
                if (j >= t)
                    break;
            }
            if (j == t)
                Console.WriteLine ("YES");
            else
                Console.WriteLine ("NO");
        }

        static void Z61A ()
        {
            string str1 = Console.ReadLine ();
            string str2 = Console.ReadLine ();
            string str3 = "";
            for (int i = 0; i < str1.Length; i++) {
                if (str1 [i] == str2 [i])
                    str3 += "0";
                else
                    str3 += "1";
            }
            Console.WriteLine (str3);
        }

        static void Z268A ()
        {
            int n = Int32.Parse (Console.ReadLine ());
            int[] h = new int[n];
            int[] a = new int[n];
            string[] strs;
            for (int i = 0; i < n; i++) {
                strs = Console.ReadLine ().Split (' ');
                h [i] = Int32.Parse (strs [0]);
                a [i] = Int32.Parse (strs [1]);
            }
            int sum = 0;
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                    if (i != j && h [i] == a [j])
                        sum++;
                }
            }
            Console.WriteLine (sum);
        }

        static void Z208A ()
        {
            string str = Console.ReadLine ();
            string[] separ = new string[1];
            separ [0] = "WUB";
            string[] strs = str.Split (separ, StringSplitOptions.RemoveEmptyEntries);
            for (int i = 0; i < strs.Length; i++) {
                Console.Write (strs [i] + " ");
            }
        }

        static void Z478A ()
        {
            string []strs=Console.ReadLine().Split(' ');
            int n=0;
            for (int i = 0; i < 5; i++) {
                n+=Int32.Parse(strs[i]);
            }
            if (n%5==0&&n!=0) {
                Console.WriteLine(n/5);
            }
            else {
                Console.WriteLine(-1);
            }
        }
        static void Z69A ()
        {
            int n = Int32.Parse (Console.ReadLine ());
            int x = 0, y = 0, z = 0;
            string[] strs;
            for (int i = 0; i < n; i++) {
                strs = Console.ReadLine ().Split (' ');
                x += Int32.Parse (strs [0]);
                y += Int32.Parse (strs [1]);
                z += Int32.Parse (strs [2]);
            }
            if (x == 0 && y == 0 && z == 0) {
                Console.Write ("YES");
            } else {
                Console.Write("NO");
            }
        }
        static void Z337A ()
        {
            string[] strs=Console.ReadLine().Split(' ');
            int n=Int32.Parse(strs[0]);
            int m=Int32.Parse(strs[1]);
            List<int> arra=new List<int>();
            strs=Console.ReadLine().Split(' ');
            bool flag;
            for (int i = 0; i < m; i++) {
                flag=true;
                int t=Int32.Parse(strs[i]);
                for (int j = 0; j < arra.Count; j++) {
                    if(t<arra[j])
                    {
                        arra.Insert(j,t);
                        flag=false;
                        break;
                    }
                }
                if (flag) {
                    arra.Add(t);
                }
            }
            int min=int.MaxValue;
            for (int i = n-1; i < arra.Count; i++) {
                if (arra[i]-arra[i-n+1]<min) {

                    min=arra[i]-arra[i-n+1];
                }
            }
            Console.Write(min);
        }
        static void Z141A ()
        {
            string names = Console.ReadLine ();
            names += Console.ReadLine ();
            string str = Console.ReadLine ();
            if (names.Length != str.Length) {
                Console.Write ("NO");
                return;
            }
            bool flag;
            for (int i = 0; i < str.Length; i++) {
                flag=true;;
                for (int qj = 0; qj < names.Length; qj++) {
                    if (str[i]==names[qj]) {
                        flag=false;
                        names=names.Substring(0,qj)+' '+names.Substring(qj+1);
                        break;
                    }
                }
                if (flag) {
                    Console.WriteLine("NO");
                    return;
                }
            }
            Console.WriteLine("YES");
        }
        static void Z492A ()
        {
            int n=Int32.Parse(Console.ReadLine());
            int i=1;
            int level=0;
            int sum=1;
            while (n>=sum) {
                level++;
                n-=sum;
                i++;
                sum+=i;
            }
            Console.WriteLine(level);
        }
        static void Z479A ()
        {
            int a=Int32.Parse(Console.ReadLine());
            int b=Int32.Parse(Console.ReadLine());
            int c=Int32.Parse(Console.ReadLine());
            int res=a+b+c;
            res=Math.Max(res,(a+b)*c);
            res=Math.Max(res,a*(b+c));
            res=Math.Max(res,(a*b)*c);
            Console.WriteLine(res);

        }
        static void Z448A ()
        {
            string[] strs = Console.ReadLine ().Split (' ');
            int a = Int32.Parse (strs [0]) + Int32.Parse (strs [1]) + Int32.Parse (strs [2]);
            strs = Console.ReadLine ().Split (' ');
            int b = Int32.Parse (strs [0]) + Int32.Parse (strs [1]) + Int32.Parse (strs [2]);
            int n = Int32.Parse (Console.ReadLine ());
            int aa = a / 5;
            if (a % 5 != 0) {
                aa++;
            }
            n -= aa;
            if (n < 0) {
                Console.WriteLine("NO");
                return;
            }
            aa=b/10;
            if (b%10!=0) {
                aa++;
            }
            n -= aa;
            if (n < 0) {
                Console.WriteLine("NO");
                return;
            }
            Console.WriteLine("YES");
        }
        static  void Z469A ()
        {
            int n=Int32.Parse(Console.ReadLine());
            bool[]levels=new bool[n];
            for (int i = 0; i < n; i++) {
                levels[i]=true;
            }
            for (int i = 0; i < 2; i++) {
                string[]str=Console.ReadLine().Split(' ');
                int m=Int32.Parse(str[0]);
                for (int j = 1; j <= m; j++) {
                    levels[Int32.Parse(str[j])-1]=false;
                }
            }
            for (int i = 0; i < n; i++) {
                if (levels[i]) {
                    Console.WriteLine("Oh, my keyboard!");
                    return;
                }
            }
            Console.WriteLine("I become the guy.");
        }
        static void Z155A ()
        {
            int n=Int32.Parse(Console.ReadLine());
            string[]strs=Console.ReadLine().Split(' ');
            int max=Int32.Parse(strs[0]);
            int min=max;
            int m=0;
            for (int i = 1; i < n; i++) {
                int t=Int32.Parse(strs[i]);
                if (t>max) {
                    m++;
                    max=t;
                }
                if (t<min) {
                    m++;
                    min=t;
                }
            }
            Console.WriteLine(m);
        }
        static void Z443A ()
        {
            string str=Console.ReadLine();
            int i=1;
            List<char> chrs=new List<char>();
            bool flag;
            while (str[i]!='}') {

                flag=true;
                for (int j = 0; j < chrs.Count; j++) {
                    if (str[i]==chrs[j]) {
                        flag=false;
                        break;
                    }
                }
                if (flag) {
                    chrs.Add(str[i]);
                }
                i++;
                if(str[i]=='}')
                    break;
                i+=2;
            }
            Console.WriteLine(chrs.Count);
        }
        static void Z474A ()
        {
            char[,]keyboard=new char[3,10];
            keyboard[0,0]='q';
            keyboard[0,1]='w';
            keyboard[0,2]='e';
            keyboard[0,3]='r';
            keyboard[0,4]='t';
            keyboard[0,5]='y';
            keyboard[0,6]='u';
            keyboard[0,7]='i';
            keyboard[0,8]='o';
            keyboard[0,9]='p';
            keyboard[1,0]='a';
            keyboard[1,1]='s';
            keyboard[1,2]='d';
            keyboard[1,3]='f';
            keyboard[1,4]='g';
            keyboard[1,5]='h';
            keyboard[1,6]='j';
            keyboard[1,7]='k';
            keyboard[1,8]='l';
            keyboard[1,9]=';';
            keyboard[2,0]='z';
            keyboard[2,1]='x';
            keyboard[2,2]='c';
            keyboard[2,3]='v';
            keyboard[2,4]='b';
            keyboard[2,5]='n';
            keyboard[2,6]='m';
            keyboard[2,7]=',';
            keyboard[2,8]='.';
            keyboard[2,9]='/';
            bool flag;
            string lr=Console.ReadLine();
            string str=Console.ReadLine();
            int[]x=new int[str.Length];
            int[]y=new int[str.Length];
            for (int i = 0; i < str.Length; i++) {
                flag=false;
                for (int k = 0; k < 3; k++) {
                    for (int m = 0; m < 10; m++) {
                        if (keyboard[k,m]==str[i]) {
                            y[i]=k;
                            x[i]=m;
                            flag=true;
                            break;
                        }
                    }
                    if(flag)
                        break;
                }
            }
            int a=0;
            if (lr=="L") {
                a++;
            }
            else {
                a--;
            }
            for (int i = 0; i < str.Length; i++) {
                Console.Write(keyboard[y[i],x[i]+a]);
            }
        }
        static void Z268B ()
        {
            int n=Int32.Parse(Console.ReadLine());
            int sum=0;
            for (int j = 1; j < n; j++) {
                sum+=(n-j)*j;
            }
            sum+=n;
            Console.WriteLine(sum);
        }
        static void Z318A ()
        {
            string[] strs=Console.ReadLine().Split(' ');

            long n=Int64.Parse(strs[0]);
            long m=Int64.Parse(strs[1]);
            n=n/2+n%2;
            long a=0;

            if (m<=n) {
                a=1;
            }
            else
            {
                m-=n;
                a=2;
            }
                    a=a+(m-1)*2;

            Console.WriteLine(a);

        }
        static void Z510A ()
        {
            string[] strs=Console.ReadLine().Split(' ');

            int n=Int32.Parse(strs[0]);
            int m=Int32.Parse(strs[1]);
            int  dir=0;
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < m; j++) {
                    if(dir==0)
                    {
                        Console.Write("#");
                    }
                    if(dir==1&&j==m-1)
                    {
                        Console.Write("#");
                    }
                    if(dir==1&&j!=m-1)
                    {
                        Console.Write(".");
                    }
                    if(dir==2)
                    {
                        Console.Write("#");
                    }
                    if(dir==3&&j==0)
                    {
                        Console.Write("#");
                    }
                    if(dir==3&&j!=0)
                    {
                        Console.Write(".");
                    }
                }
                dir++;
                dir%=4;
                Console.WriteLine();
            }
        }
        static void Z405A ()
        {
            int n=Int32.Parse(Console.ReadLine());
            int[]st=new int[n];
            string []strs=Console.ReadLine().Split(' ');
            for (int i = 0; i < n; i++) {
                st[i]=Int32.Parse(strs[i]);
            }
            Array.Sort(st);
            for (int i = 0; i < st.Length; i++) {
                Console.Write(st[i].ToString()+" ");
            }
        }
        static void Z466A ()
        {
            string[] strs = Console.ReadLine ().Split (' ');
            int n = Int32.Parse (strs [0]);
            int m = Int32.Parse (strs [1]);
            int a = Int32.Parse (strs [2]);
            int b = Int32.Parse (strs [3]);
            int sum = 0;
            int temp=m *a;
            if (temp>b) {
                temp=b;
            }
            sum=(n /m)*temp;
            n %=m;
            temp=n *a;
            if(temp>b)
                temp=b;

            sum+=temp;
            Console.Write(sum);

        }
        static void Z513A ()
        {
            string[] str = Console.ReadLine ().Split ();
            int a = Int32.Parse (str [0]);
            int b = Int32.Parse (str [1]);
            if (a > b) {
                Console.Write ("First");
            } else {
                Console.Write ("Second");
            }
        }
        static void Z237A ()
        {
            int n=Int32.Parse(Console.ReadLine());
            int max=0;
            int now=1;
            int lh=-1;
            int lm=-1;
            string[]strs;
            for (int i = 0; i < n; i++) {
                strs=Console.ReadLine().Split(' ');
                int h=int.Parse(strs[0]);
                int m=int.Parse(strs[1]);
                if (lm==m&&lh==h) {
                    now++;
                }
                else
                {
                    if (max<now) {
                        max=now;
                    }
                    now=1;
                    lm=m;
                    lh=h;
                }
            }
            if (max<now) {
                        max=now;
                    }
            Console.Write(max);
        }
        static void Z427A ()
        {
            int prest=0;
            int n=int.Parse(Console.ReadLine());
            string[]strs=Console.ReadLine().Split(' ');
            int poliz=0;
            for (int i = 0; i < n; i++) {
                int temp=int.Parse(strs[i]);
                if (temp>=0) {
                    poliz+=temp;
                }
                else {
                    if(poliz==0)
                        prest++;
                    else
                        poliz--;
                }
            }
            Console.Write(prest);
        }

        static void Z471A ()
        {
            string[]str=Console.ReadLine().Split(' ');
            List<int> pl=new List<int>();
            List<int> plc=new List<int>();
            bool fl=true;
            for (int i = 0; i < 6; i++) {
                fl=true;
                int n=int.Parse(str[i]);
                for (int j = 0; j < pl.Count; j++) {
                    if(n==pl[j])
                    {
                        plc[j]++;
                        fl=false;
                        break;
                    }
                }
                if (fl) {
                    pl.Add(n);
                    plc.Add(1);
                }
            }
            int[] arr=plc.ToArray();
            Array.Sort(arr);
            if (arr.Length<=3) {
                if (arr[arr.Length-1]>=4) {
                    if (arr[0]>1) {
                        Console.Write("Elephant");
                    }
                    else {

                        Console.Write("Bear");
                    }
                    return;
                }
            }

                        Console.Write("Alien");

        }
        static void Z509A ()
        {
            int n=int.Parse(Console.ReadLine());
            int[,] table=new int[n,n];
            for (int i = 0; i < n; i++) {
                table[i,0]=1;
            }
            for (int i = 0; i < n; i++) {
                table[0,i]=1;
            }
            for (int i = 1; i < n; i++) {
                for (int j = 1; j < n; j++) {
                    table[i,j]=table[i-1,j]+table[i,j-1];
                }
            }
            Console.Write(table[n-1,n-1]);
        }
        public static void Main ()
        {

            Z509A ();
        }

    }
}

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

namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = Convert.ToInt32(Console.ReadLine());

            int[] x = new int[n];
            for (int i = 0; i < n; i++)
            {
                x[i] = 1;
            }
            int lasttop = 1;
            for(int i= 1; i<n; i++)
            {
                for(int j =i; j<n; j++)
                {
                    x[j] = x[j - 1] + lasttop;
                    if (j != n - 1)
                        lasttop = x[j + 1];
                }
                if (i != n - 1)
                {
                    x[i] = x[i + 1];
                    lasttop = x[i];
                }
            }
            Console.Write(x[n - 1]);
        }
    }
}

using System;

namespace Codeforces509A
{
    class Program
    {
        public static ulong Fact(ulong num)
        {
            ulong factorial = 1;
            for (ulong i = 1; i <= num; i++)
            {
                factorial *= i;
            }
            return factorial;
        }

        static void Main(string[] args)
        {
            var n = ulong.Parse(Console.ReadLine());
            n--;
            var solution = Fact(2 * n) / (Fact(n) * Fact(n));
            Console.WriteLine(solution);
        }
    }
}

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

namespace ConsoleApplication1
{
    class Program
    {
        static int[] ReadInt(int size)
        {
            string[] input = Console.ReadLine().Split(' ');
            int[] res = new int[size];
            for (int i=0; i<input.Length; i++)
            {
                res[i] = Convert.ToInt32(input[i]);
            }
            return res;
        }

        static int ReadInt()
        {
            int n = Convert.ToInt32(Console.ReadLine());
            return n;
        }

        static void ReadInt(out int a, out int b)
        {
            int[] input = ReadInt(2);
            a = input[0];
            b = input[1];
        }

        static void ReadInt(out int a, out int b, out int c)
        {
            int[] input = ReadInt(3);
            a = input[0];
            b = input[1];
            c = input[2];
        }

        static void ReadInt(out int a, out int b, out int c, out int d)
        {
            int[] input = ReadInt(4);
            a = input[0];
            b = input[1];
            c = input[2];
            d = input[3];
        }

        static String ReadString()
        {
            return Console.ReadLine();
        }

        static int Max(int a, int b)
        {
            return (a > b ? a : b);
        }

        static void WL<T> (T s)
        {
            Console.WriteLine(s);
        }

        static void swap(ref int a, ref int b)
        {
            int temp = a;
            a = b;
            b = temp;
        }

        static void Main(string[] args)
        {
            int n = ReadInt();
            int[,] a = new int[n,n];
            int res = -1;
            for (int i = 0; i < n; i++)
                for (int j = 0; j < n; j++)
                {
                    if (i == 0 || j == 0) a[i, j] = 1;
                    else a[i, j] = a[i - 1, j] + a[i, j - 1];
                    res = Max(res, a[i, j]);
                }
            WL(res);
        }
    }
}

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

namespace CodeForces289
{
    class Program
    {
        public static void Main(string[] args)
        {
            int[,] a = new int[11, 11];
            string input = Console.ReadLine();
            int n = Convert.ToInt32(input);
            for (int i = 0; i < n; i++)
            {
                for (int j = 0; j < n; j++)
                {
                    if (i == 0 || j == 0)
                    {
                        a[i, j] = 1;
                    }
                    else
                    {
                        a[i, j] = a[i - 1, j] + a[i, j - 1];
                    }
                }
            }
            Console.Write(a[n - 1, n - 1]);
        }
    }
}

using System;

namespace CodeFirstSimple
{
    class Program
    {
        static void Main()
        {
            var n = int.Parse(Console.ReadLine());
            int[,] arr = new int[n, n];
            for (int i = 0; i < n; i++)
            {
                for (int j = 0; j < n; j++)
                {
                    if (i == 0 || j == 0)
                        arr[i, j] = 1;
                    else
                        arr[i, j] = arr[i - 1, j] + arr[i, j - 1];
                }

            }

            var res = arr[n - 1, n - 1];
            Console.WriteLine(res);
        }
    }
}

using System;
public abstract class Animal : Object
{
    public abstract void say();
}
public class Dog : Animal
{
    public override void say()
    {
        Console.WriteLine("Гав");
    }
    public static void hi()
    {
        Console.WriteLine("hi");
    }
}
struct lol
{
    int x, y;

};
namespace EduSharp
{
    class Program
    {
        static void swap<T>(ref T a,ref T b)
        {
            T temp = a;
            a = b;
            b = temp;
        }
        static void Main(string[] args)
        {
            int n = int.Parse(Console.ReadLine());

            if (n == 1) Console.WriteLine("1");
            else
            {
                int[,] m = new int[n,n];
                for(int i=0;i< n;i++)
                {
                    m[0, i] = 1;
                    m[i, 0] = 1;
                }
                for(int i=1;i< n;i++) // строка
                {
                    for(int j=1;j< n;j++) // стобец
                    {
                        m[i, j] = m[i, j - 1] + m[i - 1, j];
                    }
                }
                Console.WriteLine(m[n-1, n-1]);

            }

            Console.Read();
        }
    }
}

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

namespace _509A_Maximum_in_Table
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = int.Parse(Console.ReadLine());
            long output;

            if (n == 1)
                output = 1;
            else
            {
                output = Factorial((n - 1) * 2) / (Factorial(n - 1) * Factorial(n - 1));
            }

            Console.WriteLine(output.ToString());
        }

        static long Factorial(int k)
        {
            if (k == 0)
                return 1;
            else
                return k * Factorial(k - 1);
        }
    }
}

using System;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = int.Parse(Console.ReadLine());
            int max = 0;
            int[,] array = new int[n, n];
            for (int i = 0; i < n; i++)
            {
                for (int j = 0; j < n; j++)
                {
                    if (i == 0 || j == 0)
                        array[i, j] = 1;
                    else array[i, j] = array[i - 1, j] + array[i, j - 1];
                    if (array[i, j] > max);
                    max = array[i, j];
                }
            }
            Console.Write(max);
        }
    }
}

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

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            int a = Convert.ToInt32(Console.ReadLine());
            if (a == 1) Console.WriteLine(1);
            if (a == 2) Console.WriteLine(2);
            if (a == 3) Console.WriteLine(6);
            if (a == 4) Console.WriteLine(20);
            if (a == 5) Console.WriteLine(70);
            if (a == 6) Console.WriteLine(252);
            if (a == 7) Console.WriteLine(924);
            if (a == 8) Console.WriteLine(3432);
            if (a == 9) Console.WriteLine(12870);
            if (a == 10) Console.WriteLine(48620);
            //if (a == 1) Console.WriteLine(1);
        }
    }
}

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

namespace ProblemSolvingProject
{
    class MaximumInTheTable
    {
        public static void Main(string[] args)
        {
            int n = int.Parse(Console.ReadLine());
            int[,] arr = new int[n, n];
            for(int i = 0; i <n; i++)
            {
                arr[0, i] = 1;
                arr[i, 0] = 1;
            }
            for(int i = 1; i < n; i++)
            {
                for(int j = 1; j < n; j++)
                {
                    arr[i, j] = arr[i, j - 1] + arr[i - 1, j];
                }

            }
            Console.WriteLine(arr[n - 1, n - 1]);
            Console.ReadLine();
        }
    }
}

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

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

            int[][] data = new int[10][];
            for (int i = 0; i < 10; i++)
            {
                data[i] = new int[10];
            }

            for (int i = 0; i < n; i++)
            {
                for (int j = 0; j < n; j++)
                {
                    if (i > 0 && j > 0)
                    {
                        data[i][j] = data[i - 1][j] + data[i][j - 1];
                    }
                    else
                    {
                        data[i][j] = 1;
                    }
                }
            }

            Console.WriteLine(data[n-1][n-1]);
        }
    }
}

class Program
{
    static void Main()
    {
        switch(System.Console.ReadLine())
        {
            case "10":
                Out("48620");
                break;
            case "9":
                Out("12870");
                break;
            case "8":
                Out("3432");
                break;
            case "7":
                Out("924");
                break;
            case "6":
                Out("252");
                break;
            case "5":
                Out("70");
                break;
            case "4":
                Out("20");
                break;
            case "3":
                Out("6");
                break;
            case "2":
                Out("2");
                break;
            case "1":
                Out("1");
                break;
            case "0":
                Out("0");
                break;
        }
    }
    static void Out(string line) { System.Console.Write(line); }
}

using System;
using System.IO;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Reflection;
using System.Net.Sockets;
using System.Xml;
using System.Diagnostics;
using System.Linq;

namespace codeforcesSolution
{
    class Program
    {
        #region testlib
        public delegate ReadDelegate<T> ReadDelegate<T>(out T value);
        public delegate bool ParserDelegate<T>(string word, out T item);

        public class Input : IDisposable
        {
            private static EventArgs DefaultEventArgs = new EventArgs();

            public TextReader TextReader { get; private set; }

            public event EventHandler OnEndOfStream;
            public event EventHandler OnParseError;
            public event EventHandler OnReadError;

            public bool CanRead { get; private set; }
            public bool ThrowExceptions { get; set; }

            string line = string.Empty;
            int pos = 0;

            static EventHandler emptyHandler;

            public Input(string path)
                : this(File.OpenRead(path))
            {
            }
            public Input(Stream s)
                : this(new StreamReader(s))
            {

            }
            public Input(TextReader tr)
            {
                TextReader = tr;

                if (emptyHandler == null)
                    emptyHandler = (a, b) => { };

                OnEndOfStream = emptyHandler;
                OnParseError = emptyHandler;
                OnReadError = emptyHandler;

                CanRead = true;
            }

            public static implicit operator Input(Stream s)
            {
                return new Input(s);
            }
            public static implicit operator Input(TextReader tr)
            {
                return new Input(tr);
            }

            private bool ReadStream()
            {
                if (!CanRead) return false;
                if (pos < line.Length) return true;

                Clear();

                string s = TextReader.ReadLine();
                if (s == null)
                {
                    CanRead = false;
                    return false;
                }

                line = s;
                return true;
            }

            public ReadDelegate<T> r<T>(out T value)
            {
                value = ReadData<T>();
                return r;
            }

            public void SkipChar()
            {
                if (pos < line.Length) pos++;
                else
                {
                    ReadStream();
                }
            }
            public void SkipChars(int length)
            {
                while (length > 0)
                {
                    int dt = line.Length - pos;
                    if (dt <= 0)
                    {
                        length--;
                        if (!ReadStream()) return;
                    }
                    dt = Math.Min(length, dt);
                    pos += dt;
                    length -= dt;
                }
            }

            public void SkipWhiteSpace()
            {
                while (true)
                {
                    for (; pos < line.Length; pos++)
                    {
                        if (!char.IsWhiteSpace(line[pos])) return;
                    }
                    if (!ReadStream())
                    {
                        OnEndOfStream(this, DefaultEventArgs);
                        return;
                    }
                }
            }
            public bool CanReadData()
            {
                SkipWhiteSpace();
                return CanRead;
            }

            public T[] ReadArray<T>()
            {
                int length = ReadInt32();
                return ReadArray<T>(length);
            }
            public T[] ReadArray<T>(int length)
            {
                ParserDelegate<T> parser = Parser.GetPrimitiveParser<T>();
                return ReadArray<T>(length, parser);
            }
            public T[] ReadArray<T>(ParserDelegate<T> parser)
            {
                int length = ReadInt32();
                return ReadArray<T>(length, parser);
            }
            public T[] ReadArray<T>(int length, ParserDelegate<T> parser)
            {
                T[] res = new T[length];
                for (int i = 0; i < length; i++)
                {
                    res[i] = ReadData<T>(parser);
                }
                return res;
            }

            public Decimal ReadDecimal()
            {
                return ReadData<Decimal>(Parser.DecimalParser);
            }
            public Double ReadDouble()
            {
                return ReadData<Double>(Parser.DoubleParser);
            }
            public Single ReadSingle()
            {
                return ReadData<Single>(Parser.SingleParser);
            }
            public UInt64 ReadUInt64()
            {
                return ReadData<UInt64>(UInt64.TryParse);
            }
            public UInt32 ReadUInt32()
            {
                return ReadData<UInt32>(UInt32.TryParse);
            }
            public UInt16 ReadUInt16()
            {
                return ReadData<UInt16>(UInt16.TryParse);
            }
            public Int64 ReadInt64()
            {
                return ReadData<Int64>(Int64.TryParse);
            }
            public Int32 ReadInt32()
            {
                return ReadData<Int32>(Int32.TryParse);
            }
            public Int16 ReadInt16()
            {
                return ReadData<Int16>(Int16.TryParse);
            }
            public Boolean ReadYesNo()
            {
                return ReadData<Boolean>(Parser.YesNoParser);
            }
            public Boolean ReadBoolean()
            {
                return ReadData<Boolean>(Boolean.TryParse);
            }
            public Byte ReadByte()
            {
                return ReadData<Byte>(Byte.TryParse);
            }

            private bool ReadCheck()
            {
                if (!CanRead)
                {
                    OnReadError(this, DefaultEventArgs);
                    if (ThrowExceptions)
                    {
                        throw new Exception("!CanRead");
                    }
                    return false;
                }
                return true;
            }
            public T ReadData<T>()
            {
                return ReadData<T>(true);
            }
            public T ReadData<T>(bool skipWhiteSpace)
            {
                ParserDelegate<T> parser = Parser.GetPrimitiveParser<T>();
                return ReadData<T>(parser, skipWhiteSpace);
            }
            public T ReadData<T>(ParserDelegate<T> parser)
            {
                return ReadData<T>(parser, true);
            }
            public T ReadData<T>(ParserDelegate<T> parser, bool skipWhiteSpace)
            {
                if (skipWhiteSpace)
                    SkipWhiteSpace();

                if (!ReadCheck()) return default(T);

                string s = ReadWord(false);

                T res;
                if (!parser.Invoke(s, out res))
                {
                    OnParseError(this, DefaultEventArgs);
                    if (ThrowExceptions)
                    {
                        throw new Exception("!validate, word = " + Output.ToString(s, 256));
                    }
                }
                return res;
            }

            public string ReadWord()
            {
                return ReadWord(true);
            }
            public string ReadWord(bool skipWhiteSpace)
            {
                if (skipWhiteSpace)
                    SkipWhiteSpace();

                if (!ReadCheck()) return string.Empty;

                int from = pos;
                int to = pos;
                for (int i = pos; i < line.Length; i++)
                {
                    if (char.IsWhiteSpace(line[i])) break;
                    to = i + 1;
                }
                pos = to;

                return line.Substring(from, to - from);
            }

            public string ReadLine()
            {
                if (!ReadCheck()) return string.Empty;

                ReadStream();
                string res = line.Substring(pos);
                pos = line.Length;

                return res;
            }

            public void Close()
            {
                TextReader.Close();
            }
            public void Clear()
            {
                pos = 0;
                line = string.Empty;
            }

            private bool disposed = false;
            public void Dispose()
            {
                Dispose(true);
                GC.SuppressFinalize(this);
            }

            protected virtual void Dispose(bool disposing)
            {
                if (!this.disposed)
                {
                    if (disposing)
                    {
                        line = string.Empty;
                        TextReader.Dispose();
                    }
                    disposed = true;
                }
            }
            ~Input()
            {
                Dispose(false);
            }
        }
        public class Output : IDisposable
        {
            static char[] space = new char[] { ' ' };

            public TextWriter TextWriter { get; private set; }
            public bool AutoFlush { get; set; }

            public static string ToString(object obj, int maxLength)
            {
                return ToString(FormatReal(obj), maxLength);
            }
            public static string ToString(string s, int maxLength)
            {
                if (s.Length <= maxLength) return s;
                else return s.Substring(0, maxLength) + "...";
            }
            public static object FormatReal(object v, string format)
            {
                if (v is decimal) return ((decimal)v).ToString(format).Replace(',', '.');
                if (v is double) return ((double)v).ToString(format).Replace(',', '.');
                if (v is float) return ((float)v).ToString(format).Replace(',', '.');

                return v;
            }
            public static object FormatReal(object v)
            {
                if (v is decimal || v is double || v is float)
                {
                    return v.ToString().Replace(',', '.');
                }
                return v;
            }

            public Output()
                : this(new MemoryStream())
            {
            }
            public Output(string path)
                : this(File.Create(path))
            {

            }
            public Output(Stream s)
                : this(new StreamWriter(s))
            {
            }
            public Output(TextWriter tw)
            {
                TextWriter = tw;
            }

            public static implicit operator Output(Stream s)
            {
                return new Output(s);
            }

            public static implicit operator Output(TextWriter tw)
            {
                return new Output(tw);
            }

            public static Output operator +(Output output, object obj)
            {
                output.Write(obj);
                return output;
            }
            public Output WriteArray<T>(params T[] array)
            {
                return WriteArray<T>(array, false);
            }
            public Output WriteArray<T>(T[] array, bool appendLength)
            {
                return WriteArray<T>(array, 0, array.Length, appendLength);
            }
            public Output WriteArray<T>(T[] array, int index, int count)
            {
                return WriteArray<T>(array, index, count, false);
            }
            public Output WriteArray<T>(T[] array, int index, int count, bool appendLength)
            {
                if (index + count > array.Length)
                {
                    string message = string.Format(
                        "Index out of range: {0} + {1} >= {2}",
                        index,
                        count,
                        array.Length);
                    throw new Exception(message);
                }
                if (appendLength)
                {
                    WriteLine(count);
                }
                for (int i = 0; i < count; i++)
                {
                    Write(array[i]);
                    Write(space, 0, space.Length);
                }
                WriteLine();

                return this;
            }
            public Output WriteLine(object obj)
            {
                obj = FormatReal(obj);
                return WriteLine(obj.ToString());
            }
            public Output WriteLine(string format, params object[] args)
            {
                return WriteLine(string.Format(format, args));
            }
            public Output WriteLine(string s)
            {
                return WriteLine(s.ToCharArray());
            }
            public Output WriteLine(char[] buffer)
            {
                return WriteLine(buffer, 0, buffer.Length);
            }
            public Output WriteLine(char[] buffer, int index, int count)
            {
                TextWriter.WriteLine(buffer, index, count);
                if (AutoFlush) TextWriter.Flush();
                return this;
            }
            public Output WriteLine()
            {
                TextWriter.WriteLine();
                if (AutoFlush) TextWriter.Flush();
                return this;
            }
            public Output Write(object obj)
            {
                obj = FormatReal(obj);
                return Write(obj.ToString());
            }
            public Output Write(string format, params object[] args)
            {
                return Write(string.Format(format, args));
            }
            public Output Write(string s)
            {
                return Write(s.ToCharArray());
            }
            public Output Write(char[] buffer)
            {
                return Write(buffer, 0, buffer.Length);
            }
            public Output Write(char[] buffer, int index, int count)
            {
                TextWriter.Write(buffer, index, count);
                if (AutoFlush) TextWriter.Flush();
                return this;
            }

            public void Close()
            {
                TextWriter.Close();
            }
            public void Flush()
            {
                TextWriter.Flush();
            }

            private bool disposed = false;
            public void Dispose()
            {
                Dispose(true);
                GC.SuppressFinalize(this);
            }

            protected virtual void Dispose(bool disposing)
            {
                if (!this.disposed)
                {
                    if (disposing)
                    {
                        TextWriter.Dispose();
                    }
                    disposed = true;
                }
            }
            ~Output()
            {
                Dispose(false);
            }
        }
        public static class Parser
        {
            public static ParserDelegate<T> GetPrimitiveParser<T>()
            {
                if (!typeof(T).IsPrimitive) throw new Exception("Unknown type");
                else if (default(T) is Byte) return new ParserDelegate<Byte>(Byte.TryParse) as ParserDelegate<T>;
                else if (default(T) is Boolean) return new ParserDelegate<Boolean>(Boolean.TryParse) as ParserDelegate<T>;
                else if (default(T) is Int16) return new ParserDelegate<Int16>(Int16.TryParse) as ParserDelegate<T>;
                else if (default(T) is Int32) return new ParserDelegate<Int32>(Int32.TryParse) as ParserDelegate<T>;
                else if (default(T) is Int64) return new ParserDelegate<Int64>(Int64.TryParse) as ParserDelegate<T>;
                else if (default(T) is UInt16) return new ParserDelegate<UInt16>(UInt16.TryParse) as ParserDelegate<T>;
                else if (default(T) is UInt32) return new ParserDelegate<UInt32>(UInt32.TryParse) as ParserDelegate<T>;
                else if (default(T) is UInt64) return new ParserDelegate<UInt64>(UInt64.TryParse) as ParserDelegate<T>;
                else if (default(T) is Single) return new ParserDelegate<Single>(Parser.SingleParser) as ParserDelegate<T>;
                else if (default(T) is Double) return new ParserDelegate<Double>(Parser.DoubleParser) as ParserDelegate<T>;
                else if (default(T) is Decimal) return new ParserDelegate<Decimal>(Parser.DecimalParser) as ParserDelegate<T>;
                else if (default(T) is String) return new ParserDelegate<String>(Parser.StringParser) as ParserDelegate<T>;
                else throw new Exception("Unknown type");
            }
            public static bool YesNoParser(string s, out Boolean result)
            {
                s = s.ToLower();
                if (s == "yes") result = true;
                else if (s == "no") result = false;
                else
                {
                    result = false;
                    return false;
                }
                return true;
            }
            public static bool StringParser(string s, out string result)
            {
                result = s;
                return string.IsNullOrEmpty(s);
            }
            public static bool DecimalParser(string s, out Decimal result)
            {
                return Decimal.TryParse(s.Replace('.', ','), out result);
            }
            public static bool DoubleParser(string s, out Double result)
            {
                return Double.TryParse(s.Replace('.', ','), out result);
            }
            public static bool SingleParser(string s, out Single result)
            {
                return Single.TryParse(s.Replace('.', ','), out result);
            }
        }
        #endregion
        #region Streams
        static string endl = Environment.NewLine;
        static Input cin = new Input(Console.In);
        static Output cout = new Output(Console.Out);
        static Output cerr = new Output(Console.Error);
        #endregion
        #region Time
        //*
        static Stopwatch sw = new Stopwatch();
        static void Start()
        {
            sw.Reset();
            sw.Start();
        }
        static void Restart(string text = "")
        {
            Stop(text);
            Start();
        }
        static void Time(string text = "")
        {
            if (string.IsNullOrEmpty(text))
            {
                cerr.WriteLine(sw.Elapsed);
            }
            else
            {
                cerr.WriteLine(text + ": " + sw.Elapsed);
            }
        }
        static void Stop(string text = "")
        {
            sw.Stop();
            Time(text);
        }
        //*/
        #endregion

        static void Main()
        {
            int n = cin.ReadInt32();
            long[,] a = new long[n, n];
            for (int i = 0; i < n; i++)
            {
                a[i, 0] = a[0, i] = 1;
            }
            long max = 1;
            for (int i = 1; i < n; i++)
            {
                for (int j = 1; j < n; j++)
                {
                    a[i, j] = a[i - 1, j] + a[i, j - 1];
                    max = Math.Max(a[i, j], max);
                }
            }
            cout += max + endl;
        }
    }
}

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

namespace ConsoleApplication4
{
    class Program
    {
        static IEnumerable<int> iterator()
        {
            yield return 7;
            yield return 8;
        }
        static void Main(string[] args)
        {
            var s = Console.ReadLine();
            int x = int.Parse(s);
            int[,] table = new int[x, x];

            for (int i = 0; i < x; i++ )
                table[i,0] = table[0,i] = 1;

            for (int i = 1; i < x; i++)
                for (int j = 1; j < x; j++)
                    table[i, j] = table[i - 1, j] + table[i, j - 1];

            Console.Write(table[x-1, x-1]);

            //foreach (var v in table)
             //   Console.Write(v);

        }
    }
}

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

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            var n = int.Parse(Console.ReadLine());
            Console.WriteLine(GetMax(n, n));
        }

        private static long GetMax(int i, int j)
        {
            if (i == 1 || j == 1)
                return 1;
            return GetMax(i - 1, j) + GetMax(i, j - 1);
        }
    }
}

using System;

namespace maximum_in_table
{
    class MainClass
    {
        public static void Main (string[] args)
        {
                        int n;
                        int [] a = new int[10] { 1, 2, 6, 20, 70, 252, 924, 3432, 12870, 48620 };
                        n = int.Parse(Console.ReadLine());
                        Console.WriteLine(a[n - 1]);
                        Console.ReadLine();

                    }
                }
            }

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

namespace _codeForces__509A_
{
    class Program
    {
        static void Main(string[] args)
        {
            int input = Convert.ToInt16(Console.ReadLine());
            int[,] table = new int[input, input];
            for(int i = 0; i<input; i++)
            {
                table[i, 0] = table[0,i] = 1;
            }
            for (int i = 1; i<input; i++)
            {
                for (int j = 1; j<input; j++)
                {
                    table[i, j] = table[i - 1, j] + table[i, j - 1];
                }
            }
            Console.Write(table[input - 1, input - 1]);
       }
    }
}

using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.IO;
using System.Linq;
using System.Security;
using System.Security.Cryptography.X509Certificates;
using System.Text;

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

			public int r;
		}

		public class Comparer : IComparer<User>
		{
			public int Compare(User x, User y)
			{
				if (x.c < y.c)
					return -1;
				if (x.c != y.c) return 1;
				if (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)
		{
			if (x)
				Console.WriteLine("YES");
			else
			{
				Console.WriteLine("NO");
			}
		}

		private static void Main(string[] args)
		{
/*			var input = new StreamReader("input.txt");
			var output = new StreamWriter("output.txt");*/
			var s = Console.ReadLine();
			var arr = new int[11, 11];
			var n = int.Parse(s);
			for (var i = 1; i <= n; ++i)
				arr[i, 1] = arr[1, i] = 1;
			for (var i = 2; i <= n; ++i)
				for (var j = 2; j <= n; ++j)
					arr[i, j] = arr[i - 1, j] + arr[i, j - 1];
			Console.WriteLine(arr[n, n]);
			/*			input.Close();
			output.Close();*/
		}
	}
}

using System;
namespace Contest509ProblemA
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = Convert.ToInt32(Console.ReadLine());
            int[][] array = new int[n][];
            for (int i = 0; i < n; i++)
            {
                array[i] = new int[n];
                array[0][i] = 1;
                array[i][0] = 1;
            }
            for (int i = 1; i < n; i++)
                for (int j = 1; j < n; j++) array[i][j] = array[i - 1][j] + array[i][j - 1];
            Console.WriteLine(array[n-1][n-1]);
        }
    }
}

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

namespace CodeForces
{
    class Program
    {

        static void Main(string[] args)
        {
            int n = int.Parse(Console.ReadLine());
            int[,] values = new int[n, n];

            for (int i = 0; i < n; i++)
            {
                for (int j = 0; j < n; j++)
                {
                    if (i == 0)
                    {
                        values[i, j] = 1;
                    }
                    else if (j == 0)
                    {
                        values[i, j] = 1;

                    }
                    else
                    {
                        values[i, j] = values[i, j - 1] + values[i - 1, j];
                    }

                }

            }
            Console.WriteLine(values[n - 1, n - 1]);

        }

    }
}

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

namespace ConsoleApplication22
{
    class Program
    {

        static void Main(string[] args)
        {
            int n = int.Parse(Console.ReadLine());
            int[,] x = new int[n,n];
            int k;
            for (int i = 0; i < n; i++)
            {
                if (i == 0)
                    for (k = 0; k < n; k++)
                    {
                        x[0, k] = 1;
                        x[k - i, 0] = 1;
                    }

                else
                {
                    for ( k = 1; k < n; k++)
                    {
                        x[i,k]  = x [i-1 ,k] + x[i, k-1];
                    }

                }

            }
            Console.WriteLine(x[n-1,n-1]);

        }

    }
}

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

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

            int n = int.Parse(Console.ReadLine());
            int[,] tabla = new int[n, n];

            for (int i = 0; i < n; i++)
            {
                tabla[0, i] = 1;
                tabla[i, 0] = 1;
            }

            for (int i = 1; i < n; i++)
            {
                for (int j = 1; j < n; j++)
                {
                    tabla[i, j] = tabla[i - 1, j] + tabla[i, j - 1];
                }

            }

            //for (int i = 0; i < n; i++)
            //{
            //    for (int j = 0; j < n; j++)
            //    {
            //        Console.Write(tabla[i, j] + " ");
            //    }
            //    Console.WriteLine();

            //}
            Console.WriteLine(tabla[n - 1, n - 1]);

            Console.ReadLine();
        }
    }
}

using System;
using System.Linq;

namespace _509A
{
    class Program
    {
        static void Main()
        {
            var n = long.Parse(Console.ReadLine())-1;
            Console.WriteLine(Fact(2*n)/Fact(n)/Fact(n));
        }
        static long Fact(long num)
        {
            long i = 1;
            while(1<num)
            {
                i *= num--;
            }
            return i;
        }
    }
}

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

namespace _509A
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = Convert.ToInt32(Console.ReadLine());
            int[,] a = new int[n, n];
            for (int i = 0; i < n; i++)
            {
                a[0, i] = 1;
                a[i, 0] = 1;
            }
            for (int i = 1; i < n; i++)
            {
                for (int j = 1; j < n; j++)
                {
                    a[i, j] = a[i - 1, j] + a[i, j - 1];
                }
            }
            Console.WriteLine(a[n-1,n-1]);
        }
    }
}

using System;
using System.Linq;

namespace ConsoleApplication
{
    sealed class Program
    {
        static void Main(string[] args)
        {
            var n = Int32.Parse(Console.ReadLine());
            var m = new int[n, n];
            for (int i = 0; i < n; i++)
                m[0, i] = 1;
            for (int i = 0; i < n; i++)
                m[i, 0] = 1;
            for (int i = 1; i < n; i++)
                for (int j = 1; j < n; j++)
                    m[i, j] = m[i - 1, j] + m[i, j - 1];

            Console.WriteLine(m[n-1, n-1]);
        }
    }
}

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

namespace Codeforces
{
	class Program
	{
		static void Main(string[] args)
		{
			var n = Int();
			var arr = new int[n][];
			for (int i = 0; i < n; i++)
			{
				arr[i] = new int[n];
			}

			for (int i = 0; i < n; i++)
			{
				arr[i][0] = 1;
				arr[0][i] = 1;
			}

			for (int i =1; i < n; i++)
			{
				for (int j = 1; j < n; j++)
				{
					arr[i][j] = arr[i - 1][j] + arr[i][j - 1];
				}
			}
			Console.WriteLine(arr[n - 1][n - 1]);
		}

		static int Int()
		{
			return Int32.Parse(Console.ReadLine());
		}

		static (int, int) Int2()
		{
			var arr = Array.ConvertAll(Console.ReadLine().Split(' '), Int32.Parse);
			return (arr[0], arr[1]);
		}

		static (int, int, int) Int3()
		{
			var arr = Array.ConvertAll(Console.ReadLine().Split(' '), Int32.Parse);
			return (arr[0], arr[1], arr[2]);
		}

		static int[] Ints()
		{
			return Array.ConvertAll(Console.ReadLine().Split(' '), Int32.Parse);
		}

		static long[] Longs()
		{
			return Array.ConvertAll(Console.ReadLine().Split(' '), Int64.Parse);
		}
	}

}

using System;

namespace _509A_Recursion
{
    class Program
    {
        static void Main()
        {
            var n = int.Parse(Console.ReadLine());
            Console.WriteLine(Cell(n,n));
            Console.ReadLine();
        }
        static int Cell(int x,int y)
        {
            if (x==1||y==1)
            {
                return 1;
            }
            else
            {
                return Cell(x - 1, y) + Cell(x,y-1);
            }
        }
    }
}

using System;

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

            int[,] matrix = new int[5, rang];
            for (int i=0;i<5;i++)
                for (int j = 0; j < rang; j++)
                    try
                    {
                        matrix[i, j] = matrix[i - 1, j] + matrix[i,j - 1] ;
                    }
                    catch { matrix[i, j] = 1; }

            Console.WriteLine(matrix[4, rang - 1]) ;

        }
    }
}

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

namespace Solution
{
    class Program
    {
        static void Main(string[] args)
        {
            var n = int.Parse(Console.ReadLine());
            var table = new List<List<int>>();
            table.Add(new List<int>(new int[] {1, 1, 1, 1, 1}));
            for (var i = 1; i <= 9; i++) {
                table.Add(new List<int>(new int[5]));
                table[i][0] = 1;
                for (var j = 1; j < 5; j++)
                    table[i][j] = table[i][j-1] + table[i-1][j];
            }
            Console.WriteLine(table[n-1][4]);
        }
    }
}

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

namespace Testerka
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = Convert.ToInt32(Console.ReadLine());
            int[,] a = new int[n, n];
            for (int i = 0; i < n; i++)
            {
                a[i, 0] = 1;
                a[0, i] = 1;
            }
            for (int i = 1; i < n; i++)
            {
                for (int j = 1; j < n; j++)
                {
                    a[i, j] = a[i, j - 1] + a[i - 1, j];
                }
            }

        }

    }
}

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

namespace Problema_MAXIMO_NA_TABELA
{
    class Program
    {
        static void Main(string[] args)
        {
            int n, m = 0;

            n = int.Parse(Console.ReadLine());

            int[,] Matriz = new int[n,n];

            //Matriz para "setar" os valores na primeira linha e primeiras counas
            for(int x=0;x< n;x++)
            {
                for(int y=0;y< n;y++)
                {
                    Matriz[x, 0] = 1;
                    Matriz[0, y] = 1;
                }
            }

            //Matriz pa
            for (int i = 1; i < n; i++)
            {
                for (int j = 1; j < n; j++)
                {
                    Matriz[i, j] = Matriz[i - 1, j] + Matriz[i, j - 1];
                }
            }

            for (int a = 0; a < n; a++)
            {
                for (int b = 0; b < n; b++)
                {
                    Console.Write(Matriz[a,b]+" ");
                    m = Matriz[a, b];
                }
                Console.WriteLine();
            }
            Console.WriteLine(m);

        }
    }
}

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

namespace Problema_MAXIMO_NA_TABELA
{
    class Program
    {
        static void Main(string[] args)
        {
            int n, m = 0;

            n = int.Parse(Console.ReadLine());

            int[,] Matriz = new int[n,n];

            //Matriz para "setar" os valores na primeira linha e primeiras counas
            for(int x=0;x< n;x++)
            {
                for(int y=0;y< n;y++)
                {
                    Matriz[x, 0] = 1;
                    Matriz[0, y] = 1;
                }
            }

            //Matriz pa
            for (int i = 1; i < n; i++)
            {
                for (int j = 1; j < n; j++)
                {
                    Matriz[i, j] = Matriz[i - 1, j] + Matriz[i, j - 1];
                }
            }

            Console.WriteLine(m);

        }
    }
}

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

namespace weith
{
    class Program
    {
        static void Main(string[] args)
        {
             int n = Convert.ToInt32(Console.ReadLine());
			 int[,] a = new int[n, n];
			 for (int j = 0; j < n; j++)
			 {
				 a[0,j] = 1;
			 }
			 for (int i = 0; i < n; i++)
			 {
				 a[i,0] = 1;
			 }
			 for (int i = 1; i < n; i++)
			 {
				 for (int j = 1; j < n; j++)
				 {
					 a[i,j] = a[i-1, j] + a[i, j-1];
				 }
			 }
			 for (int i = 1; i < n; i++)
			 {
				 for (int j = 1; j < n; j++)
				 {
					 if(  i == n-1 &&  j == n-1)
					 {
						 Console.WriteLine(a[n-1, n-1]);
					 }
				 }
			 }
        }
    }
}

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)
        {
            var n = int.Parse(Console.ReadLine());
            var arr = new int[n, 2];
            for (int i = 0; i < n; i++)
            {
                arr[i, 0] = 1;
            }
            for (var tn = 1; tn < n; tn++)
            {
                arr[0, 1] = 1;
                for (int i = 1; i < n; i++)
                {
                    arr[i, 1] = arr[i - 1, 1] + arr[i, 0];
                }
                for (int i = 0; i < n; i++)
                {
                    arr[i, 0] = arr[i, 1];
                }
            }
            Console.WriteLine(arr[n-1,1]);
        }
    }
}

using System;
using System.Text;
using System.Collections.Generic;
using System.Collections;
class Problem
{
    static void Main()
    {
        int n = Convert.ToInt32( Console.ReadLine() );
        Console.WriteLine( kq( n - 1) );
    }

    private static string kq(int p)
    {
        int str = 1;
        for(int i = p + 1 ; i <= 2 * p ; i++)
            str*= i;
        for(int i = 1 ; i <= p ; i++)
            str /= i;
        return str.ToString();
    }
}

using System;

public class CodeForces
{
    public static void Main(string[] args)
    {
        int n = int.Parse(Console.ReadLine());
        long t = 1;
        int i = 1;
        while (i <= n)
        {
            t *= 11;
            ++i;
        }
        i = n / 2;
        while (i > 0)
        {
            t /= 10;
            --i;
        }
        Console.WriteLine(t % 10);
    }
}

using System;

public class CodeForces
{
    public static void Main(string[] args)
    {
        int n = int.Parse(Console.ReadLine());
        int[] c = new int[n];
        for (int i = 0; i < n; ++i)
        {
            c[i] = 1;
        }
        while (n > 1)
        {
            for (int i = 1; i < n; ++i)
            {
                c[i] = c[i - 1] + c[i];
            }
            --n;
        }
        Console.WriteLine(c[c.Length - 1]);
    }
}

using System;

public class CodeForces
{
    public static void Main(string[] args)
    {
        int n = int.Parse(Console.ReadLine());
        int[] c = new int[n];
        for (int i = 0; i < n; ++i)
        {
            c[i] = 1;
        }
        while (n > 1)
        {
            for (int i = 1; i < n; ++i)
            {
                c[i] = c[i - 1] + c[i];
            }
            --n;
        }
        Console.WriteLine(c[n - 1]);
    }
}

using System;
public abstract class Animal : Object
{
    public abstract void say();
}
public class Dog : Animal
{
    public override void say()
    {
        Console.WriteLine("Гав");
    }
    public static void hi()
    {
        Console.WriteLine("hi");
    }
}
struct lol
{
    int x, y;

};
namespace EduSharp
{
    class Program
    {
        static void swap<T>(ref T a,ref T b)
        {
            T temp = a;
            a = b;
            b = temp;
        }
        static void Main(string[] args)
        {
            int n = int.Parse(Console.ReadLine());

            if (n == 1) Console.WriteLine("1");
            else
            {
                int max = 0;
                for (int i = 2; i <= n; i++)
                {
                    int x = max + n * i;
                    if (x > max) max = x;
                }
                Console.WriteLine(max);
            }

            Console.Read();
        }
    }
}

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

namespace _509A_Maximum_in_Table
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = int.Parse(Console.ReadLine());
            int output;

            if (n == 1)
                output = 1;
            else
            {
                output = Factorial((n - 1) * 2) / (Factorial(n - 1) * Factorial(n - 1));
            }

            Console.WriteLine(output.ToString());
        }

        static int Factorial(int k)
        {
            if (k == 0)
                return 1;
            else
                return k * Factorial(k - 1);
        }
    }
}

using System;
using System.IO;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Reflection;
using System.Net.Sockets;
using System.Xml;
using System.Diagnostics;
using System.Linq;

namespace codeforcesSolution
{
    class Program
    {
        #region testlib
        public delegate ReadDelegate<T> ReadDelegate<T>(out T value);
        public delegate bool ParserDelegate<T>(string word, out T item);

        public class Input : IDisposable
        {
            private static EventArgs DefaultEventArgs = new EventArgs();

            public TextReader TextReader { get; private set; }

            public event EventHandler OnEndOfStream;
            public event EventHandler OnParseError;
            public event EventHandler OnReadError;

            public bool CanRead { get; private set; }
            public bool ThrowExceptions { get; set; }

            string line = string.Empty;
            int pos = 0;

            static EventHandler emptyHandler;

            public Input(string path)
                : this(File.OpenRead(path))
            {
            }
            public Input(Stream s)
                : this(new StreamReader(s))
            {

            }
            public Input(TextReader tr)
            {
                TextReader = tr;

                if (emptyHandler == null)
                    emptyHandler = (a, b) => { };

                OnEndOfStream = emptyHandler;
                OnParseError = emptyHandler;
                OnReadError = emptyHandler;

                CanRead = true;
            }

            public static implicit operator Input(Stream s)
            {
                return new Input(s);
            }
            public static implicit operator Input(TextReader tr)
            {
                return new Input(tr);
            }

            private bool ReadStream()
            {
                if (!CanRead) return false;
                if (pos < line.Length) return true;

                Clear();

                string s = TextReader.ReadLine();
                if (s == null)
                {
                    CanRead = false;
                    return false;
                }

                line = s;
                return true;
            }

            public ReadDelegate<T> r<T>(out T value)
            {
                value = ReadData<T>();
                return r;
            }

            public void SkipChar()
            {
                if (pos < line.Length) pos++;
                else
                {
                    ReadStream();
                }
            }
            public void SkipChars(int length)
            {
                while (length > 0)
                {
                    int dt = line.Length - pos;
                    if (dt <= 0)
                    {
                        length--;
                        if (!ReadStream()) return;
                    }
                    dt = Math.Min(length, dt);
                    pos += dt;
                    length -= dt;
                }
            }

            public void SkipWhiteSpace()
            {
                while (true)
                {
                    for (; pos < line.Length; pos++)
                    {
                        if (!char.IsWhiteSpace(line[pos])) return;
                    }
                    if (!ReadStream())
                    {
                        OnEndOfStream(this, DefaultEventArgs);
                        return;
                    }
                }
            }
            public bool CanReadData()
            {
                SkipWhiteSpace();
                return CanRead;
            }

            public T[] ReadArray<T>()
            {
                int length = ReadInt32();
                return ReadArray<T>(length);
            }
            public T[] ReadArray<T>(int length)
            {
                ParserDelegate<T> parser = Parser.GetPrimitiveParser<T>();
                return ReadArray<T>(length, parser);
            }
            public T[] ReadArray<T>(ParserDelegate<T> parser)
            {
                int length = ReadInt32();
                return ReadArray<T>(length, parser);
            }
            public T[] ReadArray<T>(int length, ParserDelegate<T> parser)
            {
                T[] res = new T[length];
                for (int i = 0; i < length; i++)
                {
                    res[i] = ReadData<T>(parser);
                }
                return res;
            }

            public Decimal ReadDecimal()
            {
                return ReadData<Decimal>(Parser.DecimalParser);
            }
            public Double ReadDouble()
            {
                return ReadData<Double>(Parser.DoubleParser);
            }
            public Single ReadSingle()
            {
                return ReadData<Single>(Parser.SingleParser);
            }
            public UInt64 ReadUInt64()
            {
                return ReadData<UInt64>(UInt64.TryParse);
            }
            public UInt32 ReadUInt32()
            {
                return ReadData<UInt32>(UInt32.TryParse);
            }
            public UInt16 ReadUInt16()
            {
                return ReadData<UInt16>(UInt16.TryParse);
            }
            public Int64 ReadInt64()
            {
                return ReadData<Int64>(Int64.TryParse);
            }
            public Int32 ReadInt32()
            {
                return ReadData<Int32>(Int32.TryParse);
            }
            public Int16 ReadInt16()
            {
                return ReadData<Int16>(Int16.TryParse);
            }
            public Boolean ReadYesNo()
            {
                return ReadData<Boolean>(Parser.YesNoParser);
            }
            public Boolean ReadBoolean()
            {
                return ReadData<Boolean>(Boolean.TryParse);
            }
            public Byte ReadByte()
            {
                return ReadData<Byte>(Byte.TryParse);
            }

            private bool ReadCheck()
            {
                if (!CanRead)
                {
                    OnReadError(this, DefaultEventArgs);
                    if (ThrowExceptions)
                    {
                        throw new Exception("!CanRead");
                    }
                    return false;
                }
                return true;
            }
            public T ReadData<T>()
            {
                return ReadData<T>(true);
            }
            public T ReadData<T>(bool skipWhiteSpace)
            {
                ParserDelegate<T> parser = Parser.GetPrimitiveParser<T>();
                return ReadData<T>(parser, skipWhiteSpace);
            }
            public T ReadData<T>(ParserDelegate<T> parser)
            {
                return ReadData<T>(parser, true);
            }
            public T ReadData<T>(ParserDelegate<T> parser, bool skipWhiteSpace)
            {
                if (skipWhiteSpace)
                    SkipWhiteSpace();

                if (!ReadCheck()) return default(T);

                string s = ReadWord(false);

                T res;
                if (!parser.Invoke(s, out res))
                {
                    OnParseError(this, DefaultEventArgs);
                    if (ThrowExceptions)
                    {
                        throw new Exception("!validate, word = " + Output.ToString(s, 256));
                    }
                }
                return res;
            }

            public string ReadWord()
            {
                return ReadWord(true);
            }
            public string ReadWord(bool skipWhiteSpace)
            {
                if (skipWhiteSpace)
                    SkipWhiteSpace();

                if (!ReadCheck()) return string.Empty;

                int from = pos;
                int to = pos;
                for (int i = pos; i < line.Length; i++)
                {
                    if (char.IsWhiteSpace(line[i])) break;
                    to = i + 1;
                }
                pos = to;

                return line.Substring(from, to - from);
            }

            public string ReadLine()
            {
                if (!ReadCheck()) return string.Empty;

                ReadStream();
                string res = line.Substring(pos);
                pos = line.Length;

                return res;
            }

            public void Close()
            {
                TextReader.Close();
            }
            public void Clear()
            {
                pos = 0;
                line = string.Empty;
            }

            private bool disposed = false;
            public void Dispose()
            {
                Dispose(true);
                GC.SuppressFinalize(this);
            }

            protected virtual void Dispose(bool disposing)
            {
                if (!this.disposed)
                {
                    if (disposing)
                    {
                        line = string.Empty;
                        TextReader.Dispose();
                    }
                    disposed = true;
                }
            }
            ~Input()
            {
                Dispose(false);
            }
        }
        public class Output : IDisposable
        {
            static char[] space = new char[] { ' ' };

            public TextWriter TextWriter { get; private set; }
            public bool AutoFlush { get; set; }

            public static string ToString(object obj, int maxLength)
            {
                return ToString(FormatReal(obj), maxLength);
            }
            public static string ToString(string s, int maxLength)
            {
                if (s.Length <= maxLength) return s;
                else return s.Substring(0, maxLength) + "...";
            }
            public static object FormatReal(object v, string format)
            {
                if (v is decimal) return ((decimal)v).ToString(format).Replace(',', '.');
                if (v is double) return ((double)v).ToString(format).Replace(',', '.');
                if (v is float) return ((float)v).ToString(format).Replace(',', '.');

                return v;
            }
            public static object FormatReal(object v)
            {
                if (v is decimal || v is double || v is float)
                {
                    return v.ToString().Replace(',', '.');
                }
                return v;
            }

            public Output()
                : this(new MemoryStream())
            {
            }
            public Output(string path)
                : this(File.Create(path))
            {

            }
            public Output(Stream s)
                : this(new StreamWriter(s))
            {
            }
            public Output(TextWriter tw)
            {
                TextWriter = tw;
            }

            public static implicit operator Output(Stream s)
            {
                return new Output(s);
            }

            public static implicit operator Output(TextWriter tw)
            {
                return new Output(tw);
            }

            public static Output operator +(Output output, object obj)
            {
                output.Write(obj);
                return output;
            }
            public Output WriteArray<T>(params T[] array)
            {
                return WriteArray<T>(array, false);
            }
            public Output WriteArray<T>(T[] array, bool appendLength)
            {
                return WriteArray<T>(array, 0, array.Length, appendLength);
            }
            public Output WriteArray<T>(T[] array, int index, int count)
            {
                return WriteArray<T>(array, index, count, false);
            }
            public Output WriteArray<T>(T[] array, int index, int count, bool appendLength)
            {
                if (index + count > array.Length)
                {
                    string message = string.Format(
                        "Index out of range: {0} + {1} >= {2}",
                        index,
                        count,
                        array.Length);
                    throw new Exception(message);
                }
                if (appendLength)
                {
                    WriteLine(count);
                }
                for (int i = 0; i < count; i++)
                {
                    Write(array[i]);
                    Write(space, 0, space.Length);
                }
                WriteLine();

                return this;
            }
            public Output WriteLine(object obj)
            {
                obj = FormatReal(obj);
                return WriteLine(obj.ToString());
            }
            public Output WriteLine(string format, params object[] args)
            {
                return WriteLine(string.Format(format, args));
            }
            public Output WriteLine(string s)
            {
                return WriteLine(s.ToCharArray());
            }
            public Output WriteLine(char[] buffer)
            {
                return WriteLine(buffer, 0, buffer.Length);
            }
            public Output WriteLine(char[] buffer, int index, int count)
            {
                TextWriter.WriteLine(buffer, index, count);
                if (AutoFlush) TextWriter.Flush();
                return this;
            }
            public Output WriteLine()
            {
                TextWriter.WriteLine();
                if (AutoFlush) TextWriter.Flush();
                return this;
            }
            public Output Write(object obj)
            {
                obj = FormatReal(obj);
                return Write(obj.ToString());
            }
            public Output Write(string format, params object[] args)
            {
                return Write(string.Format(format, args));
            }
            public Output Write(string s)
            {
                return Write(s.ToCharArray());
            }
            public Output Write(char[] buffer)
            {
                return Write(buffer, 0, buffer.Length);
            }
            public Output Write(char[] buffer, int index, int count)
            {
                TextWriter.Write(buffer, index, count);
                if (AutoFlush) TextWriter.Flush();
                return this;
            }

            public void Close()
            {
                TextWriter.Close();
            }
            public void Flush()
            {
                TextWriter.Flush();
            }

            private bool disposed = false;
            public void Dispose()
            {
                Dispose(true);
                GC.SuppressFinalize(this);
            }

            protected virtual void Dispose(bool disposing)
            {
                if (!this.disposed)
                {
                    if (disposing)
                    {
                        TextWriter.Dispose();
                    }
                    disposed = true;
                }
            }
            ~Output()
            {
                Dispose(false);
            }
        }
        public static class Parser
        {
            public static ParserDelegate<T> GetPrimitiveParser<T>()
            {
                if (!typeof(T).IsPrimitive) throw new Exception("Unknown type");
                else if (default(T) is Byte) return new ParserDelegate<Byte>(Byte.TryParse) as ParserDelegate<T>;
                else if (default(T) is Boolean) return new ParserDelegate<Boolean>(Boolean.TryParse) as ParserDelegate<T>;
                else if (default(T) is Int16) return new ParserDelegate<Int16>(Int16.TryParse) as ParserDelegate<T>;
                else if (default(T) is Int32) return new ParserDelegate<Int32>(Int32.TryParse) as ParserDelegate<T>;
                else if (default(T) is Int64) return new ParserDelegate<Int64>(Int64.TryParse) as ParserDelegate<T>;
                else if (default(T) is UInt16) return new ParserDelegate<UInt16>(UInt16.TryParse) as ParserDelegate<T>;
                else if (default(T) is UInt32) return new ParserDelegate<UInt32>(UInt32.TryParse) as ParserDelegate<T>;
                else if (default(T) is UInt64) return new ParserDelegate<UInt64>(UInt64.TryParse) as ParserDelegate<T>;
                else if (default(T) is Single) return new ParserDelegate<Single>(Parser.SingleParser) as ParserDelegate<T>;
                else if (default(T) is Double) return new ParserDelegate<Double>(Parser.DoubleParser) as ParserDelegate<T>;
                else if (default(T) is Decimal) return new ParserDelegate<Decimal>(Parser.DecimalParser) as ParserDelegate<T>;
                else if (default(T) is String) return new ParserDelegate<String>(Parser.StringParser) as ParserDelegate<T>;
                else throw new Exception("Unknown type");
            }
            public static bool YesNoParser(string s, out Boolean result)
            {
                s = s.ToLower();
                if (s == "yes") result = true;
                else if (s == "no") result = false;
                else
                {
                    result = false;
                    return false;
                }
                return true;
            }
            public static bool StringParser(string s, out string result)
            {
                result = s;
                return string.IsNullOrEmpty(s);
            }
            public static bool DecimalParser(string s, out Decimal result)
            {
                return Decimal.TryParse(s.Replace('.', ','), out result);
            }
            public static bool DoubleParser(string s, out Double result)
            {
                return Double.TryParse(s.Replace('.', ','), out result);
            }
            public static bool SingleParser(string s, out Single result)
            {
                return Single.TryParse(s.Replace('.', ','), out result);
            }
        }
        #endregion
        #region Streams
        static string endl = Environment.NewLine;
        static Input cin = new Input(Console.In);
        static Output cout = new Output(Console.Out);
        static Output cerr = new Output(Console.Error);
        #endregion
        #region Time
        //*
        static Stopwatch sw = new Stopwatch();
        static void Start()
        {
            sw.Reset();
            sw.Start();
        }
        static void Restart(string text = "")
        {
            Stop(text);
            Start();
        }
        static void Time(string text = "")
        {
            if (string.IsNullOrEmpty(text))
            {
                cerr.WriteLine(sw.Elapsed);
            }
            else
            {
                cerr.WriteLine(text + ": " + sw.Elapsed);
            }
        }
        static void Stop(string text = "")
        {
            sw.Stop();
            Time(text);
        }
        //*/
        #endregion

        static void Main()
        {
            int n = cin.ReadInt32();
            long[,] a = new long[n, n];
            for (int i = 0; i < n; i++)
            {
                a[i, 0] = a[0, i] = 1;
            }
            long max = 0;
            for (int i = 1; i < n; i++)
            {
                for (int j = 1; j < n; j++)
                {
                    a[i, j] = a[i - 1, j] + a[i, j - 1];
                    max = Math.Max(a[i, j], max);
                }
            }
            cout += max + endl;
        }
    }
}

using System;
using System.Linq;

namespace _509A
{
    class Program
    {
        static void Main()
        {
            var n = int.Parse(Console.ReadLine())-1;
            Console.WriteLine(Fact(2*n)/Fact(n)/Fact(n));
        }
        static int Fact(int num)
        {
            int i = 1;
            while(1<num)
            {
                i *= num--;
            }
            return i;
        }
    }
}