/*

首先定义一个足够长的数组。

拿10000的阶乘为例，最后的结果长度是35660位，所以我们定义一个40000个成员的数组就可以了。

int result[40000];

其核心思想就是把计算结果每一位上的数字保存到一个数组成员中，例如：

把124保存至数组中，保存结果应该是

result[0] 4

result[1] 2

result[2] 1

这样肯定是没有问题的,一个int型数据存放一个小于10的数是绝对不会溢出。但是处理起来就稍微有点麻烦。

把整个数组看成一个数字，这个数字和一个数相乘的时候，需要每一位都和这个乘数进行相乘运算还需要把前一为的进位加上。运算方法和小学数学是一样的，乘积的个位是当前位上应该表示的数字，10位以上的需要进位。因为乘数不可能大于 10000，所以乘数和一个小于10的书相乘的时候不会大于100000，再加上前一位的进位用一个int型数据来保持这个结果就没有问题。写法如下：

int 结果 = result[x] * 乘数 + 进位;

每一位的计算结果有了，把这个结果的个位数拿出来放到这个数组元素上：

result[x] = 结果%10;

接下来的工作就是计算出进位：

进位 = 结果 / 10;

这样一位一位的把整个数组计算一遍，最后可能还有进位，用同样的方法，把进位的数值拆成单个数字，放到相应的数组元素中。

最后输出一下结果，从最高位吧数字打印一遍就OK了。

*/



#include <iostream>

using namespace std;

int main()

{ int result[40000];

  int height = 1;

  int num;

  result[0] = 1;

  cout << "intput num: " ;

  cin >> num;

  for(int i = 1; i <= num; ++i)

  { int temp = 0; //进位  

    for(int j = 0; j < height; ++j)

    {  int buf = result[j]*i + temp;//计算结果  

       result[j] = buf % 10;//取当前位  

       temp = buf / 10;//计算进位  

    }

    while(temp)

    { result[height++] = temp % 10;//取当前位  

      temp = temp / 10;//计算进位  

    }

  }

  for(int k=height-1;k>=0;k--) 

  { 

  cout<<result[k]; 

  } 

 cout<<endl;

 system("pause");

 return 0;

}

//刚写的

#include <cstdio>

#include <algorithm>

using namespace std;

struct bn

{

	int len;

	int data[1024];

	void show()

	{

		int top = len - 1;

		while (top >= 0 && data[top] == 0) --top;

		if (top < 0) printf("0");

		else for (; top >= 0; --top) printf("%d", data[top]);

	}

	void read(const char* buff)

	{

		for (len = 0; buff[len]; ++len) data[len] = buff[len] - 48;

		reverse(data, data+len);

	}

};



bn add(const bn& x, const bn& y)

{

	bn result;

	int* ptr = result.data;

	int inc = 0;

	int i = 0;

	while (i < x.len || i < y.len || inc)

	{

		int t1 = 0, t2 = 0;

		if (i < x.len) t1 = x.data[i];

		if (i < y.len) t2 = y.data[i];

		int v = t1 + t2 + inc;

		ptr[i] = v % 10;

		inc = v / 10;

		++i;

	}

	result.len = i;

	return result;

}

int main()

{

	char buff1[1024], buff2[1024];

	while (scanf("%s%s", buff1, buff2) == 2)

	{

		bn x, y, z;

		x.read(buff1);

		y.read(buff2);

		z = add(x, y);

		z.show();

		puts("");

	}

	return 0;

}

void add(char *n1,char *n2,char *r)

{

     char nn1[66]={0};

     char nn2[66]={0};

	 char nn3[66]={0};

     int  len1,len2,i,off;

     int  over=0,temp;



     len1=strlen(n1);

     len2=strlen(n2);



	 if((len1>64)||(len2>64))  

	 {

		  memcpy(r,"数太长了,你傻B啊!",66);

		  return;

     }

     for(i=len1,off=64;i>0;i--,off--)

	 {

        nn1[off]=n1[i-1]-48;

		if((nn1[off]<0)||(nn1[off]>9))

		{

			memcpy(r,"数据1里边夹有非法字母,你瞎啊!",66);

			return;

		}

	 }

     for(i=len2,off=64;i>0;i--,off--)

	 {

        nn2[off]=n2[i-1]-48;

		if((nn2[off]<0)||(nn2[off]>9))

		{

			memcpy(r,"数据2里边夹有非法字母啊,脓包!",66);

			return;

		}

	 }



	 for(i=64;i>0;i--)

     {

         temp=nn1[i]+nn2[i]+over;

		 nn3[i]=temp%10;

         over=temp/10;

      }

      nn3[0]=over;

    

	  off=0;

	  while(nn3[off]==0) off++;

	  for(i=off;i<65;i++)

	    r[i-off]=nn3[i]+48;

}

    

void main()

{

	char *x="12896896789687090824534564567568679690121212";

	char *y="9987733888245234600000000000000000075456765989986756969879673738";

	char c[66]={0}; //结果,考虑会最多会进一位,留1位结尾,共66位.但x和y最长64位



    add(x,y,c);



    printf("%66s\n+\n%66s\n=\n%66s\n\n",x,y,c);

}