Problem:
Score: 900 points

Problem Statement

In 2937, DISCO creates a new universe called DISCOSMOS to celebrate its 1000-th anniversary.

DISCOSMOS can be described as an H \times W grid. Let (i, j) (1 \leq i \leq H, 1 \leq j \leq W) denote the square at the i-th row from the top and the j-th column from the left.

At time 0, one robot will be placed onto each square. Each robot is one of the following three types:

Type-H: Does not move at all.

Type-R: If a robot of this type is in (i, j) at time t, it will be in (i, j+1) at time t+1. If it is in (i, W) at time t, however, it will be instead in (i, 1) at time t+1. (The robots do not collide with each other.)

Type-D: If a robot of this type is in (i, j) at time t, it will be in (i+1, j) at time t+1. If it is in (H, j) at time t, however, it will be instead in (1, j) at time t+1.

There are 3^{H \times W} possible ways to place these robots. In how many of them will every square be occupied by one robot at times 0, T, 2T, 3T, 4T, and all subsequent multiples of T?

Since the count can be enormous, compute it modulo (10^9 + 7).

Constraints

1 \leq H \leq 10^9

1 \leq W \leq 10^9

1 \leq T \leq 10^9

H, W, T are all integers.

Input

Input is given from Standard Input in the following format:

H W T

Output

Print the number of ways to place the robots that satisfy the condition, modulo (10^9 + 7).

Sample Input 1

2 2 1

Sample Output 1

9

Shown below are some of the ways to place the robots that satisfy the condition, where ., >, and v stand for Type-H, Type-R, and Type-D, respectively:

>> .. vv
.. .. vv

Sample Input 2

869 120 1001

Sample Output 2

672919729

Solution in Kotlin (1.0.0) (judge verdict: Accepted)

import java.io.BufferedReader
import java.io.InputStream
import java.io.InputStreamReader
import java.util.*

const val mod = (1e9 + 7).toInt()

fun main(args: Array<String>) {
    val sc = FastScanner(System.`in`)

    val H = sc.nextLong()
    val W = sc.nextLong()
    val t = sc.nextLong()

    val w = gcd(W, t)
    val h = gcd(H, t)

    var res = 0L

    val x = H / h
    val y = W / w
    res = (res + pow(2, x)) % mod
    res = (res + pow(2, y)) % mod
    res = (res + pow(2, gcd(x, y))) % mod
    res = (res - 3 + mod) % mod

    res = pow(res, w * h)

    println(res)
    /*val n = sc.nextLong()
    val m = sc.nextLong()
    val T = sc.nextLong()
    val gn = gcd(T, n)
    val gm = gcd(T, m)
    val mod = 1000000007
    val q = gcd(n / gn, m / gm)
    var res = 0L
    res = (res + pow(2, q)) % mod
    res = (res + pow(2, n / gn)) % mod
    res = (res + pow(2, m / gm)) % mod
    res = (res - 3 +mod) % mod
    println(pow(res, gn * gm))*/
}

fun inv(h: Long): Long = pow(h, (mod - 2).toLong())

fun gcd(a: Long, b: Long): Long = if (b == 0L) a else gcd(b, a % b)
fun pow(a: Long, x: Long): Long {
    var res = 1L
    var x = x
    var a = a
    while (x > 0) {
        if (x % 2 == 1L) res = (res * a) % mod
        a = (a * a) % mod
        x /= 2
    }
    return res
}


class FastScanner(s: InputStream) {
    private var st = StringTokenizer("")
    private val br = BufferedReader(InputStreamReader(s))

    fun next(): String {
        while (!st.hasMoreTokens()) st = StringTokenizer(br.readLine())

        return st.nextToken()
    }

    fun nextInt() = next().toInt()
    fun nextLong() = next().toLong()
    fun nextLine() = br.readLine()
    fun nextDouble() = next().toDouble()
    fun ready() = br.ready()
}