pre-release

/// Factor the number, ignoring factors greater than `max`. Returns a vec of tuples `Vec<(lo, hi)>`
/// where `lo` <= `max` and `lo` > `hi`
fn factor(number: &BigUint, max: &BigUint) -> FactorList {
    let mut factors = FactorList::new();
    let mut one = ToBigUint::to_biguint(&1).unwrap();
    let mut zero = ToBigUint::to_biguint(&0).unwrap();
    let mut loop_idx = ToBigUint::to_biguint(&2).unwrap();
    let loop_max = std::cmp::min(number.sqrt(), max.clone());

    loop {
        if loop_idx > loop_max {
            break;
        }

        if number % &loop_idx == zero {
            factors.push((loop_idx.clone(), number / &loop_idx));
        }

        loop_idx = &loop_idx + &one;
    }
    factors
}

/// Factor `number` into the `tree`, avoiding lo-factors greater than `max`.
fn factor_tree(number: &BigUint, max: &BigUint, tree: &mut FactorTree) {
    if tree.contains_key(&number) {
        return;
    }

    let factors = factor(number, max);
    if factors.is_empty() {
        return;
    }

    tree.insert(number.clone(), factors.clone());

    for (_, hi) in factors {
        factor_tree(&hi, max, tree);
    }
}

fn collect_solutions(
    number: &BigUint,
    tree: &FactorTree,
    max: &BigUint,
    solution_callback: fn(Vec<BigUint>),
    so_far: &mut Vec<BigUint>,
) {
    if number <= max {
        so_far.push(number.clone());
        solution_callback(so_far.clone());
        so_far.pop();
    }

    let factors = match tree.get(number) {
        Some(v) => v,
        None => {
            return;
        }
    };

    for (lo, hi) in factors {
        so_far.push(lo.clone());
        collect_solutions(hi, tree, max, solution_callback, so_far);
        so_far.pop();

        if hi <= max {
            so_far.push(hi.clone());
            collect_solutions(lo, tree, max, solution_callback, so_far);
            so_far.pop();
        }
    }
}