1 #include <iostream>
2 #include <stdio.h>
3 #include <string.h>
4 using namespace std;
5
6
7
8 #define DIGIT 4 //四位隔开,即万进制
9 #define DEPTH 10000 //万进制
10 #define MAX 100 //题目最大位数/4，要不大直接设为最大位数也行
11 typedef int bignum_t[MAX+1];
12
13 /************************************************************************/
14 /* 读取操作数，对操作数进行处理存储在数组里 */
15 /************************************************************************/
16 int read(bignum_t a,istream&is=cin)
17 {
18 char buf[MAX*DIGIT+1],ch ;
19 int i,j ;
20 memset((void*)a,0,sizeof(bignum_t));
21 if(!(is>>buf))return 0 ;
22 for(a[0]=strlen(buf),i=a[0]/2-1;i>=0;i--)
23 ch=buf[i],buf[i]=buf[a[0]-1-i],buf[a[0]-1-i]=ch ;
24 for(a[0]=(a[0]+DIGIT-1)/DIGIT,j=strlen(buf);j<a[0]*DIGIT;buf[j++]=‘0‘);
25 for(i=1;i<=a[0];i++)
26 for(a[i]=0,j=0;j<DIGIT;j++)
27 a[i]=a[i]*10+buf[i*DIGIT-1-j]-‘0‘ ;
28 for(;!a[a[0]]&&a[0]>1;a[0]--);
29 return 1 ;
30 }
31
32 void write(const bignum_t a,ostream&os=cout)
33 {
34 int i,j ;
35 for(os<<a[i=a[0]],i--;i;i--)
36 for(j=DEPTH/10;j;j/=10)
37 os<<a[i]/j%10 ;
38 }
39
40 int comp(const bignum_t a,const bignum_t b)
41 {
42 int i ;
43 if(a[0]!=b[0])
44 return a[0]-b[0];
45 for(i=a[0];i;i--)
46 if(a[i]!=b[i])
47 return a[i]-b[i];
48 return 0 ;
49 }
50
51 int comp(const bignum_t a,const int b)
52 {
53 int c[12]=
54 {
55 }
56 ;
57 for(c[1]=b;c[c[0]]>=DEPTH;c[c[0]+1]=c[c[0]]/DEPTH,c[c[0]]%=DEPTH,c[0]++);
58 return comp(a,c);
59 }
60
61 int comp(const bignum_t a,const int c,const int d,const bignum_t b)
62 {
63 int i,t=0,O=-DEPTH*2 ;
64 if(b[0]-a[0]<d&&c)
65 return 1 ;
66 for(i=b[0];i>d;i--)
67 {
68 t=t*DEPTH+a[i-d]*c-b[i];
69 if(t>0)return 1 ;
70 if(t<O)return 0 ;
71 }
72 for(i=d;i;i--)
73 {
74 t=t*DEPTH-b[i];
75 if(t>0)return 1 ;
76 if(t<O)return 0 ;
77 }
78 return t>0 ;
79 }
80 /************************************************************************/
81 /* 大数与大数相加 */
82 /************************************************************************/
83 void add(bignum_t a,const bignum_t b)
84 {
85 int i ;
86 for(i=1;i<=b[0];i++)
87 if((a[i]+=b[i])>=DEPTH)
88 a[i]-=DEPTH,a[i+1]++;
89 if(b[0]>=a[0])
90 a[0]=b[0];
91 else
92 for(;a[i]>=DEPTH&&i<a[0];a[i]-=DEPTH,i++,a[i]++);
93 a[0]+=(a[a[0]+1]>0);
94 }
95 /************************************************************************/
96 /* 大数与小数相加 */
97 /************************************************************************/
98 void add(bignum_t a,const int b)
99 {
100 int i=1 ;
101 for(a[1]+=b;a[i]>=DEPTH&&i<a[0];a[i+1]+=a[i]/DEPTH,a[i]%=DEPTH,i++);
102 for(;a[a[0]]>=DEPTH;a[a[0]+1]=a[a[0]]/DEPTH,a[a[0]]%=DEPTH,a[0]++);
103 }
104 /************************************************************************/
105 /* 大数相减(被减数>=减数) */
106 /************************************************************************/
107 void sub(bignum_t a,const bignum_t b)
108 {
109 int i ;
110 for(i=1;i<=b[0];i++)
111 if((a[i]-=b[i])<0)
112 a[i+1]--,a[i]+=DEPTH ;
113 for(;a[i]<0;a[i]+=DEPTH,i++,a[i]--);
114 for(;!a[a[0]]&&a[0]>1;a[0]--);
115 }
116 /************************************************************************/
117 /* 大数减去小数(被减数>=减数) */
118 /************************************************************************/
119 void sub(bignum_t a,const int b)
120 {
121 int i=1 ;
122 for(a[1]-=b;a[i]<0;a[i+1]+=(a[i]-DEPTH+1)/DEPTH,a[i]-=(a[i]-DEPTH+1)/DEPTH*DEPTH,i++);
123 for(;!a[a[0]]&&a[0]>1;a[0]--);
124 }
125
126 void sub(bignum_t a,const bignum_t b,const int c,const int d)
127 {
128 int i,O=b[0]+d ;
129 for(i=1+d;i<=O;i++)
130 if((a[i]-=b[i-d]*c)<0)
131 a[i+1]+=(a[i]-DEPTH+1)/DEPTH,a[i]-=(a[i]-DEPTH+1)/DEPTH*DEPTH ;
132 for(;a[i]<0;a[i+1]+=(a[i]-DEPTH+1)/DEPTH,a[i]-=(a[i]-DEPTH+1)/DEPTH*DEPTH,i++);
133 for(;!a[a[0]]&&a[0]>1;a[0]--);
134 }
135 /************************************************************************/
136 /* 大数相乘，读入被乘数a，乘数b，结果保存在c[] */
137 /************************************************************************/
138 void mul(bignum_t c,const bignum_t a,const bignum_t b)
139 {
140 int i,j ;
141 memset((void*)c,0,sizeof(bignum_t));
142 for(c[0]=a[0]+b[0]-1,i=1;i<=a[0];i++)
143 for(j=1;j<=b[0];j++)
144 if((c[i+j-1]+=a[i]*b[j])>=DEPTH)
145 c[i+j]+=c[i+j-1]/DEPTH,c[i+j-1]%=DEPTH ;
146 for(c[0]+=(c[c[0]+1]>0);!c[c[0]]&&c[0]>1;c[0]--);
147 }
148 /************************************************************************/
149 /* 大数乘以小数，读入被乘数a，乘数b，结果保存在被乘数 */
150 /************************************************************************/
151 void mul(bignum_t a,const int b)
152 {
153 int i ;
154 for(a[1]*=b,i=2;i<=a[0];i++)
155 {
156 a[i]*=b ;
157 if(a[i-1]>=DEPTH)
158 a[i]+=a[i-1]/DEPTH,a[i-1]%=DEPTH ;
159 }
160 for(;a[a[0]]>=DEPTH;a[a[0]+1]=a[a[0]]/DEPTH,a[a[0]]%=DEPTH,a[0]++);
161 for(;!a[a[0]]&&a[0]>1;a[0]--);
162 }
163
164 void mul(bignum_t b,const bignum_t a,const int c,const int d)
165 {
166 int i ;
167 memset((void*)b,0,sizeof(bignum_t));
168 for(b[0]=a[0]+d,i=d+1;i<=b[0];i++)
169 if((b[i]+=a[i-d]*c)>=DEPTH)
170 b[i+1]+=b[i]/DEPTH,b[i]%=DEPTH ;
171 for(;b[b[0]+1];b[0]++,b[b[0]+1]=b[b[0]]/DEPTH,b[b[0]]%=DEPTH);
172 for(;!b[b[0]]&&b[0]>1;b[0]--);
173 }
174 /**************************************************************************/
175 /* 大数相除,读入被除数a，除数b，结果保存在c[]数组 */
176 /* 需要comp()函数 */
177 /**************************************************************************/
178 void div(bignum_t c,bignum_t a,const bignum_t b)
179 {
180 int h,l,m,i ;
181 memset((void*)c,0,sizeof(bignum_t));
182 c[0]=(b[0]<a[0]+1)?(a[0]-b[0]+2):1 ;
183 for(i=c[0];i;sub(a,b,c[i]=m,i-1),i--)
184 for(h=DEPTH-1,l=0,m=(h+l+1)>>1;h>l;m=(h+l+1)>>1)
185 if(comp(b,m,i-1,a))h=m-1 ;
186 else l=m ;
187 for(;!c[c[0]]&&c[0]>1;c[0]--);
188 c[0]=c[0]>1?c[0]:1 ;
189 }
190
191 void div(bignum_t a,const int b,int&c)
192 {
193 int i ;
194 for(c=0,i=a[0];i;c=c*DEPTH+a[i],a[i]=c/b,c%=b,i--);
195 for(;!a[a[0]]&&a[0]>1;a[0]--);
196 }
197 /************************************************************************/
198 /* 大数平方根，读入大数a，结果保存在b[]数组里 */
199 /* 需要comp()函数 */
200 /************************************************************************/
201 void sqrt(bignum_t b,bignum_t a)
202 {
203 int h,l,m,i ;
204 memset((void*)b,0,sizeof(bignum_t));
205 for(i=b[0]=(a[0]+1)>>1;i;sub(a,b,m,i-1),b[i]+=m,i--)
206 for(h=DEPTH-1,l=0,b[i]=m=(h+l+1)>>1;h>l;b[i]=m=(h+l+1)>>1)
207 if(comp(b,m,i-1,a))h=m-1 ;
208 else l=m ;
209 for(;!b[b[0]]&&b[0]>1;b[0]--);
210 for(i=1;i<=b[0];b[i++]>>=1);
211 }
212 /************************************************************************/
213 /* 返回大数的长度 */
214 /************************************************************************/
215 int length(const bignum_t a)
216 {
217 int t,ret ;
218 for(ret=(a[0]-1)*DIGIT,t=a[a[0]];t;t/=10,ret++);
219 return ret>0?ret:1 ;
220 }
221 /************************************************************************/
222 /* 返回指定位置的数字，从低位开始数到第b位，返回b位上的数 */
223 /************************************************************************/
224 int digit(const bignum_t a,const int b)
225 {
226 int i,ret ;
227 for(ret=a[(b-1)/DIGIT+1],i=(b-1)%DIGIT;i;ret/=10,i--);
228 return ret%10 ;
229 }
230 /************************************************************************/
231 /* 返回大数末尾0的个数 */
232 /************************************************************************/
233 int zeronum(const bignum_t a)
234 {
235 int ret,t ;
236 for(ret=0;!a[ret+1];ret++);
237 for(t=a[ret+1],ret*=DIGIT;!(t%10);t/=10,ret++);
238 return ret ;
239 }
240
241 void comp(int*a,const int l,const int h,const int d)
242 {
243 int i,j,t ;
244 for(i=l;i<=h;i++)
245 for(t=i,j=2;t>1;j++)
246 while(!(t%j))
247 a[j]+=d,t/=j ;
248 }
249
250 void convert(int*a,const int h,bignum_t b)
251 {
252 int i,j,t=1 ;
253 memset(b,0,sizeof(bignum_t));
254 for(b[0]=b[1]=1,i=2;i<=h;i++)
255 if(a[i])
256 for(j=a[i];j;t*=i,j--)
257 if(t*i>DEPTH)
258 mul(b,t),t=1 ;
259 mul(b,t);
260 }
261 /************************************************************************/
262 /* 组合数 */
263 /************************************************************************/
264 void combination(bignum_t a,int m,int n)
265 {
266 int*t=new int[m+1];
267 memset((void*)t,0,sizeof(int)*(m+1));
268 comp(t,n+1,m,1);
269 comp(t,2,m-n,-1);
270 convert(t,m,a);
271 delete[]t ;
272 }
273 /************************************************************************/
274 /* 排列数 */
275 /************************************************************************/
276 void permutation(bignum_t a,int m,int n)
277 {
278 int i,t=1 ;
279 memset(a,0,sizeof(bignum_t));
280 a[0]=a[1]=1 ;
281 for(i=m-n+1;i<=m;t*=i++)
282 if(t*i>DEPTH)
283 mul(a,t),t=1 ;
284 mul(a,t);
285 }
286
287 #define SGN(x) ((x)>0?1:((x)<0?-1:0))
288 #define ABS(x) ((x)>0?(x):-(x))
289
290 int read(bignum_t a,int&sgn,istream&is=cin)
291 {
292 char str[MAX*DIGIT+2],ch,*buf ;
293 int i,j ;
294 memset((void*)a,0,sizeof(bignum_t));
295 if(!(is>>str))return 0 ;
296 buf=str,sgn=1 ;
297 if(*buf==‘-‘)sgn=-1,buf++;
298 for(a[0]=strlen(buf),i=a[0]/2-1;i>=0;i--)
299 ch=buf[i],buf[i]=buf[a[0]-1-i],buf[a[0]-1-i]=ch ;
300 for(a[0]=(a[0]+DIGIT-1)/DIGIT,j=strlen(buf);j<a[0]*DIGIT;buf[j++]=‘0‘);
301 for(i=1;i<=a[0];i++)
302 for(a[i]=0,j=0;j<DIGIT;j++)
303 a[i]=a[i]*10+buf[i*DIGIT-1-j]-‘0‘ ;
304 for(;!a[a[0]]&&a[0]>1;a[0]--);
305 if(a[0]==1&&!a[1])sgn=0 ;
306 return 1 ;
307 }
308 struct bignum
309 {
310 bignum_t num ;
311 int sgn ;
312 public :
313 inline bignum()
314 {
315 memset(num,0,sizeof(bignum_t));
316 num[0]=1 ;
317 sgn=0 ;
318 }
319 inline int operator!()
320 {
321 return num[0]==1&&!num[1];
322 }
323 inline bignum&operator=(const bignum&a)
324 {
325 memcpy(num,a.num,sizeof(bignum_t));
326 sgn=a.sgn ;
327 return*this ;
328 }
329 inline bignum&operator=(const int a)
330 {
331 memset(num,0,sizeof(bignum_t));
332 num[0]=1 ;
333 sgn=SGN (a);
334 add(num,sgn*a);
335 return*this ;
336 }
337 ;
338 inline bignum&operator+=(const bignum&a)
339 {
340 if(sgn==a.sgn)add(num,a.num);
341 else if
342 (sgn&&a.sgn)
343 {
344 int ret=comp(num,a.num);
345 if(ret>0)sub(num,a.num);
346 else if(ret<0)
347 {
348 bignum_t t ;
349 memcpy(t,num,sizeof(bignum_t));
350 memcpy(num,a.num,sizeof(bignum_t));
351 sub (num,t);
352 sgn=a.sgn ;
353 }
354 else memset(num,0,sizeof(bignum_t)),num[0]=1,sgn=0 ;
355 }
356 else if(!sgn)
357 memcpy(num,a.num,sizeof(bignum_t)),sgn=a.sgn ;
358 return*this ;
359 }
360 inline bignum&operator+=(const int a)
361 {
362 if(sgn*a>0)add(num,ABS(a));
363 else if(sgn&&a)
364 {
365 int ret=comp(num,ABS(a));
366 if(ret>0)sub(num,ABS(a));
367 else if(ret<0)
368 {
369 bignum_t t ;
370 memcpy(t,num,sizeof(bignum_t));
371 memset(num,0,sizeof(bignum_t));
372 num[0]=1 ;
373 add(num,ABS (a));
374 sgn=-sgn ;
375 sub(num,t);
376 }
377 else memset(num,0,sizeof(bignum_t)),num[0]=1,sgn=0 ;
378 }
379 else if
380 (!sgn)sgn=SGN(a),add(num,ABS(a));
381 return*this ;
382 }
383 inline bignum operator+(const bignum&a)
384 {
385 bignum ret ;
386 memcpy(ret.num,num,sizeof (bignum_t));
387 ret.sgn=sgn ;
388 ret+=a ;
389 return ret ;
390 }
391 inline bignum operator+(const int a)
392 {
393 bignum ret ;
394 memcpy(ret.num,num,sizeof (bignum_t));
395 ret.sgn=sgn ;
396 ret+=a ;
397 return ret ;
398 }
399 inline bignum&operator-=(const bignum&a)
400 {
401 if(sgn*a.sgn<0)add(num,a.num);
402 else if
403 (sgn&&a.sgn)
404 {
405 int ret=comp(num,a.num);
406 if(ret>0)sub(num,a.num);
407 else if(ret<0)
408 {
409 bignum_t t ;
410 memcpy(t,num,sizeof(bignum_t));
411 memcpy(num,a.num,sizeof(bignum_t));
412 sub(num,t);
413 sgn=-sgn ;
414 }
415 else memset(num,0,sizeof(bignum_t)),num[0]=1,sgn=0 ;
416 }
417 else if(!sgn)add (num,a.num),sgn=-a.sgn ;
418 return*this ;
419 }
420 inline bignum&operator-=(const int a)
421 {
422 if(sgn*a<0)add(num,ABS(a));
423 else if(sgn&&a)
424 {
425 int ret=comp(num,ABS(a));
426 if(ret>0)sub(num,ABS(a));
427 else if(ret<0)
428 {
429 bignum_t t ;
430 memcpy(t,num,sizeof(bignum_t));
431 memset(num,0,sizeof(bignum_t));
432 num[0]=1 ;
433 add(num,ABS(a));
434 sub(num,t);
435 sgn=-sgn ;
436 }
437 else memset(num,0,sizeof(bignum_t)),num[0]=1,sgn=0 ;
438 }
439 else if
440 (!sgn)sgn=-SGN(a),add(num,ABS(a));
441 return*this ;
442 }
443 inline bignum operator-(const bignum&a)
444 {
445 bignum ret ;
446 memcpy(ret.num,num,sizeof(bignum_t));
447 ret.sgn=sgn ;
448 ret-=a ;
449 return ret ;
450 }
451 inline bignum operator-(const int a)
452 {
453 bignum ret ;
454 memcpy(ret.num,num,sizeof(bignum_t));
455 ret.sgn=sgn ;
456 ret-=a ;
457 return ret ;
458 }
459 inline bignum&operator*=(const bignum&a)
460 {
461 bignum_t t ;
462 mul(t,num,a.num);
463 memcpy(num,t,sizeof(bignum_t));
464 sgn*=a.sgn ;
465 return*this ;
466 }
467 inline bignum&operator*=(const int a)
468 {
469 mul(num,ABS(a));
470 sgn*=SGN(a);
471 return*this ;
472 }
473 inline bignum operator*(const bignum&a)
474 {
475 bignum ret ;
476 mul(ret.num,num,a.num);
477 ret.sgn=sgn*a.sgn ;
478 return ret ;
479 }
480 inline bignum operator*(const int a)
481 {
482 bignum ret ;
483 memcpy(ret.num,num,sizeof (bignum_t));
484 mul(ret.num,ABS(a));
485 ret.sgn=sgn*SGN(a);
486 return ret ;
487 }
488 inline bignum&operator/=(const bignum&a)
489 {
490 bignum_t t ;
491 div(t,num,a.num);
492 memcpy (num,t,sizeof(bignum_t));
493 sgn=(num[0]==1&&!num[1])?0:sgn*a.sgn ;
494 return*this ;
495 }
496 inline bignum&operator/=(const int a)
497 {
498 int t ;
499 div(num,ABS(a),t);
500 sgn=(num[0]==1&&!num [1])?0:sgn*SGN(a);
501 return*this ;
502 }
503 inline bignum operator/(const bignum&a)
504 {
505 bignum ret ;
506 bignum_t t ;
507 memcpy(t,num,sizeof(bignum_t));
508 div(ret.num,t,a.num);
509 ret.sgn=(ret.num[0]==1&&!ret.num[1])?0:sgn*a.sgn ;
510 return ret ;
511 }
512 inline bignum operator/(const int a)
513 {
514 bignum ret ;
515 int t ;
516 memcpy(ret.num,num,sizeof(bignum_t));
517 div(ret.num,ABS(a),t);
518 ret.sgn=(ret.num[0]==1&&!ret.num[1])?0:sgn*SGN(a);
519 return ret ;
520 }
521 inline bignum&operator%=(const bignum&a)
522 {
523 bignum_t t ;
524 div(t,num,a.num);
525 if(num[0]==1&&!num[1])sgn=0 ;
526 return*this ;
527 }
528 inline int operator%=(const int a)
529 {
530 int t ;
531 div(num,ABS(a),t);
532 memset(num,0,sizeof (bignum_t));
533 num[0]=1 ;
534 add(num,t);
535 return t ;
536 }
537 inline bignum operator%(const bignum&a)
538 {
539 bignum ret ;
540 bignum_t t ;
541 memcpy(ret.num,num,sizeof(bignum_t));
542 div(t,ret.num,a.num);
543 ret.sgn=(ret.num[0]==1&&!ret.num [1])?0:sgn ;
544 return ret ;
545 }
546 inline int operator%(const int a)
547 {
548 bignum ret ;
549 int t ;
550 memcpy(ret.num,num,sizeof(bignum_t));
551 div(ret.num,ABS(a),t);
552 memset(ret.num,0,sizeof(bignum_t));
553 ret.num[0]=1 ;
554 add(ret.num,t);
555 return t ;
556 }
557 inline bignum&operator++()
558 {
559 *this+=1 ;
560 return*this ;
561 }
562 inline bignum&operator--()
563 {
564 *this-=1 ;
565 return*this ;
566 }
567 ;
568 inline int operator>(const bignum&a)
569 {
570 return sgn>0?(a.sgn>0?comp(num,a.num)>0:1):(sgn<0?(a.sgn<0?comp(num,a.num)<0:0):a.sgn<0);
571 }
572 inline int operator>(const int a)
573 {
574 return sgn>0?(a>0?comp(num,a)>0:1):(sgn<0?(a<0?comp(num,-a)<0:0):a<0);
575 }
576 inline int operator>=(const bignum&a)
577 {
578 return sgn>0?(a.sgn>0?comp(num,a.num)>=0:1):(sgn<0?(a.sgn<0?comp(num,a.num)<=0:0):a.sgn<=0);
579 }
580 inline int operator>=(const int a)
581 {
582 return sgn>0?(a>0?comp(num,a)>=0:1):(sgn<0?(a<0?comp(num,-a)<=0:0):a<=0);
583 }
584 inline int operator<(const bignum&a)
585 {
586 return sgn<0?(a.sgn<0?comp(num,a.num)>0:1):(sgn>0?(a.sgn>0?comp(num,a.num)<0:0):a.sgn>0);
587 }
588 inline int operator<(const int a)
589 {
590 return sgn<0?(a<0?comp(num,-a)>0:1):(sgn>0?(a>0?comp(num,a)<0:0):a>0);
591 }
592 inline int operator<=(const bignum&a)
593 {
594 return sgn<0?(a.sgn<0?comp(num,a.num)>=0:1):(sgn>0?(a.sgn>0?comp(num,a.num)<=0:0):a.sgn>=0);
595 }
596 inline int operator<=(const int a)
597 {
598 return sgn<0?(a<0?comp(num,-a)>=0:1):
599 (sgn>0?(a>0?comp(num,a)<=0:0):a>=0);
600 }
601 inline int operator==(const bignum&a)
602 {
603 return(sgn==a.sgn)?!comp(num,a.num):0 ;
604 }
605 inline int operator==(const int a)
606 {
607 return(sgn*a>=0)?!comp(num,ABS(a)):0 ;
608 }
609 inline int operator!=(const bignum&a)
610 {
611 return(sgn==a.sgn)?comp(num,a.num):1 ;
612 }
613 inline int operator!=(const int a)
614 {
615 return(sgn*a>=0)?comp(num,ABS(a)):1 ;
616 }
617 inline int operator[](const int a)
618 {
619 return digit(num,a);
620 }
621 friend inline istream&operator>>(istream&is,bignum&a)
622 {
623 read(a.num,a.sgn,is);
624 return is ;
625 }
626 friend inline ostream&operator<<(ostream&os,const bignum&a)
627 {
628 if(a.sgn<0)
629 os<<‘-‘ ;
630 write(a.num,os);
631 return os ;
632 }
633 friend inline bignum sqrt(const bignum&a)
634 {
635 bignum ret ;
636 bignum_t t ;
637 memcpy(t,a.num,sizeof(bignum_t));
638 sqrt(ret.num,t);
639 ret.sgn=ret.num[0]!=1||ret.num[1];
640 return ret ;
641 }
642 friend inline bignum sqrt(const bignum&a,bignum&b)
643 {
644 bignum ret ;
645 memcpy(b.num,a.num,sizeof(bignum_t));
646 sqrt(ret.num,b.num);
647 ret.sgn=ret.num[0]!=1||ret.num[1];
648 b.sgn=b.num[0]!=1||ret.num[1];
649 return ret ;
650 }
651 inline int length()
652 {
653 return :: length(num);
654 }
655 inline int zeronum()
656 {
657 return :: zeronum(num);
658 }
659 inline bignum C(const int m,const int n)
660 {
661 combination(num,m,n);
662 sgn=1 ;
663 return*this ;
664 }
665 inline bignum P(const int m,const int n)
666 {
667 permutation(num,m,n);
668 sgn=1 ;
669 return*this ;
670 }
671 };
672 int main()
673 {
674 bignum a[1000];
675 a[1]=1;
676 a[2]=2;
677 int n;
678 for(int i=3;i<=300;i++)
679 {
680 a[i]=a[i-1]+a[i-2];
681 }
682 while(cin>>n)
683 {
684 cout<<a[n]<<endl;
685 }
686 return 0;
687 }
