#include <bits/stdc++.h>

int main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr);
	std::cout.tie(nullptr);
	int64_t n, m, k;
	while (std::cin >> n >> m >> k) {
		auto fastpow = [&](int64_t x, int64_t p) {
			const int64_t inf = 1e9;
			int64_t r = 1;
			while (p) {
				if (p & 1) r = std::min(inf, r * x);
				x = std::min(inf, x * x);
				p >>= 1;
			}
			return r;
		};
		auto solve = [&](int64_t n, int64_t m, int64_t k) -> int64_t{
			if (n == 1) {
				if (k == 1)
					return 2 * m * (2 * m + 1);
				return 0;
			}
			std::vector<std::vector<int>> divisors(m + 1, std::vector<int>());
			// Case 1: x == 0
			std::vector<std::pair<int, int>> vecs;
			auto report = [&](int a, int b, int x) {
				vecs.emplace_back(a, b);
			};
			for (int a = -m; a <= m; ++a)
				report(a, 0, 0);
			for (int64_t x = 1; x <= m; ++x) {
				int64_t z = fastpow(x, n - 1);
				if (z >= 1000'000'000) break;
				for (int _b = 0; _b <= m; _b += x) {
					for (int sgnx : {-1, 1})
						for (int sgnb : {-1, 1}) {
							if (_b == 0 && sgnb == -1)
								continue;
							int symbol = sgnx;
							if (n % 2 == 1 && sgnx == -1)
								symbol = 1;
							int64_t b = sgnb * _b, Za = b / x * sgnx;
							int64_t a = -Za - symbol * z;
							if (std::abs(a) > m) continue;
							report(a, b, sgnx * x);
						//	assert(fastpow(sgnx * x, n) + a * sgnx * x + b == 0);
						}
				}
			}
			int64_t ans = 0;
			std::sort(vecs.begin(), vecs.end());
			for (int l = 0, r; l < vecs.size(); ++l) {
				r = l;
				while (r + 1 < vecs.size() && vecs[r] == vecs[r + 1])
					++r;
				if (r - l + 1 == k)
					++ans;
				l = r;
			}	
			return ans;
		};
		std::cout << solve(n, m, k) << '\n';
	}
}