#include <bits/stdc++.h>
using namespace std;

using ll = long long;
const ll MOD = 1000000007;

struct mint
{
    ll x;
    mint(ll x = 0) : x(x % MOD) {}
    mint& operator+=(const mint rh) { if((x += rh.x) >= MOD) x -= MOD; return *this; }
    mint& operator-=(const mint rh) { if((x += MOD-rh.x) >= MOD) x -= MOD; return *this; }
    mint& operator*=(const mint rh) { (x *= rh.x) %= MOD; return *this; }
    mint operator+(const mint rh) const { return mint(*this) += rh; }
    mint operator-(const mint rh) const { return mint(*this) -= rh; }
    mint operator*(const mint rh) const { return mint(*this) *= rh; }
    mint pow(ll k) const
    {
        if(!k) return 1;
        mint a = x;
        mint res = 1;
        while(k)
        {
            if(k & 1) res *= a;
            k >>= 1;
            a *= a;
        }
        return res;
    }
    mint inv() const { return pow(MOD-2); }
    mint& operator/=(const mint rh) { return *this *= rh.inv(); }
    mint operator/(const mint rh) { return mint(*this) /= rh; }
};

template <typename T>
struct matrix
{
    int r, c;
    vector<vector<T>> mat;
    //単位行列
    static matrix e(int n) { matrix res(n, n); for(int i=0; i<n; i++) res[i][i] = (T)1; return res; }

    //コンストラクタ
    matrix() = default;
    matrix(int r, int c, T val = 0) : r(r), c(c), mat(r, vector<T>(c,val)) {}
    matrix(vector<vector<T>> mat) : r((int)mat.size()), c((int)mat[0].size()), mat(mat) {}

    matrix operator-() const { matrix B = mat; for(int i=0; i<r; i++) for(int j=0; j<c; j++) B.mat[i][j] = -B.mat[i][j]; return B; }
    //添え字演算子
    vector<T> operator[](const int i) const { return mat[i]; }
    vector<T>& operator[](const int i) { return mat[i]; }

    //比較演算子
    bool operator==(matrix B) { if(r != B.r || c != B.c) return false; for(int i=0; i<r; i++) for(int j=0; j<c; j++) if(mat[i][j] != B.mat[i][j]) return false; return true; }
    bool operator!=(matrix B) { return !((*this) == B); }
    //スカラ演算
    matrix& operator+=(const T k) { for(int i=0; i<r; i++) for(int j=0; j<c; j++) mat[i][j] += k; return *this; }
    matrix& operator-=(const T k) { for(int i=0; i<r; i++) for(int j=0; j<c; j++) mat[i][j] -= k; return *this; }
    matrix& operator*=(const T k) { for(int i=0; i<r; i++) for(int j=0; j<c; j++) mat[i][j] *= k; return *this; }
    matrix operator+(const T k) const { return matrix(*this) += k; }
    matrix operator-(const T k) const { return matrix(*this) -= k; }
    matrix operator*(const T k) const { return matrix(*this) *= k;}
    //行列と行列の演算
    matrix& operator=(const matrix B) { mat = B.mat, r = B.r, c = B.c; return *this; }
    matrix& operator+=(const matrix B) { assert(r == B.r && c == B.c); for(int i=0; i<r; i++) for(int j=0; j<c; j++) mat[i][j] += B.mat[i][j]; return *this; }
    matrix& operator-=(const matrix B) { *this += (-B); return *this; }
    matrix& operator*=(const matrix B)
    {
        assert(c == B.r);
        vector<vector<T>> m(r, vector<T>(B.c, 0));
        for(int i=0; i<r; i++)
        {
            for(int j=0; j<B.c; j++)
            {
                T sum = 0;
                for(int k=0; k<c; k++) sum += (*this)[i][k] * B[k][j];
                m[i][j] = sum;
            }
        }
        c = B.c;
        mat = m;
        return *this;
    }
    matrix operator+(const matrix B) const { return matrix(*this) += B; }
    matrix operator-(const matrix B) const { return matrix(*this) -= B; }
    matrix operator*(const matrix B) const { return matrix(*this) *= B; }
    matrix pow(long long k) const
    {
        assert(k >= 0);
        assert(c == r);
        matrix x = mat;
        matrix res = e(r);
        while(k)
        {
            if(k & 1) res = (res * x);
            k >>= 1;
            x *= x;
        }
        return res;
    }
    matrix inv() const {}
    matrix& operator/=(const matrix B) { (*this) *= B.inv(); return *this; }
    matrix& operator/(const matrix B) const { return matrix(*this) /= B; }
    //変形する操作
    matrix& transpose() { vector<vector<T>> res(c, vector<T>(r)); for(int i=0; i<r; i++) for(int j=0; j<c; j++) res[j][i] = mat[i][j]; mat = res; return *this; }
    matrix& rotate(int n = 1) {}
    //変形しない操作
    matrix transposed() const { return matrix(*this).transpose();}
    matrix rotated() const { return matrix(*this).rotate(); }

    T diterminant() const {}
    pair<int, int> size() const { return make_pair(r, c); }
    void show(int wid = 2) const
    {
        for(int i=0; i<r; i++)
        {
            for(int j=0; j<c; j++)
            {
                cout << mat[i][j] << setw(wid);
            }
            cout << "\n";
        }
        cout << "\n";
    }
};


int main()
{
    ll a, b, n;
    cin >> a >> b >> n;
    mint a1(2), a2(2*a);
    matrix<mint> t(2, 2);
    t[0][0] = 2*a;
    t[0][1] = mint(mint(b) - mint(a*a));
    t[1][0] = mint(1);
    t[1][1] = mint(0);
    t = t.pow(n);
    mint ans = t[1][0] * a2 + t[1][1] * a1;
    cout << ans.x << endl;

    return 0;
}