Language: C++

#include <cmath>
#include <cstdio>
#pragma warning(disable : 4996)
template<typename Type> Type gcd(Type a, Type b) {
	if (b == 0) return a;
	return gcd(b, a % b);
}
// ----- Fraction Class ------ //
template<typename Type> class Fraction {
public:
	// ------ Variable ------ //
	Type p, q;
	// ------ Constructor ------ //
	Fraction() : p(0), q(1) {}
	Fraction(const Type& p_, const Type& q_) : p(p_ / gcd(abs(p_), abs(q_))), q(q_ / gcd(abs(p_), abs(q_))) { if (q < 0) p = -p, q = -q; }
	Fraction(const Fraction<Type> f) : p(f.p), q(f.q) {}
	// ------ Operator ------ //
	template<typename Type> friend bool operator==(const Fraction<Type>& f1, const Fraction<Type>& f2) { return f1 == f2; }
	template<typename Type> friend bool operator!=(const Fraction<Type>& f1, const Fraction<Type>& f2) { return f1 != f2; }
	template<typename Type> friend Fraction operator+(const Fraction<Type>& f1, const Fraction<Type>& f2) { return Fraction(f1.p * f2.q + f1.q * f2.p, f1.q * f2.q); }
	template<typename Type> friend Fraction operator-(const Fraction<Type>& f1, const Fraction<Type>& f2) { return Fraction(f1.p * f2.q - f1.q * f2.p, f1.q * f2.q); }
	template<typename Type> friend Fraction operator*(const Fraction<Type>& f1, const Fraction<Type>& f2) { return Fraction(f1.p * f2.p, f1.q * f2.q); }
	template<typename Type> friend Fraction operator/(const Fraction<Type>& f1, const Fraction<Type>& f2) { return Fraction(f1.p * f2.q, f1.q * f2.p); }
	template<typename Type> friend bool operator<(const Fraction<Type>& f1, const Fraction<Type>& f2) { return Fraction f3 = f1 - f2; return f3.p < 0; }
	template<typename Type> friend bool operator>(const Fraction<Type>& f1, const Fraction<Type>& f2) { return Fraction f3 = f1 - f2; return f3.p > 0; }
	template<typename Type> friend bool operator<=(const Fraction<Type>& f1, const Fraction<Type>& f2) { return Fraction f3 = f1 - f2; return f3.p <= 0; }
	template<typename Type> friend bool operator>=(const Fraction<Type>& f1, const Fraction<Type>& f2) { return Fraction f3 = f1 - f2; return f3.p >= 0; }
	template<typename Type> Fraction& operator+=(const Fraction<Type>& f1) { Fraction f2 = Fraction(p * f1.q + q * f1.p, q * f1.q); p = f2.p; q = f2.q; return *this; }
	template<typename Type> Fraction& operator-=(const Fraction<Type>& f1) { Fraction f2 = Fraction(p * f1.q - q * f1.p, q * f1.q); p = f2.p; q = f2.q; return *this; }
	template<typename Type> Fraction& operator*=(const Fraction<Type>& f1) { Fraction f2 = Fraction(p * f1.p, q * f1.q); p = f2.p; q = f2.q; return *this; }
	template<typename Type> Fraction& operator/=(const Fraction<Type>& f1) { Fraction f2 = Fraction(p * f1.q, q * f1.p); p = f2.p; q = f2.q; return *this; }
};
Fraction<int> f; int p, q, a, n;
int solve(Fraction<int> f1, int a1, int c, int d) {
	if (f1 > f) return 0;
	if (f1 == f) return 1;
	if (d >= n) return 0;
	int ret = 0;
	for (int i = c; a1 * i <= a; i++) {
		ret += solve(f1 + Fraction<int>(1, i), a1 * i, i, d + 1);
	}
	return ret;
}
int main() {
	while (~scanf("%d%d%d%d", &p, &q, &a, &n)) {
		if (p == 0 && q == 0 && a == 0 && n == 0) break;
		f = Fraction<int>(p, q);
		printf("%d\n", solve(Fraction<int>(0, 1), 1, 1, 0));
	}
	return 0;
}

Compiler output:
a.cc:16:9: error: invalid constructor; you probably meant 'Fraction<Type> (const Fraction<Type>&)'
   16 |         Fraction(const Fraction<Type> f) : p(f.p), q(f.q) {}
      |         ^~~~~~~~
a.cc:18:18: error: declaration of template parameter 'Type' shadows template parameter
   18 |         template<typename Type> friend bool operator==(const Fraction<Type>& f1, const Fraction<Type>& f2) { return f1 == f2; }
      |                  ^~~~~~~~
a.cc:9:10: note: template parameter 'Type' declared here
    9 | template<typename Type> class Fraction {
      |          ^~~~~~~~
a.cc:19:18: error: declaration of template parameter 'Type' shadows template parameter
   19 |         template<typename Type> friend bool operator!=(const Fraction<Type>& f1, const Fraction<Type>& f2) { return f1 != f2; }
      |                  ^~~~~~~~
a.cc:9:10: note: template parameter 'Type' declared here
    9 | template<typename Type> class Fraction {
      |          ^~~~~~~~
a.cc:20:18: error: declaration of template parameter 'Type' shadows template parameter
   20 |         template<typename Type> friend Fraction operator+(const Fraction<Type>& f1, const Fraction<Type>& f2) { return Fraction(f1.p * f2.q + f1.q * f2.p, f1.q * f2.q); }
      |                  ^~~~~~~~
a.cc:9:10: note: template parameter 'Type' declared here
    9 | template<typename Type> class Fraction {
      |          ^~~~~~~~
a.cc:21:18: error: declaration of template parameter 'Type' shadows template parameter
   21 |         template<typename Type> friend Fraction operator-(const Fraction<Type>& f1, const Fraction<Type>& f2) { return Fraction(f1.p * f2.q - f1.q * f2.p, f1.q * f2.q); }
      |                  ^~~~~~~~
a.cc:9:10: note: template parameter 'Type' declared here
    9 | template<typename Type> class Fraction {
      |          ^~~~~~~~
a.cc:22:18: error: declaration of template parameter 'Type' shadows template parameter
   22 |         template<typename Type> friend Fraction operator*(const Fraction<Type>& f1, const Fraction<Type>& f2) { return Fraction(f1.p * f2.p, f1.q * f2.q); }
      |                  ^~~~~~~~
a.cc:9:10: note: template parameter 'Type' declared here
    9 | template<typename Type> class Fraction {
      |          ^~~~~~~~
a.cc:23:18: error: declaration of template parameter 'Type' shadows template parameter
   23 |         template<typename Type> friend Fraction operator/(const Fraction<Type>& f1, const Fraction<Type>& f2) { return Fraction(f1.p * f2.q, f1.q * f2.p); }
      |                  ^~~~~~~~
a.cc:9:10: note: template parameter 'Type' declared here
    9 | template<typename Type> class Fraction {
      |          ^~~~~~~~
a.cc:24:18: error: declaration of template parameter 'Type' shadows template parameter
   24 |         template<typename Type> friend bool operator<(const Fraction<Type>& f1, const Fraction<Type>& f2) { return Fraction f3 = f1 - f2; return f3.p < 0; }
      |                  ^~~~~~~~
a.cc:9:10: note: template parameter 'Type' declared here
    9 | template<typename Type> class Fraction {
      |          ^~~~~~~~
a.cc:25:18: error: declaration of template parameter 'Type' shadows template parameter
   25 |         template<typename Type> friend bool operator>(const Fraction<Type>& f1, const Fraction<Type>& f2) { return Fraction f3 = f1 - f2; return f3.p > 0; }
      |                  ^~~~~~~~
a.cc:9:10: note: template parameter 'Type' declared here
    9 | template<typename Type> class Fraction {
      |          ^~~~~~~~
a.cc:26:18: error: declaration of template parameter 'Type' shadows template parameter
   26 |         template<typename Type> friend bool operator<=(const Fraction<Type>& f1, const Fraction<Type>& f2) { return Fraction f3 = f1 - f2; return f3.p <= 0; }
      |                  ^~~~~~~~
a.cc:9:10: note: template parameter 'Type' declared here
    9 | template<typename Type> class Fraction {
      |          ^~~~~~~~
a.cc:27:18: error: declaration of template parameter 'Type' shadows template parameter
   27 |         template<typename Type> friend bool operator>=(const Fraction<Type>& f1, const Fraction<Type>& f2) { return Fraction f3 = f1 - f2; return f3.p >= 0; }
      |                  ^~~~~~~~
a.cc:9:10: note: template parameter 'Type' declared here
    9 | template<typename Type> class Fraction {
      |          ^~~~~~~~
a.cc:28:18: error: declaration of template parameter 'Type' shadows template parameter
   28 |         template<typename Type> Fraction& operator+=(const Fraction<Type>& f1) { Fraction f2 = Fraction(p * f1.q + q * f1.p, q * f1.q); p = f2.p; q = f2.q; return *this; }
      |                  ^~~~~~~~
a.cc:9:10: note: template parameter 'Type' declared here
    9 | template<typename Type> class Fraction {
      |          ^~~~~~~~
a.cc:29:18: error: declaration of template parameter 'Type' shadows template parameter
   29 |         template<typename Type> Fraction& operator-=(const Fraction<Type>& f1) { Fraction f2 = Fraction(p * f1.q - q * f1.p, q * f1.q); p = f2.p; q = f2.q; return *this; }
      |                  ^~~~~~~~
a.cc:9:10: note: template parameter 'Type' declared here
    9 | template<typename Type> class Fraction {
      |          ^~~~~~~~
a.cc:30:18: error: declaration of template parameter 'Type' shadows template parameter
   30 |         template<typename Type> Fraction& operator*=(const Fraction<Type>& f1) { Fraction f2 = Fraction(p * f1.p, q * f1.q); p = f2.p; q = f2.q; return *this; }
      |                  ^~~~~~~~
a.cc:9:10: note: template parameter 'Type' declared here
    9 | template<typename Type> class Fraction {
      |          ^~~~~~~~
a.cc:31:18: error: declaration of template parameter 'Type' shadows template parameter
   31 |         template<typename Type> Fraction& operator/=(const Fraction<Type>& f1) { Fraction f2 = Fraction(p * f1.q, q * f1.p); p = f2.p; q = f2.q; return *this; }
      |                  ^~~~~~~~
a.cc:9:10: note: template parameter 'Type' declared here
    9 | template<typename Type> class Fraction {
      |          ^~~~~~~~
a.cc: In function 'bool operator<(const Fraction<Type>&, const Fraction<Type>&)':
a.cc:24:125: error: expected primary-expression before 'f3'
   24 |         template<typename Type> friend bool operator<(const Fraction<Type>& f1, const Fraction<Type>& f2) { return Fraction f3 = f1 - f2; return f3.p < 0; }
      |                                                                                                                             ^~
a.cc:24:125: error: expected ';' before 'f3'
a.cc:24:125: error: 'f3' was not declared in this scope; did you mean 'f1'?
   24 |         template<typename Type> friend bool operator<(const Fraction<Type>& f1, const Fraction<Type>& f2) { return Fraction f3 = f1 - f2; return f3.p < 0; }
      |                                                                                                                             ^~
      |                                                                                                                             f1
a.cc: In function 'bool operator>(const Fraction<Type>&, const Fraction<Type>&)':
a.cc:25:125: error: expected primary-expression before 'f3'
   25 |         template<typename Type> friend bool operator>(const Fraction<Type>& f1, const Fraction<Type>& f2) { return Fraction f3 = f1 - f2; return f3.p > 0; }
      |                                                                                                                             ^~
a.cc:25:125: error: expected ';' before 'f3'
a.cc:25:125: error: 'f3' was not declared in this scope; did you mean 'f1'?
   25 |         template<typename Type> friend bool operator>(const Fraction<Type>& f1, const Fraction<Type>& f2) { return Fraction f3 = f1 - f2; return f3.p > 0; }
      |                                                                                                                             ^~
      |                                                                                                                             f1
a.cc: In function 'bool operator<=(const Fraction<Type>&, const Fraction<Type>&)':
a.cc:26:126: error: expected primary-expression before 'f3'
   26 |         template<typename Type> friend bool operator<=(const Fraction<Type>& f1, const Fraction<Type>& f2) { return Fraction f3 = f1 - f2; return f3.p <= 0; }
      |                                                                                                                              ^~
a.cc:26:126: error: expected ';' before 'f3'
a.cc:26:126: error: 'f3' was not declared in this scope; did you mean 'f1'?
   26 |         template<typename Type> friend bool operator<=(const Fraction<Type>& f1, const Fraction<Type>& f2) { return Fraction f3 = f1 - f2; return f3.p <= 0; }
      |                                                                                                                              ^~
      |                                                                                                                              f1
a.cc: In function 'bool operator>=(const Fraction<Type>&, const Fraction<Type>&)':
a.cc:27:126: error: expected primary-expression before 'f3'
   27 |         template<typename Type> friend bool operator>=(const Fraction<Type>& f1, const Fraction<Type>& f2) { return Fraction f3 = f1 - f2; return f3.p >= 0; }
      |                                                                                                                              ^~
a.cc:27:126: error: expected ';' before 'f3'
a.cc:27:126: error: 'f3' was not declared in this scope; did you mean 'f1'?
   27 |         template<typename Type> friend bool operator>=(const Fraction<Type>& f1, const Fraction<Type>& f2) { return Fraction f3 = f1 - f2; return f3.p >= 0; }
      |                                                                                                                              ^~
      |                                                                                                                              f1