void MyF1(vector<int>& vec, int s)
{
    transform(vec.begin(), vec.end(), vec.begin(), (s + _1));
}

?MyF1@@YAXAAV?$vector@HV?$allocator@H@std@@@std@@H@Z PROC ; MyF1, COMDAT
    mov    eax, DWORD PTR _vec$[esp-4]
    mov    ecx, DWORD PTR [eax+4]
    mov    edx, DWORD PTR [eax+8]
    mov    eax, ecx
    cmp    eax, edx
    push    esi
    push    edi
    je    SHORT $LN71@MyF1
    mov    esi, DWORD PTR _s$[esp+4]
$LL82@MyF1:
    mov    edi, DWORD PTR [eax]
    add    edi, esi
    mov    DWORD PTR [ecx], edi
    add    eax, 4
    add    ecx, 4
    cmp    eax, edx
    jne    SHORT $LL82@MyF1
$LN71@MyF1:
    pop    edi
    pop    esi
    ret    0

#include <list>
#include <string>
#include <iostream>
#include <boost/algorithm/string/split.hpp>
#include <boost/algorithm/string/classification.hpp>

#define OS_POSIX

#ifdef OS_WINDOWS
#include <windows.h> // for GetTickCount
#else // posix
#include <sys/times.h>
#endif

using namespace std;
using namespace boost::algorithm;

int main()
{
#ifdef OS_WINDOWS
  DWORD start = GetTickCount();
#else
  struct tms t;
  long ts = sysconf(_SC_CLK_TCK);
  double start = ((double) times(&t) / ts) * 1000;
#endif
    
  int res = 0;
  for(int i = 0; i < 1000000; i++)
  {
    list<string> tokens; 
    split(tokens, "123 345 asdf 23453 asdfas", is_any_of(" "));
    res += tokens.size();
  }


#ifdef OS_WINDOWS
  DWORD stop = GetTickCount();
#else
  double stop = ((double) times(&t) / ts) * 1000;
#endif

  cout << "res is " << res << ',' << stop - start << " ms elapsed\n";
  
  return 0;
}

/*!
    \since v.4.2.7
    \brief Предикат для std::find_if.

    Для очередного состояния проверяет возможность слияния
    с состоянием из другого класса агентов.

    Определяет, есть ли среди всех классов, на которые ссылаются
    состояния, еще не полностью определенные классы.
*/
class    merge_possibility_checker_t
    :    public std::unary_function<
            const state_handler_impl_ptr_vector_t::value_type &,
            bool >
    {
    private :
        /*! Список всех классов. */
        const class_map_t & m_all_classes;

        /*! Список состояний всех классов */
        const std_class_relation_handler_t::class_info_map_t &
            m_classes_state;

        /*! Принимает значение true, если были найдены не
            полностью определенные классы. */
        bool    & m_is_incomplete_class_found;

        /*! Приемник описания ошибки. */
        std::string &    m_error_desc;

    public :
        //! Основной конструктор.
        merge_possibility_checker_t(
            //! Список всех классов.
            const class_map_t & all_classes,
            const std_class_relation_handler_t::class_info_map_t &
                classes_state,
            bool & is_incomplete_class_found,
            //! Приемник описания ошибки.
            std::string & error_desc )
            :    m_is_incomplete_class_found( is_incomplete_class_found )
            ,    m_all_classes( all_classes )
            ,    m_classes_state( classes_state )
            ,    m_error_desc( error_desc )
            {}

        result_type
        operator()( argument_type a );

    private :
        /*! Проверка наличия указанного состояния в указанном
            классе.

            \return true, если состояние найдено. */
        bool
        try_find_state_in_class(
            //! Имя искомого состояния.
            const std::string & state_name,
            //! Класс, в котором состояние нужно найти.
            const class_handler_impl_t & class_handler );
    };

merge_possibility_checker_t::result_type
merge_possibility_checker_t::operator()( argument_type a )
    {
        bool result = false;

        const state_handler_impl_t::merge_list_t & merge_list =
            a->merge_list();

        for( state_handler_impl_t::merge_list_t::const_iterator
                it = merge_list.begin(), it_end = merge_list.end();
            it != it_end;
            ++it )
            {
                bool is_merge_valid = false;

                const state_handler_impl_t::merge_t & m = *it;

                // Должен быть известен класс.
                class_map_t::const_iterator it_class = m_all_classes.find(
                    m.m_class_name );
                if( it_class != m_all_classes.end() )
                    {
                        int state = m_classes_state.find(
                            m.m_class_name )->second.m_state;
                        // Класс должен быть полностью определен.
                        if( std_class_relation_handler_t::state_valid == state )
                            {
                                // Должно быть известно состояние.
                                if( try_find_state_in_class(
                                    m.m_state_name, *( it_class->second ) ) )
                                    // Все хорошо. Поэтому, чтобы перейти к обработке
                                    // следующего состояния, нужно возвратить false.
                                    is_merge_valid = true;
                                else
                                    {
                                        // Состояние не известно.
                                        m_error_desc += std::string( "state '" ) +
                                            a->query_name() +
                                            "' requires merging with undefined state '" +
                                            m.m_state_name + "' from class '" +
                                            m.m_class_name + "';";
                                    }
                            }
                        else if( std_class_relation_handler_t::state_invalid == state )
                            // Нашли ссылку на некорректный класс.
                            m_error_desc += std::string( "state '" ) +
                                a->query_name() +
                                "' requires merging with invalid class '" +
                                m.m_class_name + "';";
                        else
                            {
                                // Класс еще не определен.
                                m_is_incomplete_class_found = true;
                                m_error_desc += std::string( "incomplete class: " ) +
                                    m.m_class_name + ";";
                            }
                    }
                else
                    // Нашли ссылку на неизвестный класс.
                    m_error_desc += std::string( "state '" ) + a->query_name() +
                        "' requires merging with undefined class '" +
                        m.m_class_name + "';";

                // Если текущее слияние не корректно, то и состояние не может
                // быть корректным.
                if( !is_merge_valid )
                    result = true;
            }

        return result;
    }

bool
merge_possibility_checker_t::try_find_state_in_class(
    const std::string & state_name,
    const class_handler_impl_t & class_handler )
    {
        const state_handler_impl_ptr_vector_t & states =
            class_handler.query_state_handlers();
        return ( states.end() != std::find_if(
            states.begin(), states.end(),
            state_by_name_finder_t( state_name ) ) );
    }

int
std_class_relation_handler_t::try_merge_states(
    const class_handler_impl_t & class_handler,
    const class_map_t & all_classes,
    std::string & error_desc )
    {
        // Берем все состояния, которые нуждаются в слиянии.
        state_handler_impl_ptr_vector_t states_for_merging =
            class_handler.states_for_merge();

        // Проверяем возможность проведения слияния.
        bool is_incomplete_class_found = false;
        merge_possibility_checker_t checker( all_classes, m_classes,
            is_incomplete_class_found, error_desc );
        if( states_for_merging.end() != std::find_if(
            states_for_merging.begin(), states_for_merging.end(),
            checker ) )
            // Слияние не возможно. Осталось только определить,
            // по какой причине.
            return ( is_incomplete_class_found ?
                state_not_processed :
                state_invalid );

        // Выполняем слияние.
        std::for_each( states_for_merging.begin(),
            states_for_merging.end(),
            merge_maker_t( all_classes ) );

        return state_valid;
    }

D>void MyF1(vector<int>& vec, int s)
D>{
D>    transform(vec.begin(), vec.end(), vec.begin(), (s + _1));
D>}
D>

transform.(s + _);