// Template
#define FORESTED
#include "bits/stdc++.h"
#define rep_override(x, y, z, name, ...) name
#define rep2(i, n) for (int i = 0; i < (int)(n); ++i)
#define rep3(i, l, r) for (int i = (int)(l); i < (int)(r); ++i)
#define rep(...) rep_override(__VA_ARGS__, rep3, rep2)(__VA_ARGS__)
#define per(i, n) for (ll i = (ll)(n) - 1; i >= 0; --i)
#define all(x) (x).begin(), (x).end()
using namespace std;
using ll = long long;
constexpr int inf = 1001001001;
constexpr ll INF = 3003003003003003003LL;
template <typename T>
inline bool chmin(T &x, const T &y) {
    if (x > y) {
        x = y;
        return true;
    }
    return false;
}
template <typename T> 
inline bool chmax(T &x, const T &y) {
    if (x < y) {
        x = y;
        return true;
    }
    return false;
}
struct IOSET {
    IOSET() {
        cin.tie(nullptr);
        ios::sync_with_stdio(false);
        cout << fixed << setprecision(10);
    }
} ioset;
template <typename T>
istream &operator>>(istream &is, vector<T> &vec) {
    for (T &element : vec) is >> element;
    return is;
}
template <typename T>
vector<T> operator--(vector<T> &vec) {
    for (T &element : vec) --element;
    return vec;
}

// Mod-Int
#ifndef FORESTED
#include "template.cpp"
#endif

#define MOD_INT
template <int MOD>
struct ModInt {
    static_assert(MOD >= 1);
    
    long long val;
    
    ModInt() = default;
    
    ModInt(long long x) : val(x % MOD + (x < 0 ? MOD : 0)) {}
    
    ModInt<MOD> &operator+= (const ModInt<MOD> &x) {
        if ((val += x.val) >= MOD) val -= MOD;
        return *this;
    }
    
    ModInt<MOD> &operator-= (const ModInt<MOD> &x) {
        if ((val -= x.val) < 0) val += MOD; 
        return *this;
    }
    
    ModInt<MOD> &operator*= (const ModInt<MOD> &x) {
        (val *= x.val) %= MOD; return *this;
    }
    
    ModInt<MOD> operator+ (const ModInt<MOD> &x) const {
        return ModInt(*this) += x;
    }
    
    ModInt<MOD> operator- (const ModInt<MOD> &x) const {
        return ModInt(*this) -= x;
    }
    
    ModInt<MOD> operator* (const ModInt<MOD> &x) const {
        return ModInt(*this) *= x;
    }
    
    ModInt<MOD> pow(long long t) const {
        assert(t >= 0);
        ModInt<MOD> res(1), now(*this);
        while (t) {
            if (t & 1) res *= now;
            now *= now;
            t >>= 1;
        }
        return res;
    }
    
    ModInt<MOD> inv() const {
        return pow(MOD - 2);
    }
    
    ModInt<MOD> &operator/= (const ModInt<MOD> &x) {
        return *this *= x.pow(MOD - 2);
    }
    
    ModInt<MOD> operator/ (const ModInt<MOD> &x) const {
        return ModInt(*this) /= x;
    }
    
    friend std::istream &operator>> (std::istream &is, ModInt<MOD> &x) {
        long long a;
        is >> a;
        x = ModInt<MOD>(a);
        return is;
    }
    
    friend std::ostream &operator<< (std::ostream &os, const ModInt<MOD> &x) {
        os << x.val;
        return os;
    }
};

constexpr int mod = 1000000007;
using mint = ModInt<mod>;

// Square Matrix
#ifndef FORESTED
#include "template.cpp"
#endif

#define SQUARE_MATRIX
template <typename T, int N>
class SquareMatrix {
    static_assert(N >= 0);
    
    std::array<std::array<T, N>, N> arr;
    
public:
    const std::array<T, N> &operator[](int x) const {
        assert(x >= 0 && x < N);
        return arr[x];
    }
    
    std::array<T, N> &operator[](int x) {
        assert(x >= 0 && x < N);
        return arr[x];
    }
    
    static SquareMatrix identity() {
        SquareMatrix<T, N> s;
        for (int i = 0; i < N; ++i) {
            for (int j = 0; j < N; ++j) {
                if (i == j) {
                    s.arr[i][j] = T(1);
                } else {
                    s.arr[i][j] = T(0);
                }
            }
        }
        return s;
    }
    
    SquareMatrix &operator+=(const SquareMatrix<T, N> &x) {
        for (int i = 0; i < N; ++i) {
            for (int j = 0; j < N; ++j) {
                arr[i][j] += x.arr[i][j];
            }
        }
        return *this;
    }
    
    SquareMatrix &operator-=(const SquareMatrix<T, N> &x) {
        for (int i = 0; i < N; ++i) {
            for (int j = 0; j < N; ++j) {
                arr[i][j] -= x.arr[i][j];
            }
        }
        return *this;
    }
    
    SquareMatrix &operator*=(const SquareMatrix<T, N> &x) {
        std::array<std::array<T, N>, N> res;
        for (int i = 0; i < N; ++i) {
            for (int j = 0; j < N; ++j) {
                res[i][j] = T(0);
            }
        }
        for (int i = 0; i < N; ++i) {
            for (int j = 0; j < N; ++j) {
                for (int k = 0; k < N; ++k) {
                    res[i][j] += arr[i][k] * x.arr[k][j];
                }
            }
        }
        arr.swap(res);
        return *this;
    }
    
    SquareMatrix operator+(const SquareMatrix<T, N> &x) const {
        return SquareMatrix(*this) += x;
    }
    
    SquareMatrix operator-(const SquareMatrix<T, N> &x) const {
        return SquareMatrix(*this) -= x;
    }
    
    SquareMatrix operator*(const SquareMatrix<T, N> &x) {
        return SquareMatrix(*this) *= x;
    }
    
    SquareMatrix pow(long long x) const {
        assert(x >= 0);
        SquareMatrix<T, N> a(*this);
        SquareMatrix<T, N> b = SquareMatrix<T, N>::identity();
        while (x) {
            if (x & 1) {
                b *= a;
            }
            a *= a;
            x >>= 1;
        }
        return b;
    }
};

// Main
int main() {
    int a, b, n;
    cin >> a >> b >> n;
    SquareMatrix<mint, 2> s;
    s[0][0] = mint(a);
    s[0][1] = mint(b);
    s[1][0] = mint(1);
    s[1][1] = mint(0);
    auto t = s.pow(n);
    cout << t[1][0] << "\n";
}