#include <iostream>
#include <cassert>

using namespace std;

#define int long long

int splits(int streams, int desiredNumSplits) {
	assert(streams > 0);
	assert(desiredNumSplits > 0);
	int perSplitStreams = (streams + desiredNumSplits - 1) / desiredNumSplits;	
	return (streams + perSplitStreams - 1) / perSplitStreams;
}

int findLeftFaster(int p, int B, int target) {
	// cerr << p << " " << B << " " << target << endl;
	// (B*p+x)/(p+1) = target
	int small = (B * p + 1 + p) / (p + 1);
	int large = (B * p + B - 1 + p) / (p + 1);
	if (target >= small && target <= large) {
		int x = (target - 1) * (p + 1) - B * p + 1;
		return max(x, 1LL);
	} else {
		return -1;
	}
}

int findLeft(int p, int B, int target) {
	int lo = 1;
	int hi = B - 1;
	int ans = -1;
	while (lo <= hi) {
		int mid = (lo + hi) / 2;
		int my_splits = splits(B * p + mid, B);
		if (my_splits == target) {
			ans = mid;
		}
		if (my_splits >= target) {
			hi = mid - 1;
		} else {
			lo = mid + 1;
		}
	}
	return ans;
}

int findRightFaster(int p, int B, int target) {
	// cerr << p << " " << B << " " << target << endl;
	// (B*p+x)/(p+1) = (target+1)
	if ((B * p + B - 1 + p) / (p + 1) >= target) {
		int x = target * (p + 1) - B * p;
		return min(x, B - 1);
	} else {
		return -1;
	}
}

int findRight(int p, int B, int target) {
	int lo = 1;
	int hi = B - 1;
	int ans = -1;
	while (lo <= hi) {
		int mid = (lo + hi) / 2;
		int my_splits = splits(B * p + mid, B);
		if (my_splits == target) {
			ans = mid;
		}
		if (my_splits <= target) {
			lo = mid + 1;
		} else {
			hi = mid - 1;
		}
	}
	return ans;
}

int get(int N, int p, int B, int target) {
	// return 0;
	// #print(p, B, target)
	// int l = findLeft(p, B, target);
	int l = findLeftFaster(p, B, target);
	// cerr << "l " << " " << l << " " << " ll " << ll << endl;
	// assert(l == ll);
	// # print('l', l, 'r', r)
	if (l != -1 && B * p + l <= N) {
		// int r = findRight(p, B, target);
		int r = findRightFaster(p, B, target);
		// cerr << "r " << " " << r << " " << " rr " << rr << endl;
		// assert(r == rr);
		return (min(B * p + r, N) - (B * p + l)) + 1;
	}
	return 0;
}

int solveLargeB(int N, int B, int target) {
	int ans = 0;
	if (target == B) {
		ans = N / B;
	}
	for (int p = 0; p < (N + B - 1) / B + 1; p++) {
		ans += get(N, p, B, target);
	}
	// for p in range(0, ):		
	return ans;
}

const int LIM = 40000;

int solveSmallB(int N, int B, int target) {
	int ans = 0;
	for (int p = 0; p < B; p++) {
		int g = get(N, p, B, target);
		// # print('p', p, 'g', g)
		ans += g;
	}		
	// #[B*B, N]
	if (target == B) {
		ans += min(B * (long long) B - 1, (long long) N) / B;
		if (B * (long long) B <= N) {
			ans += (N - B * B + 1);
		}
	}
	return ans;
}

int solve(int N, int B, int target) {
	if (B >= LIM) {
		return solveLargeB(N, B, target);
	} else {
		return solveSmallB(N, B, target);
	}
}

#undef int

int main() {
	int T, testNum = 1;
	cin >> T;
	while (T--) {
		int N, B, target;
		cin >> N >> B >> target;
		assert(B > 0);
		// cerr << "testNum " << testNum << endl;
		cout << solve(N, B, target) << endl;
		testNum++;
	}
	return 0;
}