/*
	p1 * p2 = a
	p1 * q2 + p2 * q1 = b
	q1 * q2 = c

	all divisors of a -> fixam p1, p2

	p1 * q2 + p2 * q1 = b | * q1

	p1 * c + p2 * q1 ^ 2 - b * q1 = 0
	p2 * q1 ^ 2 - b * q1 + p1 * c = 0
		delta = b ^ 2 - 4 * a * c
	q1 = (b +- sqrt(delta)) / 2p2
	q2 = c / q1;

	scriem pe toate
*/
#include <bits/stdc++.h>
using namespace std;

using ll = long long;

vector<ll> all_divs(const ll x){
	vector<ll> rez;
	for(ll i = 1; i*i <= x; ++i){
		if(x%i) continue;
		rez.push_back(i);
		rez.push_back(-i);
		rez.push_back(x/i);
		rez.push_back(-x/i); }
	sort(begin(rez), end(rez));
	rez.erase(unique(begin(rez), end(rez)), end(rez));
	return rez; }

struct a_solution{
	ll p1, q1, p2, q2;
	a_solution(const ll x, const ll y, const ll z, const ll p):
		p1(x), q1(y), p2(z), q2(p){}
	bool operator<(const a_solution& rhs)const{
		return p1 < rhs.p1 || (p1 == rhs.p1 && q1 < rhs.q1); }
	bool operator==(const a_solution& rhs)const{
		return p1 == rhs.p1 && q1 == rhs.q1 && p2 == rhs.p2 && q2 == rhs.q2; } };

void print_paren(ostream& lhs, const ll p, const ll q){
	lhs << '(';
	if(p == 1);
	else if(p == -1) lhs << '-';
	else lhs << p;
	lhs << 'x';
	if(q >= 0) lhs << '+';
	lhs << q;
	lhs << ')'; }

ostream& operator<<(ostream& lhs, const a_solution& rhs){
	print_paren(lhs, rhs.p1, rhs.q1);
	print_paren(lhs, rhs.p2, rhs.q2);
	return lhs; }
	
ll real_sqrt(const ll x){
	ll i = 1;
	for(ll j = (1ll<<30); j; j /= 2){
		if((i+j) * (i+j) <= x) i += j; }
	return i; }

void add_solution_if_possible(const ll a, const ll b, const ll c,
		const ll p1, const ll p2, vector<a_solution>& sols){
	const static ll delta = (b * b) - 4ll * a * c;
	const static ll sqdelta = real_sqrt(delta);
	if(sqdelta * sqdelta != delta) return;
	
	auto do_a_q1 = [&](const ll q1){
		const ll q2 = c / q1;
		if(q2 * q1 != c) return;
		sols.emplace_back(p1, q1, p2, q2); };

	const ll q10 = (b + sqdelta) / (2ll * p2),
		q11 = (b - sqdelta) / (2ll * p2);

	if(q10 * 2ll * p2 == (b + sqdelta)) do_a_q1(q10);
	if(q11 * 2ll * p2 == (b - sqdelta)) do_a_q1(q11); }

int main(){
	ifstream f("ecuatie.in");
	ofstream g("ecuatie.out");
	ll a, b, c;
	f >> a >> b >> c;

	vector<ll> divs = all_divs(a);
	vector<a_solution> sols;

	for(const auto x : divs){
		add_solution_if_possible(a, b, c, x, a/x, sols); }

	sort(begin(sols), end(sols));
	sols.erase(unique(begin(sols), end(sols)), end(sols));

	ll k;
	f >> k;

	if(k-1 >= sols.size()) g << -1;
	else g << sols[k-1] << endl;
	return 0; }