[Explanations] cycle

Title Description

　　Lele is a clever and studious child. He likes to explore the law of things. One day, he suddenly positive integer powers of the number of generated interest.

　　As we all know, $ 2 $ a positive integer power last digit is repeated constantly in the $ 2,4,8,6,2,4,8,6 ... $ we say $ 2 $ a positive integer power last the cycle length is $ 4 $ (actually $ 4 $ multiples can be said to be the length of the cycle, but we only consider the minimum cycle length). Similarly, the remaining number of positive integer powers of the last digit has a similar cycle:

　　Then Lele question came out: It is not only the last one have this cycle it? For an integer $ n $ positive integer powers of, its level is the $ k $ loop will happen? If the loop, then loop length is how much?

　　note:

　　1. If $ n $ is less than the median of a positive integer powers of $ k $ high, then the under-seen $ 0 $ .

　　2. If the cycle length is L $ $ , then the description for any positive integer $ a $, $ n $ a $ A $ power and $ a + L $ last power $ k $ bits are the same.

 

Input Format

 　　Line, comprising $ 2 $ integer $ 1 \ leqslant n <10 ^ {100} $ and $. 1 \ leqslant K \ leqslant 100 $ , $ n-$ and $ k $ between separated by a space, indicates that the requested $ n-$ n Finally $ k $ integer power of cycle length bits.

 

Output Format

 　　An integer representing the cycle length. If the loop is not present, output $ $ -1 .

 i

SAMPLE INPUT

32 2

 

Sample Output

4

 

answer

　　Readily appreciate if the cycle length of the last $ I $ bits is $ L_ {i} $, and finally $ i + 1 $ bit cyclic length $ L_ {i + 1} $, the $ L_ {i} | L_ {i + 1} $.

　　We set the last bit to be multiplied $ I $ $ a ^ {L_ {i}} $ to repeat, then for $ i + 1 $ the last bit, each time multiplied by $ a ^ {L_ {i}} $, when multiplication when the $ $ CNT was repeated twice, the $ L_ {i + 1} = L_ {i} \ times cnt $.

　　Note that if the same last $ a ^ $ I $ bits {L_ {i} + 1} $ I $ $ last bits of $ A $, it also outputs $ $ -1.

#include <iostream>
#include <cstdio>
#include <cstring>

#define MAX_LEN (100 + 5)

using namespace std;

int k;

struct BigNumber
{
    int bit[MAX_LEN + MAX_LEN], len;
    
    BigNumber()
    {
        memset(bit, 0, sizeof bit);
        len = 1;
        return;
    }
    
    BigNumber operator = (char * s)
    {
        memset(bit, 0, sizeof bit);
        len = strlen(s + 1);
        for(register int i = 1; i <= len; ++i)
        {
            bit[i] = s[len - i + 1] - '0'; 
        }
        return *this;
    }
    
    BigNumber operator = (int num)
    {
        memset(bit, 0, sizeof bit);
        len = 0;
        do
        {
            bit[++len] = num % 10;
            num /= 10; 
        }
        while(num);
        return *this;
    }
    
    inline bool notZero()
    {
        return len > 1 || bit[1];
    }
    
    friend BigNumber operator + (BigNumber a, BigNumber b)
    {
        if(a.len < b.len) a.len = b.len;
        for(register int i = 1; i <= a.len; ++i)
        {
            a.bit[i] += b.bit[i];
        }
        for(register int i = 1; i <= a.len && i <= k; ++i)
        {
            if(a.bit[i] >= 10)
            {
                if(i == a.len) ++a.len;
                ++a.bit[i + 1];
                a.bit[i] -= 10;
            } 
        }
        if(a.len > k) a.bit[a.len--] = 0;
        return a;
    }
    
    friend BigNumber operator += (BigNumber & a, BigNumber b)
    {
        return a = a + b;
    }
    
    friend BigNumber operator * (BigNumber a, BigNumber b)
    {
        BigNumber c;
        c.len = a.len + b.len - 1;
        if(c.len > k) c.len = k;
        for(register int i = 1; i <= a.len; ++i)
        {
            for(register int j = 1; j <= b.len && i + j - 1 <= k; ++j)
            {
                c.bit[i + j - 1] += a.bit[i] * b.bit[j];
            }
        }
        for(register int i = 1; i <= c.len && i <= k; ++i)
        {
            if(c.bit[i] >= 10)
            {
                if(i == c.len) ++c.len;
                c.bit[i + 1] += c.bit[i] / 10;
                c.bit[i] %= 10;
            } 
        }
        if(c.len > k) c.bit[c.len--] = 0;
        return c;
    }
    
    friend BigNumber operator *= (BigNumber & a, BigNumber b)
    {
        return a = a * b;
    }
    
    void Write()
    {
        for(register int i = len; i; --i)
        {
            printf("%d", bit[i]);
        }
        return;
    }
};

BigNumber a;
int f[15];
BigNumber dp[MAX_LEN];

int main()
{
    char s[MAX_LEN];
    scanf("%s%d", s + 1, &k);
    a = s;
    dp[0] = 1;
    BigNumber res, p, tmp;
    tmp = a;
    for(register int i = 1; i <= k; ++i)
    {
        memset(f, 0, sizeof f); 
        p = tmp;
        tmp = 1;
        res = a;
        f[res.bit[i]] = 1;
        while(f[res.bit[i]] < 2)
        {
            tmp *= p;
            res *= p;
            ++f[res.bit[i]];
            dp[i] += dp[i - 1];
        }
        if(res.bit[i] != a.bit[i]) return cout << -1, 0;
    }
    dp[k].Write();
    return 0;
}

Reference program