#include <boost/metaparse/build_parser.hpp>
using namespace boost::metaparse;
using exp_parser1 = build_parser<int_>;

using int_token = token<int_>;
using plus_token = token<lit_c<'+'>>;

#include <boost/mpl/plus.hpp>
#include <boost/mpl/at.hpp>
template <class Vector> struct eval_plus : boost::mpl::plus< typename boost::mpl::at_c<Vector, 0>::type, typename boost::mpl::at_c<Vector, 2>::type > {};

eval_plus< boost::mpl::vector< mpl_::integral_c<int, 11>, mpl_::char_<'+'>, mpl_::integral_c<int, 2> >>::type

#include <boost/mpl/quote.hpp>
using exp_parser6 = build_parser< transform< sequence<int_token, plus_token, int_token>, boost::mpl::quote1<eval_plus> > >;

using exp_parser7 = build_parser< sequence< int_token,                                /* The first <number> */ repeated<sequence<plus_token, int_token>> /* The "+ <number>" elements */ > >;

using vector_of_numbers = boost::mpl::vector< boost::mpl::int_<2>, boost::mpl::int_<5>, boost::mpl::int_<6> >;

template <class Vector> struct sum_vector : boost::mpl::fold< Vector, boost::mpl::int_<0>, boost::mpl::lambda< boost::mpl::plus<boost::mpl::_1, boost::mpl::_2> >::type > {};

template <class Sum, class Item> struct sum_items : boost::mpl::plus< Sum, typename boost::mpl::at_c<Item, 1>::type > {};

sum_items< mpl_::integral_c<int, 1>, boost::mpl::vector<mpl_::char_<'+'>, mpl_::integral_c<int, 2>> >::type

boost::mpl::fold< boost::mpl::at_c<temp_result, 1>::type, /* The vector to summarise */ boost::mpl::int_<0>, /* The value to start the sum from */ boost::mpl::quote2<sum_items> /* The function to call in each iteration */ >::type

using exp_parser8 = build_parser< sequence< int_token, /* parse the first <number> */ transform< repeated<sequence<plus_token, int_token>>, /* parse the "+ <number>" elements */ /* lambda expression summarising the "+ <number>" elements using fold */ boost::mpl::lambda< /* The folding expression we have just created */ boost::mpl::fold< boost::mpl::_1, /* the argument of the lambda expression, the result */ /* of the repeated<...> parser */ boost::mpl::int_<0>, boost::mpl::quote2<sum_items> > >::type > > >;

using exp_parser9 = build_parser< transform< /* What we had so far */ sequence< int_token, transform< repeated<sequence<plus_token, int_token>>, boost::mpl::lambda< boost::mpl::fold< boost::mpl::_1, boost::mpl::int_<0>, boost::mpl::quote2<sum_items> > >::type > >, boost::mpl::quote1<sum_vector> /* summarise the vector of numbers */ > >;

using exp_parser10 = build_parser< transform< sequence< int_token, foldl< sequence<plus_token, int_token>, boost::mpl::int_<0>, boost::mpl::quote2<sum_items> > >, boost::mpl::quote1<sum_vector>> >;

>

using exp_parser11 = build_parser< foldl_start_with_parser< sequence<plus_token, int_token>, /* apply this parser repeatedly */ int_token, /* use this parser to get the initial value */ boost::mpl::quote2<sum_items> /* use this function to add a new value to the summary */ > >;

using exp_parser12 = build_parser< foldl_start_with_parser< sequence<one_of<plus_token, minus_token>, int_token>, int_token, boost::mpl::quote2<sum_items> > >;

template <class L, char Op, class R> struct eval_binary_op;
template <class L, class R> struct eval_binary_op<L, '+', R> : boost::mpl::plus<L, R>::type {};
template <class L, class R> struct eval_binary_op<L, '-', R> : boost::mpl::minus<L, R>::type {};

eval_binary_op<boost::mpl::int_<11>, '+', boost::mpl::int_<2>>::type
eval_binary_op<boost::mpl::int_<13>, '-', boost::mpl::int_<2>>::type

template <class S, class Item> struct binary_op : eval_binary_op< S, boost::mpl::at_c<Item, 0>::type::value, typename boost::mpl::at_c<Item, 1>::type > {};

using exp_parser13 = build_parser< foldl_start_with_parser< sequence<one_of<plus_token, minus_token>, int_token>, int_token, boost::mpl::quote2<binary_op> > >;

#include <boost/mpl/times.hpp>
template <class L, class R> struct eval_binary_op<L, '*', R> : boost::mpl::times<L, R>::type {};

using exp_parser14 = build_parser< foldl_start_with_parser< sequence<one_of<plus_token, minus_token, times_token>, int_token>, int_token, boost::mpl::quote2<binary_op> > >;

using exp_parser15 = build_parser< foldl_start_with_parser< sequence<one_of<plus_token, minus_token>, mult_exp1>, mult_exp1, boost::mpl::quote2<binary_op> > >;

#include <boost/mpl/divides.hpp>
template <class L, class R> struct eval_binary_op<L, '/', R> : boost::mpl::divides<L, R>::type {};
using divides_token = token<lit_c<'/'>>;
using mult_exp2 = foldl_start_with_parser< sequence<one_of<times_token, divides_token>, int_token>, int_token, boost::mpl::quote2<binary_op> >;
using exp_parser16 = build_parser< foldl_start_with_parser< sequence<one_of<plus_token, minus_token>, mult_exp2>, mult_exp2, boost::mpl::quote2<binary_op> > >;

template <class S, class Item> struct reverse_binary_op : eval_binary_op< typename boost::mpl::at_c<Item, 0>::type, boost::mpl::at_c<Item, 1>::type::value, S > {};

using mult_exp3 = foldr_start_with_parser< sequence<int_token, one_of<times_token, divides_token>>, /* The parser applied repeatedly */ int_token, /* The parser parsing the last number */ boost::mpl::quote2<reverse_binary_op> /* The function called for every result */ /* of applying the above parser */ >;

using exp_parser17 = build_parser< foldl_start_with_parser< sequence<one_of<plus_token, minus_token>, mult_exp3>, mult_exp3, boost::mpl::quote2<binary_op> > >;

#include <boost/mpl/negate.hpp>
using unary_exp1 = foldr_start_with_parser< minus_token, int_token, boost::mpl::lambda<boost::mpl::negate<boost::mpl::_1>>::type >;

using mult_exp4 = foldl_start_with_parser< sequence<one_of<times_token, divides_token>, unary_exp1>, unary_exp1, boost::mpl::quote2<binary_op> >;
using exp_parser18 = build_parser< foldl_start_with_parser< sequence<one_of<plus_token, minus_token>, mult_exp4>, mult_exp4, boost::mpl::quote2<binary_op> > >;

exp_parser18::apply<BOOST_METAPARSE_STRING("---13")>::type
exp_parser18::apply<BOOST_METAPARSE_STRING("13")>::type

using lparen_token = token<lit_c<'('>>;
using rparen_token = token<lit_c<')'>>;

using plus_exp1 = foldl_start_with_parser< sequence<one_of<plus_token, minus_token>, mult_exp4>, mult_exp4, boost::mpl::quote2<binary_op> >;

#include <boost/metaparse/middle_of.hpp>
using paren_exp2 = middle_of<lparen_token, plus_exp1, rparen_token>;

using paren_exp3 = middle_of<lparen_token, plus_exp2, rparen_token>;
using primary_exp2 = one_of<int_token, paren_exp2>;
using unary_exp2 = foldr_start_with_parser< minus_token, primary_exp2, boost::mpl::lambda<boost::mpl::negate<boost::mpl::_1>>::type >;
using mult_exp5 = foldl_start_with_parser< sequence<one_of<times_token, divides_token>, unary_exp2>, unary_exp2, boost::mpl::quote2<binary_op> >;

struct plus_exp2 : foldl_start_with_parser< sequence<one_of<plus_token, minus_token>, mult_exp5>, mult_exp5, boost::mpl::quote2<binary_op> > {};

struct plus_exp3;
using paren_exp4 = middle_of<lparen_token, plus_exp3, rparen_token>;

using unary_exp3 = foldr_start_with_parser< minus_token, primary_exp3, boost::mpl::lambda<boost::mpl::negate<boost::mpl::_1>>::type >;
using mult_exp6 = foldl_start_with_parser< sequence<one_of<times_token, divides_token>, unary_exp3>, unary_exp3, boost::mpl::quote2<binary_op> >;
struct plus_exp3 : foldl_start_with_parser< sequence<one_of<plus_token, minus_token>, mult_exp6>, mult_exp6, boost::mpl::quote2<binary_op> > {};
using exp_parser20 = build_parser<plus_exp3>;

#include <boost/metaparse/fail_at_first_char_expected.hpp>
#include <boost/metaparse/first_of.hpp>
struct plus_exp4 : first_of< foldl_start_with_parser< sequence<one_of<plus_token, minus_token>, mult_exp6>, mult_exp6, boost::mpl::quote2<binary_op> >, fail_at_first_char_expected< sequence<one_of<plus_token, minus_token>, mult_exp6> > > {};
using exp_parser21 = build_parser<plus_exp4>;

#include <boost/metaparse/foldl_reject_incomplete_start_with_parser.hpp>
struct plus_exp5 : foldl_reject_incomplete_start_with_parser< sequence<one_of<plus_token, minus_token>, mult_exp6>, mult_exp6, boost::mpl::quote2<binary_op> > {};
using exp_parser22 = build_parser<plus_exp5>;

struct plus_exp6;
using paren_exp5 = middle_of<lparen_token, plus_exp6, rparen_token>;
using primary_exp4 = one_of<int_token, paren_exp5, fail<missing_primary_expression>>;
using unary_exp4 = foldr_start_with_parser< minus_token, primary_exp4, boost::mpl::lambda<boost::mpl::negate<boost::mpl::_1>>::type >;
using mult_exp7 = foldl_reject_incomplete_start_with_parser< sequence<one_of<times_token, divides_token>, unary_exp4>, unary_exp4, boost::mpl::quote2<binary_op> >;
struct plus_exp6 : foldl_reject_incomplete_start_with_parser< sequence<one_of<plus_token, minus_token>, mult_exp7>, mult_exp7, boost::mpl::quote2<binary_op> > {};
using exp_parser23 = build_parser<plus_exp6>;