public static void extraLongFactorials(int n) {
        BigInteger fact=BigInteger.ONE;
        
        for(int i=1; i<=n; i++){
            fact = fact.multiply(BigInteger.valueOf(i));
        } 
        System.out.println(fact);
    }

void coutVector(vector<int> *a) {
    int len = (*a).size();
    for(int i = 0; i < len; i++) {
        cout << (*a)[i];
    }
}

/**
 * This function bring every character of
 * string `a` to vector `b` under int type
 * Input: a is a string with number characters
 * Input: b is a blank vector
 * Effect: b is changed with full of number got from
 *  string a's number characters, but in reverse way
 */
void translateStringToVector(string a, vector<int> *b) {
    for(int i = a.size() - 1; i >= 0; i--) {
        (*b).push_back(a[i] - 48);
    }
}

vector<int> surplusVaN(vector<int> a, int n) {
    vector<int> result{};
    vector<int> b{};
    translateStringToVector(to_string(n), &b);
      
    vector<int> *maxV {};
    if(a.size() >= b.size()) {
        maxV = &a;
    } else {
        maxV = &b;
    }
    int len = (*maxV).size();
    int minSize = min(a.size(), b.size());
    int remain = 0;
    for(int i = 0; i < len; i++) {
        if(i >= minSize) {
            int sum = (*maxV)[i] + 0 + remain;
            remain = sum/10;
            result.push_back((sum - remain*10));
            continue;
        }
        int sum = a[i] + b[i] + remain;
        remain = sum/10;
        result.push_back(sum - remain*10);
    }
    if(remain > 0) {
        result.push_back(remain);
    }
    return result;
}

/**
 * This function get
 * Input: `result` destination, vector `a` and
 * number `b` for calculation. Vector `a` is reverse
 * It returns
 * Output: `result` have new value that each 
 * number in vector is changed
 */
void multiplyVaN(vector<int> *result, vector<int> a, int b) {
    int len = a.size();
    vector<int> remain {0};
    for(int i = 0; i < len; i++ ) {
        vector<int> product = surplusVaN(remain,a[i] * b);
        
        remain.clear();
        if(product.size() > 1) {
            remain.insert(remain.begin(), product.begin() + 1, product.end());// Bring `remain` to next index
        }
        (*result)[i] = product[0];   // Get the last position number of product;
    }
    if(remain.size() == 1 && remain[0] != 0) {
        (*result).push_back(remain[0]);
    }
    if(remain.size() > 1) {
        (*result).insert((*result).end(), remain.begin(), remain.end());
    }
}

void extraLongFactorials(int n) {
    vector<int> result{1};

    for(int i = 1; i <= n; i++) {
        multiplyVaN(&result, result, i);
    }
    reverse(result.begin(), result.end());
    coutVector(&result);
}

function extraLongFactorials(n) {
    let ans = n;
    let i = n;
    while (i > 1) {
        i--;
        ans = BigInt(ans) * BigInt(i);
    }
    console.log(ans.toString())
    return ans.toString();
}

void extraLongFactorials(int n) {
    vector<int> bigInt;
    
    // Extract digits of n to initialise bigInt
    {
        stringstream ss;
        ss << n;
        string nString;
        ss >> nString;
        for (char c : nString)
            bigInt.push_back(c - '0');
        --n;
    }
    
    for (; n > 0; --n)
    {
        // Calculate the product of each individual digit of bigInt with n
        vector<int> product;
        for (unsigned int i = 0; i < bigInt.size(); ++i)
            product.push_back(bigInt[i] * n);
        
        // determine new size of bigInt
        {
            size_t prevSize = bigInt.size();
            stringstream ss;
            ss << n;
            bigInt = vector<int>(prevSize + ss.str().length(), 0);
        }
        
        // Add products to bigInt one by one
        int sizeDiff = static_cast<int>(bigInt.size() - product.size());
        int carryOver = 0;
        for (int j = static_cast<int>(bigInt.size() - 1); j >= 0; --j)
        {
            if (j - sizeDiff < 0)
            {
                if (carryOver > 0)
                {
                    bigInt[j] = carryOver % 10;
                    carryOver /= 10;
                }
                else
                {
                    // pop remaining leading 0s, erase() is [first, last)
                    bigInt.erase(bigInt.begin(), bigInt.begin() + j + 1);
                    break;
                }
            }
            else
            {
                bigInt[j] = (carryOver + product[j - sizeDiff]) % 10;
                carryOver = (carryOver + product[j - sizeDiff]) / 10;
            }
        }
    }
    
    for (int i : bigInt)
        cout << i;
}

function extraLongFactorials(n: number): void {
    // Write your code here
    let result = BigInt(n);
    let number = n;
    
    while (number > 1) {
        number = number - 1;
        result = result * BigInt(number);
    }
    
    console.log(result.toString());
}