UESTC

In the Fibonacci integer sequence, F0=0,F1=1,F0=0,F1=1, and Fn=Fn−1+Fn−2Fn=Fn−1+Fn−2 for n≥2n≥2. For example, the first ten terms of the Fibonacci sequence are:

0,1,1,2,3,5,8,13,21,34,⋯0,1,1,2,3,5,8,13,21,34,⋯
An alternative formula for the Fibonacci sequence is

Given an integer nn, your goal is to compute the last 44 digits of FnFn.
Input
The input test file will contain multiple test cases. Each test case consists of a single line containing nn (where 0≤n≤1,000,000,0000≤n≤1,000,000,000).

The end-of-file is denoted by a single line containing the number -1.

Output
For each test case, print the last four digits of FnFn. If the last four digits of FnFn are all zeros, print 0; otherwise, omit any leading zeros (i.e., print FnFn mod 1000010000).

Sample Input
0
9
999999999
1000000000
-1
Sample Output
0
34
626
6875
Hint
As a reminder, matrix multiplication is associative, and the product of two 2×22×2 matrices is given by

Also, note that raising any 2×22×2 matrix to the 0th power gives the identity matrix:

The data used in this problem is unofficial data prepared by 695375900. So any mistake here does not imply mistake in the offcial judge data.

例：
a^11=a^(2^0+2^1+2^3)
普通的快速幂(a^b%c)
int quick_pow(int a,int b,int c)
{
    int ans=1;
    while(b)
    {
        if(b&1)
            ans=ans*a%c;
        a=a*a%c
        b>>=1;
    }
    return ans;
}

#include<stdio.h>
#include<string.h>
struct mat
{
    int a[2][2];
};
mat I=
{
    1,0,
    0,1
};
mat matrax(mat q,mat p)
{
    mat e;
    memset(e.a,0,sizeof(e.a));
    for(int i=0; i<2; i++)
        for(int j=0; j<2; j++)
        {
            for(int k=0; k<2; k++)
            {
                e.a[i][j]=(e.a[i][j]+q.a[i][k]*p.a[k][j])%10000;
            }
        }
    return e;
}
mat quicklymod(mat b,int n)
{
    mat ans;
    memset(ans.a,0,sizeof(ans.a));
    ans=I;
    while(n)
    {
        if(n&1)
            ans=matrax(b,ans);
        b=matrax(b,b);
        n>>=1;
    }
    return ans;
}
int main()
{
    int n;
    while(~scanf("%d",&n)&&n!=-1)
    {
        mat b;
        b.a[0][0]=1,b.a[0][1]=1,b.a[1][0]=1,b.a[1][1]=0;
        if(n<=2)
        {
            if(n==0) printf("0
");
            else if(n==1) printf("1
");
            else if(n==2) printf("1
");
        }
        else
        {
            b=quicklymod(b,n);
            printf("%d
",b.a[0][1]);
        }
    }
    return 0;
}