#include <iostream>
#include <vector>
#include <cmath>
using namespace std;
 
// Prints a complete factorization in the form:
//    if factors is empty: "1x<n>"
//    else: "<factors[0]>x<factors[1]>x...x<n>"
void printFactorization(const vector<int>& factors, int lastFactor) {
    if (factors.empty()) {
        cout << "1x" << lastFactor << "\n";
    } else {
        for (size_t i = 0; i < factors.size(); ++i) {
            cout << factors[i] << "x";
        }
        cout << lastFactor << "\n";
    }
}
 
// Recursive helper function.
//   n      : the remaining product to factorize.
//   start  : the minimum factor to try (to enforce non-decreasing order)
//   factors: the current factors chosen (by reference)
void printFactorizationsHelper(int n, int start, vector<int>& factors) {
    // Print the current factorization (factors followed by the remaining factor n).
    printFactorization(factors, n);
 
    // Try all factors i from 'start' up to √n.
    // If i divides n, then push i into factors and recurse with n/i.
    // (Because factors are chosen in non-decreasing order, each factorization is unique.)
    for (int i = start; i <= static_cast<int>(sqrt(n)); ++i) {
        if (n % i == 0) {
            factors.push_back(i);
            printFactorizationsHelper(n / i, i, factors);
            factors.pop_back();
        }
    }
}
 
int main() {
    int n = 24;
    vector<int> factors;
    // We start with factor 2 since 1 is handled specially in printFactorization.
    printFactorizationsHelper(n, 2, factors);
    return 0;
}
 

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