#include <vector>
#include <iterator>
#include <algorithm>
#include <iostream>
#include <cassert>

auto sieve(int limit) {
	std::vector<bool> primes_lookup(limit);
	// kod z neta
	unsigned long long int i,j;
	
    for (i=2;i<limit;i++)
    	primes_lookup[i]=1;
    	
    for (i=2;i<limit;i++)
    	if (primes_lookup[i])
            for (j=i;i*j<limit;j++)
                primes_lookup[i*j]=0;
        
	return primes_lookup;
}

template<typename Cont>
auto extract_primes(Cont const &primes_lookup) {
	std::vector<int> result;
	for (int i = 0; i < primes_lookup.size(); ++i) {
		if (primes_lookup[i]) {
			result.push_back(i);
		}
	}
	return result;
}

template<typename Cont>
auto calc_factors(Cont const &primes, int num) {
	std::vector<int> result;
	
	for (int i = 0; i < primes.size() && primes[i] <= num;) {
		if (num % primes[i]) {
			i += 1;
			continue;
		} else {
			result.push_back(primes[i]);
			num /= primes[i];
		}
	}
	return result;
}

int main() {
	auto const primes = extract_primes(
		sieve(100000)
	);

	auto calc_factors = [&primes](int num) {
		return ::calc_factors(primes, num);
	};
	
	// a spróbuj tylko pchać jakieś factorsy które nie są posortowane i które nie są l. pierwszymi
	auto condition = [&primes](auto factors) -> bool {
		if (!factors.size()) return false;
		
		auto last = std::unique(std::begin(factors), std::end(factors));
		return std::equal(
			std::begin(factors),
			last,
			std::find(std::begin(primes), std::end(primes), factors[0])
		);
	};
	
	for(int num = 0; std::cin >> num;) {
		auto factors = calc_factors(num);
		std::cout
			<< (condition(factors)? "warunek spelnia " : "warunku nie spelnia ")
			<< num
			<< " -> ";

		for(auto el: factors) std::cout << el << " ";

		std::cout << std::endl;
	}
	return 0;
}