阶乘

#include<iostream>
#include<iomanip>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<memory>
#include<algorithm>
#include<string>
#include<climits>
using namespace std;
using std::istream;
using std::ostream;
using std::string;
const int maxn=5000;/*精度位数*/
/*(必选)类与基础功能定义，用法类似于unsigned(****非负****)*/
class bign
{
    friend istream& operator>>(istream&,bign&);/*输入运算符友元*/
    friend ostream& operator<<(ostream&,const bign&);/*输出运算符友元*/
    friend bign operator+(const bign&,const bign&);/*加号运算符友元*/
    friend bign operator*(const bign&,const bign&);/*乘号运算符友元*/
    friend bign operator*(const bign&,int);/*高精度乘以低精度乘法友元*/
    friend bign operator-(const bign&,const bign&);/*减号运算符友元*/
    friend bign operator/(const bign&,const bign&);/*除法运算符友元*/
    friend bign operator%(const bign&,const bign&);/*模运算符友元*/
    friend bool operator<(const bign&,const bign&);/*逻辑小于符友元*/
    friend bool operator>(const bign&,const bign&);/*逻辑大于符友元*/
    friend bool operator<=(const bign&,const bign&);/*逻辑小于等于符友元*/
    friend bool operator>=(const bign&,const bign&);/*逻辑大于等于符友元*/
    friend bool operator==(const bign&,const bign&);/*逻辑等符友元*/
    friend bool operator!=(const bign&,const bign&);/*逻辑不等符友元*/
private:
    int len,s[maxn];
public:
    bign(){memset(s,0,sizeof(s));len=1;}
    bign operator=(const char* num)
    {
        int i=0,ol;
        ol=len=strlen(num);
        while(num[i++]=='0'&&len>1)
            len--;
        memset(s,0,sizeof(s));
        for(i=0;i<len;i++)
            s[i]=num[ol-i-1]-'0';
        return *this;
    }
    bign operator=(int num)
    {
       char s[maxn];
       sprintf(s,"%d",num);
       *this=s;
       return *this;
    }
    bign(int num)
    {
        *this=num;
    }
    bign(const char* num)
    {
        *this=num;
    }
    string str() const
    {
       int i;
       string res="";
       for(i=0;i<len;i++)res=char(s[i]+'0')+res;
       if(res=="")res="0";
       return res;
    }
};
 /*(可选)基本逻辑运算符重载*/
bool operator<(const bign& a,const bign& b)
{
    int i;
    if(a.len!=b.len)
        return a.len<b.len;
    for(i=a.len-1;i>=0;i--)
       if(a.s[i]!=b.s[i])
        return a.s[i]<b.s[i];
    return false;
}
 bool operator>(const bign& a,const bign& b){return b<a;}
 bool operator<=(const bign& a,const bign& b){return !(a>b);}
 bool operator>=(const bign& a,const bign& b){return !(a<b);}
 bool operator!=(const bign& a,const bign& b){return a<b||a>b;}
 bool operator==(const bign& a,const bign& b){return !(a<b||a>b);}
 /*(可选)加法运算符重载*/

 bign operator+(const bign& a,const bign& b)
 {
  int i,max=(a.len>b.len?a.len:b.len),t,c;
  bign sum;
  sum.len=0;
  for(i=0,c=0;c||i<max;i++)
  {
   t=c;
   if(i<a.len)t+=a.s[i];
   if(i<b.len)t+=b.s[i];
   sum.s[sum.len++]=t%10;
   c=t/10;
  }
  return sum;
 }
 /*(可选)乘法运算符重载(高精度乘高精度)*/
 bign operator*(const bign& a,const bign& b)
 {
  int i,j;
  bign res;
  for(i=0;i<a.len;i++)
  {
   for(j=0;j<b.len;j++)
   {
    res.s[i+j]+=(a.s[i]*b.s[j]);
    res.s[i+j+1]+=res.s[i+j]/10;
    res.s[i+j]%=10;
   }
  }
  res.len=a.len+b.len;
  while(res.s[res.len-1]==0&&res.len>1)res.len--;
  if(res.s[res.len])res.len++;
  return res;
 }
 /*高精度乘以低精度(注意:必须是bign*int顺序不能颠倒,要么会与高精度乘高精度发生冲突
 bign operator*(const bign& a,int b)
 {
  int i,t,c=0;
  bign res;
  for(i=0;i<a.len;i++)
  {
   t=a.s[i]*b+c;
   res.s[i]=t%10;
   c=t/10;
  }
  res.len=a.len;
  while(c!=0)
  {
   res.s[i++]=c%10;
   c/=10;
   res.len++;
  }
  return res;
 }*/
 /*(可选)减法运算符重载*/

 bool compare(bign c,bign d)
 {
    if(c<d)
        return(1);
 }

 bign operator-(const bign& a,const bign& b)
 {
    bign res;
    /*if(compare(a,b))
    {
        cout<<'-';
        bign qqq;
        qqq=a;
        a=b;
        b=qqq;
    }*/
  int i,len=(a.len>b.len)?a.len:b.len;
  for(i=0;i<len;i++)
  {
   res.s[i]+=a.s[i]-b.s[i];
   if(res.s[i]<0)
   {
    res.s[i]+=10;
    res.s[i+1]--;
   }
  }
  while(res.s[len-1]==0 && len>1)len--;
  res.len=len;
  return res;
 }
 /*(可选)除法运算符重载(注意:减法和乘法运算和>=运算符必选)*/
 bign operator/(const bign& a,const bign& b)
 {
  int i,len=a.len;
  bign res,f,constt=10;
  for(i=len-1;i>=0;i--)
  {
   f=f*constt;
   f.s[0]=a.s[i];
   while(f>=b)
   {
    f=f-b;
    res.s[i]++;
   }
  }
  while(res.s[len-1]==0&&len>1)len--;
  res.len=len;
  return res;
 }
 /*(可选)模运算符重载(注意:减法和乘法运算和>=运算符必选)*/
 bign operator%(const bign& a,const bign& b)
 {
  int i,len=a.len;
  bign res,f,constt=10;
  for(i=len-1;i>=0;i--)
  {
   f=f*constt;
   f.s[0]=a.s[i];
   while(f>=b)
   {
    f=f-b;
    res.s[i]++;
   }
  }
  return f;
 }
 /*(可选)X等运算符重载(注意:X法必选)*/
 bign& operator+=(bign& a,const bign& b)
 {
  a=a+b;
  return a;
 }
 bign& operator-=(bign& a,const bign& b)
 {
  a=a-b;
  return a;
 }
 bign& operator*=(bign& a,const bign& b)
 {
  a=a*b;
  return a;
 }
 bign& operator/=(bign& a,const bign& b)
 {
  a=a/b;
  return a;
 }
 /*可选前缀++/--与后缀++/--(注意:加法必选)*/
 bign& operator++(bign& a)
 {
  a=a+1;
  return a;
 }
 bign& operator++(bign& a,int)
 {
  bign t=a;
  a=a+1;
  return t;
 }
 bign& operator--(bign& a)
 {
  a=a-1;
  return a;
 }
 bign& operator--(bign& a,int)
 {
  bign t=a;
  a=a-1;
  return t;
 }
 istream& operator>>(istream &in,bign& x)
 {
  string s;
  in>>s;
  x=s.c_str();
  return in;
 }
 ostream& operator<<(ostream &out,const bign& x)
 {
  out<<x.str();
  return out;
 }



 int main()
 {
    bign ans=1,n;
    cin>>n;
    for(bign i=1;i<=n;i++)
    {
        ans*=i;
    }
    cout<<ans;
    return 0;
 }