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

#define BN_MAX	2600

/*
 * representacao em num é do indice 0 e por ordem inversa
 * por ex, 123 fica num[0] = 3, num[1] = 2, num[2] = 1
 *
 * nao sao feitos checks de overflow, o BN_MAX tem de chegar
 */

struct BigNum {
	int size;
	int sign;
	char num[BN_MAX];
};

typedef struct BigNum BigNum;

void bignum_2str(BigNum *a, char *s)
{
	int i;
	if (a->sign == -1)
		*s++ = '-';
	if (a->size == 0)
		*s++ = '0';
	for (i = a->size-1; i >= 0; i--)
		*s++ = a->num[i] + '0';
	*s = '\0';
}

void bignum_str2(char *s, BigNum *r)
{
	int i;
	r->sign = *s == '-' ? s++, -1 : 1;
	while (*s == '0' && *s != '\0')
		s++;
	r->size = strlen(s);
	for (i = r->size-1; i >= 0; i--)
		r->num[i] = (*s++) - '0';
}

void bignum_copy(BigNum *a, BigNum *r)
{
	r->sign = a->sign;
	r->size = a->size;
	memcpy(r->num, a->num, r->size);
}

void bignum_add(BigNum *a, BigNum *b, BigNum *r)
{
	int i, j, k, carry, tmp;
	
	if (a->sign == b->sign) {
		r->sign = a->sign;

		i = j = k = carry = 0;
		while (i < a->size || j < b->size || carry) {
			tmp = carry;
			carry = 0;
			tmp += i < a->size ? a->num[i++] : 0;
			tmp += j < b->size ? b->num[j++] : 0;
			if (tmp >= 10) {
				carry = 1;
				tmp -= 10;
			}
			r->num[k++] = tmp;
		}
		r->size = k;
	}
}

void bignum_mul(BigNum *a, BigNum *b, BigNum *r)
{
	static BigNum amults[10];
	BigNum *c;
	int i, j, k, carry, base;
	char *num = r->num;
	
	r->sign = a->sign == b->sign ? 1: -1;

	if (a->size < b->size) {
		c = a;
		a = b;
		b = c;
	}
	
	bignum_str2("0", amults+0);
	bignum_copy(a, amults+1);
	for (i = 2; i < 10; i++) {
		bignum_add(a, amults + i - 1, amults + i);
	}

	for (i = 0; i < BN_MAX; i++)
		num[i] = 0;

	j = base = 0;
	for (i = 0; i < b->size; i++) {
		c = amults + b->num[i];
		
		k = carry = 0;
		j = base;
		while (k < c->size) {
			num[j] += c->num[k] + carry;
			carry = 0;
			if (num[j] >= 10) {
				num[j] -= 10;
				carry = 1;
			}
			k++, j++;
		}
		if (carry)
			num[j++] = 1;

		base++;
	}

	r->size = j;
}

char s[BN_MAX];
BigNum f, tmp, one, f2;
char factorial[1001][BN_MAX+1];

int main()
{
	int i, n;

	bignum_str2("1", &f);
	bignum_str2("1", &one);
	bignum_str2("0", &tmp);
	bignum_2str(&f, factorial[0]);
	for (i = 1; i <= 1000; i++) {
		bignum_add(&tmp, &one, &tmp);
		bignum_mul(&f, &tmp, &f2);
		bignum_copy(&f2, &f);
		bignum_2str(&f, factorial[i]);
	}

	while (scanf("%d", &n) != EOF) {
		printf("%d!\n%s\n", n, factorial[n]);
	}

	return 0;
}