#include <bits/stdc++.h>
using namespace std;
#define name "aaaaaa"
#define endl "\n"
#define fi first
#define se second
using ll = long long;
using db = double;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using ppii = pair<int, pii>;
using vi = vector<int>;
using vll = vector<ll>;
using vd = vector<double>;

template <const int m> 
struct Mint {
    int v; static_assert(m > 0);
    Mint(ll value = 0): v(value % m) { if (v < 0) v += m; }
    friend istream& operator >> (istream& inp, Mint& a) {
        ll x; inp >> x;
        a = x; return inp;
    }
    friend ostream& operator << (ostream& out, const Mint& a) { out << a.v; return out; }
    
    Mint operator + () const { return *this; }
    Mint operator - () const { return Mint() - *this; }
    
    Mint& operator++() { ++v; if (v == m) v = 1; return *this; }
    Mint& operator--() { if (v == 0) v = m; --v; return *this; }
    Mint operator++(int) { Mint ans = *this; ++*this; return ans; }
    Mint operator--(int) { Mint ans = *this; *this; return ans; }
    
    Mint& operator += (const Mint& other) { v += other.v; if (v >= m) v -= m; return *this; }
    Mint& operator -= (const Mint& other) { v -= other.v; if (v < 0) v += m; return *this; }
    Mint& operator *= (const Mint& other) { v = int64_t(v) * other.v % m; if (v < 0) v += m; return *this; }
    Mint inv() const {
        ll a = 1, b = 0;
        for (ll x = v, y = m; x != 0;)
            swap(a, b -= y / x * a), swap(x, y -= y / x * x);
        if (b < 0) b += m;
        return b;
    }
    Mint& operator /= (const Mint& other) { return *this *= other.inv(); }
    
    friend Mint operator + (const Mint& a, const Mint& b) { return Mint(a) += b; }
    friend Mint operator - (const Mint& a, const Mint& b) { return Mint(a) -= b; }
    friend Mint operator * (const Mint& a, const Mint& b) { return Mint(a) *= b; }
    friend Mint operator / (const Mint& a, const Mint& b) { return Mint(a) /= b; }
    
    friend bool operator == (const Mint& a, const Mint& b) { return a.v == b.v; }
    friend bool operator != (const Mint& a, const Mint& b) { return a.v == b.v; }
};

const int mod = 1e9 + 7;
using mint = Mint <mod>;

mint binpow(mint a, ll b){
    mint res = 1;
    while(b){
        if(b & 1ll) res *= a;
        a *= a;
        b /= 2;
    }
    return res;
}

mint inv(mint x){ return binpow(x, mod - 2); }

vector<int> U(int n){
    vector<int> v;
    for(int i = 1; i * i <= n; i++){
        if(n % i == 0){
            v.push_back(i);
            if(i * i != n) v.push_back(n / i);
        }
    }
    sort(v.begin(), v.end());
    return v;
}

ll lcm(ll x, ll y){
    return x / __gcd(x, y) * y;
}

const int N = 5e3 + 5;

ll sus[N];

void solve(){
    ll n, m, k;
    cin >> n >> m >> k;

    auto U1 = U(n), U2 = U(m);

    map<ll, mint> totient;
    sus[0] = 1;
    for(int i = 1; i < U1.size(); i++){
        for(int j = i - 1; j >= 0; j--){
            if(U1[i] % U1[j] != 0) continue;
            ll cur = U1[i] / U1[j];
            if(U1[j] % cur == 0){
                sus[i] = sus[j] * cur;
            }else{
                sus[i] = sus[j] * (cur - 1);
            }
            break;
        }
    }
    for(int i = 0; i < U1.size(); i++) totient[U1[i]] = sus[i];

    sus[0] = 1;
    for(int i = 1; i < U2.size(); i++){
        for(int j = i - 1; j >= 0; j--){
            if(U2[i] % U2[j] != 0) continue;
            ll cur = U2[i] / U2[j];
            if(U2[j] % cur == 0){
                sus[i] = sus[j] * cur;
            }else{
                sus[i] = sus[j] * (cur - 1);
            }
            break;
        }
    }
    for(int i = 0; i < U2.size(); i++) totient[U2[i]] = sus[i];

    mint res = 0;
    for(ll x : U1){
        for(ll y : U2){
            ll sus = n * m / lcm(n / x, m / y);
            res += binpow(k, sus) * totient[n / x] * totient[m / y];
        }
    }

    cout << res * inv(n * m);
}

int main(){
    if(fopen(name".inp", "r")){
        freopen(name".inp", "r", stdin);
        freopen(name".out", "w", stdout);
    }
    solve();
}