Distribute argument parameter pack to invoke two functors

I'm trying to invoke two functional objects through one given argument pack (typename Args... args), an integer parameter is provided to mark the border where i need to split the pack to invoke both functional objects correctly.

Consider the following example:

Args... = <int, int, std::vector<int>, std::vector<int>>
unsigned Bounds = 2;

functor Foo (left) and Bar (right)

// Foo is invoked with <int, int>
// Bar is invoked with <std::vector<int>, std::vector<int>>

// An evaluator template class is invoked to merge the result of both,
// for example with an add (operator+) operation

My idea was to create two integer sequences and use std::get to invoke both functional objects at once with those two integer sequences:

// Sequence creator
template<unsigned Position, unsigned Count, unsigned... Pack>
struct make_sequence
    : std::conditional<
        Count == 0,
        std::common_type<sequence<Pack...>>,
        make_sequence<Position + 1, Count - 1, Pack..., Position>
    >::type { };

// Create a sequence from inclusive from to exclusive to
template<unsigned InclusiveFrom, unsigned ExclusiveTo>
using make_sequence_from_to_t = typename make_sequence<
    InclusiveFrom,
    (ExclusiveTo <= InclusiveFrom) ? 0U : (ExclusiveTo - InclusiveFrom)
>::type;

template<typename LeftType, typename RightType, unsigned Bounds, typename Evaluator>
class distribute_functor
{
    LeftType left_;
    RightType right_;

    template<unsigned... LeftSeq, unsigned... RightSeq, typename... Args>
    auto internal_invoke(sequence<LeftSeq...>, sequence<RightSeq...>, Args... args)
    {
        return Evaluator::evaluate(left_(std::get<LeftSeq>(args)...),
//                                 ~~~~~~~~~~~~~~~^^^^^^^~~^^^^~~~~~
//                                 error C3528: 'LeftSeq': the number of
//                                 elements in this pack expansion does not
//                                 match the number of elements in 'args'
                                   right_(std::get<RightSeq>(args)...));
    }

public:
    template<typename Left, typename Right>
    distribute_functor(Left left, Right right)
        : left_(std::forward<Left>(left)), right_(std::forward<Right>(right)) { }

    template<typename... Args>
    auto operator() (Args... args)
    {
        return internal_invoke(make_sequence_from_to_t<0, Bounds>{},
                               make_sequence_from_to_t<Bounds, sizeof...(Args)>{},
                               std::forward<Args>(args)...);
    }
};

However the VisualStudio 14 compiler complains about a mismatch between the count of parameters in the arguments pack and in the sequence:

error C3528: 'LeftSeq': the number of elements in this pack expansion does not match the number of elements in 'args'

There is still the way to use std::tuple for the functor invocation which i don't prefer.

Is there another or better way to partial invoke two functional objects in one step from one argument pack?