struct Cut final
    {
        Cut(uint16_t _length, uint32_t _count) : length(_length), count(_count) {}

        uint16_t length = 0x0;
        uint32_t count = 0x0;
    };

    struct Order final
    {
        std::vector<Cut> dataset = {};

        Order(const Order& _order, SolutionNode* _node);
        Order(const Order& _order, SolutionNode* _node, bool _recursion);
        Order(const Dataset& _order, SolutionNode* _node);

        auto remove_by_pattern(const Pattern* const _pattern, uint32_t _repeat) -> void;
        auto get_pattern_repeat(const Pattern& _pattern) const -> uint16_t;
        inline auto max_element() const -> decltype(auto) { return dataset.rbegin()->length; }
    };

auto Edesia::SolutionNode::multi_thread_spreading(Order&& _init_order) -> void
{
    uint8_t allocations = 0x0;

    const auto valid_patterns = sInterface->sorted_unique_patterns.find(_init_order.max_element());
    for (auto pattern = valid_patterns->second.crbegin(); pattern != valid_patterns->second.crend(); ++pattern)
    {
        if (allocations == data.size())
            break;

        if (const uint16_t pattern_repeat = _init_order.get_pattern_repeat(*pattern->get().lengths))
        {
            if (data.solution_loss + pattern->get().loss*pattern_repeat > sInterface->runtime_statistics->solution_loss)
                continue;

            data[allocations++] = new SolutionNode(this, pattern->get(), pattern_repeat, Settings::multi_thread_spread_limit);
        }
    }
    SolutionNode::begin_next_level_spreading(this, _init_order);
}

auto Edesia::SolutionNode::begin_next_level_spreading(SolutionNode* const _parent, const Order& _init_order) const -> void
{
    /* Start spreading from future nodes... */
    std::for_each(_parent->data.rbegin(), _parent->data.rend(), [&](SolutionNode* const _node) -> void
    {
        if (_node)
        {
            Order future_order = Order(_init_order, _node);
            if (future_order.dataset.empty())
            {
                if (_node->data.stock_used < sInterface->runtime_statistics->stock_used)
                {
                    sInterface->runtime_statistics->unique_patterns = _node->data.unique_patterns;;
                    sInterface->runtime_statistics->stock_used = _node->data.stock_used;
                    sInterface->runtime_statistics->solution_loss = _node->data.solution_loss;
                    Helper::print_solution(_node, "-> Less stock found!");
                    return;
                }

                /* We found better solution loss than our statistic algorithm. Update _statistic object. */
                if (_node->data.solution_loss < sInterface->runtime_statistics->solution_loss)
                {
                    sInterface->runtime_statistics->unique_patterns = _node->data.unique_patterns;
                    sInterface->runtime_statistics->solution_loss =_node->data.solution_loss;
                    Helper::print_solution(_node, "-> Smaller loss found!");
                    return;
                }

                if (_node->data.unique_patterns < sInterface->runtime_statistics->unique_patterns)
                {
                    sInterface->runtime_statistics->unique_patterns = _node->data.unique_patterns;
                    Helper::print_solution(_node, "Less unique patterns found!");
                    return;
                }
                return;
            }

            if (sInterface->runtime_statistics->unique_patterns < _node->data.unique_patterns+1)
                return;

            _node->multi_thread_spreading(std::move(future_order));
        }
    });
}