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

// Hàm đảo ngược chuỗi
void daonguoc(char *s) {
    int l = 0, r = strlen(s) - 1;
    while (l < r) {
        char temp = s[l];
        s[l] = s[r];
        s[r] = temp;
        l++; r--;
    }
}

// Hàm nhân hai chuỗi số lớn
char *nhansolon(const char *a, const char *b) {
    if (strcmp(a, "0") == 0 || strcmp(b, "0") == 0) return "0";

    int len1 = strlen(a);
    int len2 = strlen(b);
    // Kết quả có tối đa len1 + len2 chữ số
    int *res = (int *)calloc(len1 + len2 + 1, sizeof(int));

    // Đảo chuỗi để tính toán từ chữ số cuối
    char *s1 = strdup(a); daonguoc(s1);
    char *s2 = strdup(b); daonguoc(s2);

    for (int i = 0; i < len1; i++) {
        for (int j = 0; j < len2; j++) {
            res[i + j] += (s1[i] - '0') * (s2[j] - '0');
        }
    }

    // Xử lý nhớ
    for (int i = 0; i < len1 + len2; i++) {
        if (res[i] >= 10) {
            res[i + 1] += res[i] / 10;
            res[i] %= 10;
        }
    }

    // Xác định độ dài thực tế của kết quả
    int len = len1 + len2;
    while (len > 1 && res[len - 1] == 0) len--;

    char *final = (char *)malloc(len + 1);
    for (int i = 0; i < len; i++) final[i] = res[len - 1 - i] + '0';
    final[len] = '\0';

    free(s1); free(s2); free(res);
    return final;
}

int main() {
    int t;
    scanf("%d", &t);
    while (t--) {
        int n;
        scanf("%d", &n);
        char *ans = (char *)malloc(2);
        strcpy(ans, "1");
        for (int i = 1; i <= n; i++) {
            char num[20];
            sprintf(num, "%d", i);
            ans = nhansolon(ans, num);
        }
        printf("%s\n", ans);
    }
    return 0;
}

#include <stdio.h>

int main() {
    int t;
    scanf("%d", &t);
    while(t--) {
        int n;
        scanf("%d", &n);
        if(n == 0 || n == 1) {
            printf("1\n");
            continue;
        }

        // Mảng lưu các chữ số của kết quả, ngược với thứ tự in
        int kq[5000] = {0};
        kq[0] = 1;
        int len = 1;

        for(int i = 2; i <= n; i++) {
            int du = 0;
            // Nhân từng chữ số của kết quả hiện tại với i
            for(int j = 0; j < len; j++) {
                int tmp = kq[j] * i + du;
                kq[j] = tmp % 10;
                du = tmp / 10;
            }
            // Xử lý số nhớ còn lại, tăng độ dài mảng
            while(du) {
                kq[len] = du % 10;
                du /= 10;
                len++;
            }
        }
        // In kết quả theo thứ tự từ chữ số hàng đầu
        for(int i = len - 1; i >= 0 ;i--) {
            printf("%d", kq[i]);
        }
        printf("\n");
    }
    return 0;
}

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>

using namespace std;

// Cấu trúc lưu trữ kết quả giai thừa
struct Factorial {
    vector<int> digits; // Lưu các chữ số, digits[0] là chữ số thấp nhất
    Factorial() {
        digits.push_back(1);
    }
};

// Mảng global để lưu kết quả DP
Factorial dp[1001];

// Hàm khởi tạo DP
void precompute() {
    for (int i = 1; i <= 1000; i++) {
        dp[i] = dp[i-1]; // Gán bằng kết quả trước đó
        int carry = 0;
        for (int j = 0; j < dp[i].digits.size(); j++) {
            int prod = dp[i].digits[j] * i + carry;
            dp[i].digits[j] = prod % 10;
            carry = prod / 10;
        }
        while (carry) {
            dp[i].digits.push_back(carry % 10);
            carry /= 10;
        }
    }
}

int main() {
    precompute();
    int t;
    if (cin >> t) {
        while (t--) {
            int n;
            cin >> n;
            // In từ chữ số cao nhất về thấp nhất
            for (int i = dp[n].digits.size() - 1; i >= 0; i--) {
                cout << dp[n].digits[i];
            }
            cout << endl;
        }
    }
    return 0;
}