#include <bits/stdc++.h>
 
using namespace std;
 
class BigInt {
private:
    static const int BASE = 1000000000;
    static const int BASE_DIGITS = 9;
    bool is_negative;
 
    void trim() {
        while (!digits.empty() && digits.back() == 0)
            digits.pop_back();
        if (digits.empty())
            is_negative = false;
    }
 
    static BigInt abs(const BigInt& n) {
        BigInt result = n;
        result.is_negative = false;
        return result;
    }
 
public:
    std::vector<int> digits;
 
    BigInt() : is_negative(false) {}
 
    BigInt(long long value) {
        if (value < 0) {
            is_negative = true;
            value = -value;
        } else {
            is_negative = false;
        }
 
        while (value) {
            digits.push_back(value % BASE);
            value /= BASE;
        }
    }
 
    BigInt(const std::string& str) {
        is_negative = false;
        digits.clear();
        int start = 0;
 
        if (!str.empty() && str[0] == '-') {
            is_negative = true;
            start = 1;
        }
 
        for (int i = str.size() - 1; i >= start; i -= BASE_DIGITS) {
            int end = std::max(start, i - BASE_DIGITS + 1);
            int part = std::stoi(str.substr(end, i - end + 1));
            digits.push_back(part);
        }
 
        trim();
    }
 
    friend std::ostream& operator<<(std::ostream& out, const BigInt& n) {
        if (n.is_negative && !n.digits.empty())
            out << "-";
        if (n.digits.empty()) {
            out << "0";
        } else {
            out << n.digits.back();
            for (int i = n.digits.size() - 2; i >= 0; i--)
                out << std::setw(BASE_DIGITS) << std::setfill('0') << n.digits[i];
        }
        return out;
    }
 
    bool operator==(const BigInt& other) const {
        return is_negative == other.is_negative && digits == other.digits;
    }
 
    bool operator<(const BigInt& other) const {
        if (is_negative != other.is_negative)
            return is_negative;
 
        if (digits.size() != other.digits.size())
            return digits.size() < other.digits.size();
 
        for (int i = digits.size() - 1; i >= 0; i--) {
            if (digits[i] != other.digits[i])
                return digits[i] < other.digits[i];
        }
 
        return false;
    }
 
    bool operator<=(const BigInt& other) const {
        return *this < other || *this == other;
    }
 
    BigInt operator+(const BigInt& other) const {
        if (is_negative != other.is_negative) {
            return *this - (-other);
        }
 
        BigInt result;
        result.is_negative = is_negative;
 
        int carry = 0;
        for (size_t i = 0; i < std::max(digits.size(), other.digits.size()) || carry; ++i) {
            if (i == result.digits.size())
                result.digits.push_back(0);
 
            result.digits[i] = carry + (i < digits.size() ? digits[i] : 0) +
                               (i < other.digits.size() ? other.digits[i] : 0);
            carry = result.digits[i] >= BASE;
            if (carry)
                result.digits[i] -= BASE;
        }
 
        return result;
    }
 
    BigInt operator-(const BigInt& other) const {
        if (is_negative != other.is_negative) {
            return *this + (-other);
        }
 
        if (abs(*this) < abs(other)) {
            return -(other - *this);
        }
 
        BigInt result;
        result.is_negative = is_negative;
 
        int carry = 0;
        for (size_t i = 0; i < digits.size() || carry; ++i) {
            result.digits.push_back(digits[i] - carry - (i < other.digits.size() ? other.digits[i] : 0));
            carry = result.digits.back() < 0;
            if (carry)
                result.digits.back() += BASE;
        }
 
        result.trim();
        return result;
    }
 
    BigInt operator*(const BigInt& other) const {
        BigInt result;
        result.digits.resize(digits.size() + other.digits.size());
        result.is_negative = is_negative != other.is_negative;
 
        for (size_t i = 0; i < digits.size(); ++i) {
            long long carry = 0;
            for (size_t j = 0; j < other.digits.size() || carry; ++j) {
                long long current = result.digits[i + j] +
                                    1LL * digits[i] * (j < other.digits.size() ? other.digits[j] : 0) + carry;
                carry = current / BASE;
                result.digits[i + j] = current % BASE;
            }
        }
 
        result.trim();
        return result;
    }
    
    void operator /= (long long x) {
        for (int i = (int) digits.size() - 1; i >= 0; i--) {
            if (i) digits[i - 1] += (digits[i] % x) * BASE;
            digits[i] /= x;
        }
        while (!digits.empty() && digits.back() == 0)
            digits.pop_back();
    }
    
    BigInt operator / (long long x) {
        BigInt n(*this);
        n /= x;
        return n;
    }
 
    BigInt operator-() const {
        BigInt result = *this;
        result.is_negative = !result.is_negative;
        return result;
    }
    
    bool is_even() {
        return digits.empty() || digits[0] % 2 == 0;
    }
};
 
void simplify(BigInt &a, BigInt &b) {
    if (a == 0) {
        b = 1;
        return;
    }
    if (b == 0) {
        a = 1;
        return;
    }
    if (a.is_even() && b.is_even()) {
        a = a / 2;
        b = b / 2;
        simplify(a, b);
        return;
    }
    if (a.is_even()) {
        a = a / 2;
        simplify(a, b);
        a = a * 2;
        return;
    }
    if (b.is_even()) {
        b = b / 2;
        simplify(a, b);
        b = b * 2;
        return;
    }
    if (b < a) {
        simplify(b, a);
        return;
    }
    b = b - a;
    simplify(a, b);
    b = b + a;
}
 
const int N = 101;
 
BigInt f[N];
BigInt c[N][N];
BigInt t[N];
 
void precalc() {
    f[0] = 1;
 
    for (int i = 1; i < N; ++i) {
        f[i] = f[i - 1] * i;
    }
 
    for (int i = 0; i < N; ++i) {
        c[i][0] = c[i][i] = 1;
        for (int j = 1; j < i; ++j) {
            c[i][j] = c[i - 1][j - 1] + c[i - 1][j];
        }
    }
}
 
BigInt binpow(const BigInt& x, int y) {
    if (y == 0) {
        return 1;
    }
    if (y & 1) {
        return binpow(x, y - 1) * x;
    }
    BigInt z = binpow(x, y / 2);
    return z * z;
}
 
int32_t main() {
    precalc();
 
    int n, m, k;
 
    while (cin >> n >> m >> k) {
        if (n == m && m == k && k == 0) {
            break;
        }
        if (k > min(n, m)) {
            cout << "0/1\n";
            continue;
        }
        if (m == 0) {
            cout << (k == m) << '/' << 1 << '\n';
            continue;
        }
 
        t[0] = 0;
        for (int i = 1; i <= k; ++i) {
            t[i] = binpow(i, m);
            for (int j = 0; j < i; ++j) {
                t[i] = t[i] - c[i][j] * t[j];
            }
        }
 
        BigInt p = c[n][k] * t[k];
        BigInt q = binpow(n, m);
        
        simplify(p, q);
 
        cout << p << '/' << q << '\n';
    }
}