#include<bits/stdc++.h>
#include<atcoder/modint>
using namespace atcoder;
using mint = modint1000000007;
using namespace std;
#define ll long long
#define rep(i, N) for(ll i = 0; i < N; i++)

// /* ACL版：NTT可能なmodintで使用する */
// #include<atcoder/convolution>
// using namespace atcoder;
// template <class T>
// vector<T> multiply(const vector<T>& a, const vector<T>& b) {
// 	return atcoder::convolution(a, b);
// }

/* 愚直版：ACLの畳み込みが使えない型で使用する */
template <class T>
vector<T> multiply(const vector<T>& a, const vector<T>& b) {
	if (a.empty() || b.empty()) return {};
	vector<T> c(a.size() + b.size() - 1);
	for (size_t i = 0; i < a.size(); ++i) {
		for (size_t j = 0; j < b.size(); ++j) {
			c[i + j] += a[i] * b[j];
		}
	}
	return c;
}

/**
 * 母関数A(x) = P(x) / Q(x) の x^n の係数を返す
 * 計算量 O(M(d) log n)
 * d := deg(Q)
 * M(d) := 次数 d の多項式同士の畳み込みにかかる計算量
 */
template <class T>
T bostan_mori(
	vector<T> p, vector<T> q,
	unsigned long long n
) {
	assert(!q.empty() && q[0] != T{});

	while (!p.empty() && p.back() == T{}) p.pop_back();
	assert(p.size() < q.size());

	const size_t d = q.size();
	p.resize(d - 1);

	while (n != 0) {
		vector<T> q_neg = q;
		for (size_t i = 1; i < q_neg.size(); i += 2) {
			q_neg[i] = -q_neg[i];
		}

		auto pq = multiply(p, q_neg);
		auto qq = multiply(q, q_neg);

		vector<T> next_p(d - 1);
		vector<T> next_q(d);
		const size_t parity = static_cast<size_t>(n & 1ULL);
		for (size_t i = 0; i < next_p.size(); ++i) {
			if (2 * i + parity < pq.size()) next_p[i] = pq[2 * i + parity];
		}
		for (size_t i = 0; i < next_q.size(); ++i) {
			if (2 * i < qq.size()) next_q[i] = qq[2 * i];
		}

		p = move(next_p);
		q = move(next_q);
		n >>= 1;
	}

	return p.empty() ? T{} : p[0] / q[0];
}


int main(void) {
	ll A,B,N;
	
	cin>>A>>B>>N;

	vector<mint>P={0,1},Q={1,-A,-B};
	cout<<bostan_mori(P,Q,N).val()<<endl;
	
	return 0;
}