Problem:
Score : 1000 points

Problem Statement

Takahashi and Aoki are going to together construct a sequence of integers.

First, Takahashi will provide a sequence of integers a, satisfying all of the following conditions:

The length of a is N.

Each element in a is an integer between 1 and K, inclusive.

a is a palindrome, that is, reversing the order of elements in a will result in the same sequence as the original.

Then, Aoki will perform the following operation an arbitrary number of times:

Move the first element in a to the end of a.

How many sequences a can be obtained after this procedure, modulo 10^9+7?

Constraints

1≤N≤10^9

1≤K≤10^9

Input

The input is given from Standard Input in the following format:

N K

Output

Print the number of the sequences a that can be obtained after the procedure, modulo 10^9+7.

Sample Input 1

4 2

Sample Output 1

6

The following six sequences can be obtained:

(1, 1, 1, 1)

(1, 1, 2, 2)

(1, 2, 2, 1)

(2, 2, 1, 1)

(2, 1, 1, 2)

(2, 2, 2, 2)

Sample Input 2

1 10

Sample Output 2

10

Sample Input 3

6 3

Sample Output 3

75

Sample Input 4

1000000000 1000000000

Sample Output 4

875699961

Solution in C++14 (GCC 5.4.1) (judge verdict: Wrong Answer)

#include<iostream>
#include<string>
#include<vector>
#include<map>
#include<algorithm>
#include<cmath>
#include<set>
using namespace std;
const int64_t mod = 1e9 + 7;
int64_t mod_pow(int64_t n,int64_t x){//nをx乗
    if(x%2==0){
        if(x==0){
            return 1;
        }else{
            int64_t z=mod_pow(n,x/2);
            return (z*z)%mod;
        }
    }else{
        if(x==1){
            return n;
        }else{
            int64_t z=mod_pow(n,(x-1)/2);
            return (z*((z*n)%mod))%mod;
        }
    }
}
int64_t solv(int64_t N,int64_t K){
    int64_t res;
    if(N%2==1){
        res = (mod_pow(K,(N+1)/2) - K + mod)%mod;
        res = (res * N + K)%mod;
    }
    if(N%2==0){
        if(N%4==0){
            int64_t tmp1 = (mod_pow(K,N/4)-K+mod)%mod;
            int64_t tmp2 = (mod_pow(K,N/2) - K - tmp1 + 2*mod)%mod;
            //cout << tmp1 << ' '<<tmp2 <<endl;
            res = (K + tmp1 * N * mod_pow(4,mod-2)%mod + tmp2 * N * mod_pow(2,mod-2)%mod )%mod;
        }else{
            res = ((mod_pow(K,N/2)-K+mod)*N)%mod;
            res *= mod_pow(2,mod-2);
            res = (res+K)%mod;
        }
    }
    return res;
    
}


int main(){
    int64_t N,K;
    cin>>N>>K;
    cout<< solv(N,K) <<endl;
    
    
    
    
    return 0;
}