dae

#include<iostream>

bool canDoubleToWin(int boardPoints,int pointsNeeded)
{
	if (pointsNeeded <= 0)
		return false;

	return (boardPoints * 2) == pointsNeeded;
}

int doublePoints(int boardPoints)
{
	return boardPoints * 2;
}

int triplePoints(int boardPoints)
{
	return boardPoints * 3;
}

int main()
{
	int pointsNeeded;
	std::cin >> pointsNeeded;

	int boardPoints[] = { 0,1,2,3,4,5,6,7,8,9,10,
					      11,12,13,14,15,16,17,18,19,20 };

	const int MIN_BOARD = 0;
	const int MAX_BOARD = 21;


	int possibleOuts = 0;
	for(int i=MIN_BOARD;i<MAX_BOARD;i++)
	{

		if (canDoubleToWin(i, pointsNeeded))
			possibleOuts++;

		int pointsAfterNormal = pointsNeeded - i;
		int pointsAfterDouble = pointsNeeded - doublePoints(i);
		int pointsAfterTriple = pointsNeeded - triplePoints(i);
		int pointsAfterInnerBull = pointsNeeded - 50;
		int pointsAfterOuterBull = pointsNeeded - 25;

		for(int j=MIN_BOARD;j<MAX_BOARD;j++)
		{
			//Check if you can double by normal,double or triple

			//Normal Double
			if (canDoubleToWin(doublePoints(j), pointsAfterNormal))
				possibleOuts++;

			if (canDoubleToWin(doublePoints(j), pointsAfterDouble))
				possibleOuts++;

			if (canDoubleToWin(doublePoints(j), pointsAfterTriple))
				possibleOuts++;

			if (canDoubleToWin(doublePoints(j), pointsAfterInnerBull))
				possibleOuts++;

			if (canDoubleToWin(doublePoints(j), pointsAfterOuterBull))
				possibleOuts++;

			//After Normal Shot Possibilities

			int pointsAfterNormalNormal = pointsAfterNormal - j;
			int pointsAfterNormalDouble = pointsAfterNormal - doublePoints(j);
			int pointsAfterNormalTriple = pointsAfterNormal - triplePoints(j);

			int pointsAfterNormalInner = pointsAfterNormal - 50;
			int pointsAfterNormalOuter = pointsAfterNormal - 25;


			//After Double Shot Possibilities

			int pointsAfterDoubleNormal = pointsAfterDouble - j;
			int pointsAfterDoubleDouble = pointsAfterDouble - doublePoints(j);
			int pointsAfterDoubleTriple = pointsAfterDouble - triplePoints(j);

			int pointsAfterDoubleInner = pointsAfterDouble - 50;
			int pointsAfterDoubleOuter = pointsAfterDouble - 25;


			//After Triple Shot Possibilities

			int pointsAfterTripleNormal = pointsAfterTriple - j;
			int pointsAfterTripleDouble = pointsAfterTriple - doublePoints(j);
			int pointsAfterTripleTriple = pointsAfterTriple - triplePoints(j);

			int pointsAfterTripleInner = pointsAfterTriple - 50;
			int pointsAfterTripleOuter = pointsAfterTriple - 25;

			//After InnerBullEye Shot Possibilities

			int pointsAfterInnerBullNormal = pointsAfterInnerBull - j;
			int pointsAfterInnerBullDouble = pointsAfterInnerBull - doublePoints(j);
			int pointsAfterInnerBullTriple = pointsAfterInnerBull - triplePoints(j);

			int pointsAfterInnerBullInner = pointsAfterInnerBull - 50;
			int pointsAfterInnerBullOuter = pointsAfterInnerBull - 25;


			//After OuterBullEye Shot Possibilities


			int pointsAfterOuterBullNormal = pointsAfterOuterBull - j;
			int pointsAfterOuterBullDouble = pointsAfterOuterBull - doublePoints(j);
			int pointsAfterOuterBullTriple = pointsAfterOuterBull - triplePoints(j);

			int pointsAfterOuterBullOuter = pointsAfterOuterBull - 25;
			int pointsAfterOuterBullInner = pointsAfterOuterBull - 50;

			for(int k=MIN_BOARD;k<MAX_BOARD;k++)
			{
				////After Normal Shot Possibilities  To Result
				if (canDoubleToWin(doublePoints(k), pointsAfterNormalInner))
						possibleOuts++;

				if (canDoubleToWin(doublePoints(k), pointsAfterNormalOuter))
						possibleOuts++;

				if (canDoubleToWin(doublePoints(k), pointsAfterNormalNormal))
					possibleOuts++;

				if (canDoubleToWin(doublePoints(k), pointsAfterNormalDouble))
					possibleOuts++;

				if (canDoubleToWin(doublePoints(k), pointsAfterNormalTriple))
					possibleOuts++;
				// last Double check for outs

				//AfterDoubleShotPossibilities

				if (canDoubleToWin(doublePoints(k), pointsAfterDoubleNormal))
					possibleOuts++;

				if (canDoubleToWin(doublePoints(k), pointsAfterDoubleDouble))
					possibleOuts++;

				if (canDoubleToWin(doublePoints(k), pointsAfterDoubleTriple))
					possibleOuts++;

				if (canDoubleToWin(doublePoints(k), pointsAfterDoubleInner))
					possibleOuts++;

				if (canDoubleToWin(doublePoints(k), pointsAfterDoubleOuter))
					possibleOuts++;

				//After Triple Possibilities

				if (canDoubleToWin(doublePoints(k), pointsAfterTripleNormal))
					possibleOuts++;

				if (canDoubleToWin(doublePoints(k), pointsAfterTripleDouble))
					possibleOuts++;

				if(canDoubleToWin(doublePoints(k), pointsAfterTripleTriple))
					possibleOuts++;

				if (canDoubleToWin(doublePoints(k), pointsAfterTripleInner))
					possibleOuts++;

				if (canDoubleToWin(doublePoints(k), pointsAfterTripleOuter))
					possibleOuts++;

				//After 50 Possibilities

				if (canDoubleToWin(doublePoints(k), pointsAfterInnerBullNormal))
					possibleOuts++;

				if (canDoubleToWin(doublePoints(k), pointsAfterInnerBullDouble))
					possibleOuts++;

				if (canDoubleToWin(doublePoints(k), pointsAfterInnerBullTriple))
					possibleOuts++;

				if (canDoubleToWin(doublePoints(k), pointsAfterInnerBullOuter))
					possibleOuts++;

				if (canDoubleToWin(doublePoints(k), pointsAfterInnerBullInner))
					possibleOuts++;

				//After 25 Possibilities

				if (canDoubleToWin(doublePoints(k), pointsAfterOuterBullNormal))
					possibleOuts++;

				if (canDoubleToWin(doublePoints(k), pointsAfterOuterBullDouble))
					possibleOuts++;

				if (canDoubleToWin(doublePoints(k), pointsAfterOuterBullTriple))
					possibleOuts++;

				if (canDoubleToWin(doublePoints(k), pointsAfterOuterBullInner))
					possibleOuts++;

				if (canDoubleToWin(doublePoints(k), pointsAfterOuterBullOuter))
					possibleOuts++;
			}

		}

	}

	std::cout << possibleOuts << std::endl;

	return 0;
}