#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define SIZE_CHAR 1

#define NDEBUG
#define NDEBUG_DEEP

//Сумма двух строк
char* sum_string_string(const char* s1, unsigned int p1, const char* s2, unsigned int p2)
{
	if (s1 == NULL || s2 == NULL)
	{
		return NULL;
	}
	int p_max, p_min, delta;
	const char* s_min;
	const char* s_max;

	(p1 > p2) ? (p_max = p1, p_min = p2, s_min = s2,s_max=s1) : (p_max = p2, p_min = p1, s_min = s1,s_max=s2);
	delta = p_max - p_min;
	char* s_temp = (char*)malloc(p_max*SIZE_CHAR);
	for (int i = 0; i < delta; ++i)
	{
		*(s_temp + i) = '0';
	}
	for (int i = delta; i < p_max; ++i)
	{
		*(s_temp + i) = *(s_min + i - delta);
	}

	int pow_res = p_max;
	char* res = (char*)malloc(pow_res*SIZE_CHAR);
	unsigned char d = 0;
	for (int i = pow_res - 2; i >= 0; --i)
	{
		int t = *(s_max + i) + *(s_temp + i) - 2 * '0';
		t = t + d;
		d = t / 10;
		*(res + i) = t - 10 * d + '0';
	}
	if (d > 0)
	{
		pow_res += 1;
		res = (char*)realloc(res,pow_res*SIZE_CHAR);
		//побайтовый сдвиг
		for (int i = pow_res - 2; i >= 0; --i)
		{
			*(res + i + 1) = *(res + i);
		}
		*(res + 0) = d + '0';
	}

	*(res + pow_res - 1) = '\0';

	free(s_temp);
	return res;
	}

//Произведение строки из числе на число меньше 10, на вход должна подавать Си-строка, колиечество символов строки, число.
char* mpl_string_to_const(const char* s, unsigned int pow_s, unsigned char c)
{
	if (s == NULL || c >= 10)
	{
		return NULL;
	}
	if (c == 0)
	{
		char* res = (char*)malloc(2);
		*(res + 0) = '0';
		*(res + 1) = '\0';
		return res;
	}

	char* res=NULL;
	res= (char*)realloc(res,pow_s*SIZE_CHAR);
	unsigned char d = 0;
	
	for (int i = pow_s-2; i >=0; --i)
	{
		char t = (*(s + i)-'0')*c;
		t += d;
		d = t/10;
		*(res + i) = (t - 10 * d)+'0';
	}
	if (d > 0)
	{
		pow_s+=1;
		res = (char*)realloc(res, pow_s*SIZE_CHAR);
		//побайтовый сдвиг
		for (int i = pow_s-2; i>=0; --i)
		{
			*(res + i +1) = *(res + i);
		}
		*(res + 0) = d+'0';
	}
	*(res + pow_s-1) = '\0';
	return res;
}

//Произведение двух строк
char* mpl_str_to_str(const char* s1, unsigned p1, const char* s2, unsigned p2)
{
	if (s1 == NULL || s2 == NULL)
	{
		return NULL;
	}
	char* res = (char*)malloc(2 * SIZE_CHAR);
	*res = '0';
	*(res + 1) = '\0';
	unsigned p_res = 2;
	
	for (int i = 0; i < p2 - 1; ++i)
	{
		char* t = mpl_string_to_const(s1, p1, *(s2 + i)-'0');
		unsigned p_p = strlen(t);
		unsigned p_c = strlen(t) + p2 - i-1;
		t = (char*)realloc(t, p_c);
		for (int i = p_p; i < p_c-1; ++i)
		{
			*(t + i) = '0';
		}
		*(t + p_c - 1) = '\0';
		res = sum_string_string(res, p_res, t, p_c);
		p_res = strlen(res) + 1;

	}
	return res;
}

char* get_big_factorial(unsigned a)
{
	char* res = (char*)malloc(2 * SIZE_CHAR);
	*res = '1';
	*(res + 1) = '\0';

	if (a == 0 || a == 1)
	{
		return res;
	}

	for (int i = 1; i <= a; ++i)
	{
		char* t=(char*)malloc(10);
		sprintf(t, "%d", i);
		res = mpl_str_to_str(res, strlen(res) + 1, t, strlen(t) + 1);
	}
	return res;


}

int main(int argc, char** argv)
{
	FILE* in = fopen("input.txt", "r");
	if (!in)
	{
		printf("File 'input.txt' not found.\n");
		return 0;
	}

	int a;
	fscanf(in, "%i", &a);
	char* b = (char*)malloc(50000);

	FILE* out = fopen("output.txt", "w");
	
	b = get_big_factorial(a);
	fprintf(out, "%s", b);
	
	fclose(in);
	fclose(out);
	return 0;
}

#define MAX_POW 1001+1
//сумма двух целых неотрицательных чисел s1,s2>=0
char* la_sum(const char* s0, const char* s1)
{
	int len[2] = { strlen(s0), strlen(s1) };
	int max_i = (len[0] > len[1]) ? 0 : 1; //индекс максимальной строки
	int min_i = 1 - max_i;//индекс минимальной строки
	const char* max_s = (max_i == 0) ? s0 : s1;
	const char* min_s = (min_i == 0) ? s0 : s1;

	if (len[max_i] > MAX_POW - 1)
	{
		printf("Incorrect size of the string(s).\n");
		return NULL;
	}
	
	int len_res = len[max_i] + 1 + 1;//просим на 1 Байт больше чтобы исключить вероятность повторного аллоцирования
	char* res = (char*)malloc(len_res*sizeof(char));
	for (int i = 0; i < len_res; ++i)
	{
		*(res + i) = '0';
	}


	for (int i = 0; i < len[min_i]; ++i)//пишем в конец результирующей строки минимальное число
	{
		*(res + len[max_i] - len[min_i] + i + 1) = *(min_s + i);
	}

	//основная часть алгоритма
	int d = 0;
	for (int i = len_res - 2; i > 0; i--)
	{
		int t0 = *(res + i) + *(max_s + i-1) + d - 2 * '0';
		int t1 = t0 % 10;
		*(res + i) = t1 + '0';
		d = (t0>=10) ? 1 : 0;
	}
	*(res + len_res - 1) = '\0';
	if (d == 0)//сдвиг
	{
		for (int i = 0; i < len_res-1; ++i)
		{
			*(res + i) = *(res + i + 1);
		}
	}
	else
	{
		*(res + 0) = d + '0';
	}
	return res;
}

	for (int i = 0; i < len_res; ++i)
	{
		*(res + i) = '0';
	}

char* la_sum2(const char* s0, const char* s1)
{
	int len[2] = { strlen(s0), strlen(s1) };
	int max_i = (len[0] > len[1]) ? 0 : 1; //индекс максимальной строки
	int min_i = 1 - max_i;//индекс минимальной строки
	const char* max_s = (max_i == 0) ? s0 : s1;
	const char* min_s = (min_i == 0) ? s0 : s1;

	if (len[max_i] > MAX_POW - 1)
	{
		printf("Incorrect size of the string(s).\n");
		return NULL;
	}

	int len_res = len[max_i] + 1 + 1;//просим на 1 Байт больше чтобы исключить вероятность повторного аллоцирования
	char* res = (char*)malloc(len_res*sizeof(char));
	memset(res, '0', len_res);//установка стартового значения
	memcpy(res + len[max_i] - len[min_i] + 1, min_s, len[min_i]);//пишем в конец результирующей строки минимальное число

	//основная часть алгоритма
	int d = 0;
	for (int i = len_res - 2; i > 0; i--)
	{
		int t0 = *(res + i) + *(max_s + i - 1) + d - 2 * '0';
		int t1 = t0 % 10;
		*(res + i) = t1 + '0';
		d = (t0 >= 10) ? 1 : 0;
	}
	*(res + len_res - 1) = '\0';
	if (d == 0)
	{
		memmove(res, res + 1, len_res - 1);//сдвиг
	}
	else
	{
		*(res + 0) = d + '0';
	}
	return res;
}

		for (int i = 0; i < len_res-1; ++i)
		{
			*(res + i) = *(res + i + 1);
		}

memmove(res, res + 1, len_res - 1);//сдвиг

char* la_sum3(const char* s0, const char* s1)
{
	int len[2] = { strlen(s0), strlen(s1) };
	int max_i = (len[0] > len[1]) ? 0 : 1; //индекс максимальной строки
	int min_i = 1 - max_i;//индекс минимальной строки
	const char* max_s = (max_i == 0) ? s0 : s1;
	const char* min_s = (min_i == 0) ? s0 : s1;

	if (len[max_i] > MAX_POW - 1)
	{
		printf("Incorrect size of the string(s).\n");
		return NULL;
	}

	int len_res = len[max_i] + 1 + 1;//просим на 1 Байт больше чтобы исключить вероятность повторного аллоцирования
	char* res = (char*)malloc(len_res*sizeof(char));
	memset(res, '0', len_res);//установка стартового значения
	memcpy(res + len[max_i] - len[min_i] + 1, min_s, len[min_i]);//пишем в конец результирующей строки минимальное число

	//основная часть алгоритма
	int d = 0;
	for (int i = len_res - 2; i > 0; i--)
	{
		int t0 = *(res + i) + *(max_s + i - 1) + d - 2 * '0';
		int t1 = t0 % 10;
		*(res + i) = t1 + '0';
		d = (t0 >= 10) ? 1 : 0;
	}
	*(res + len_res - 1) = '\0';
	(!d) ? (char)memmove(res, res + 1, len_res - 1) : *(res + 0) = d + '0';
	
	return res;
}