code:
# /* **************************************************************************
#  *                                                                          *
#  *     (C) Copyright Paul Mensonides 2002.
#  *     Distributed under the Boost Software License, Version 1.0. (See
#  *     accompanying file LICENSE_1_0.txt or copy at
#  *     http://www.boost.org/LICENSE_1_0.txt)
#  *                                                                          *
#  ************************************************************************** */
#
# /* See http://www.boost.org for most recent version. */
#
# if defined(BOOST_PP_ITERATION_LIMITS)
#    if !defined(BOOST_PP_FILENAME_2)
#        error BOOST_PP_ERROR:  depth #2 filename is not defined
#    endif
#    define BOOST_PP_VALUE BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_ITERATION_LIMITS)
#    include <boost/preprocessor/iteration/detail/bounds/lower2.hpp>
#    define BOOST_PP_VALUE BOOST_PP_TUPLE_ELEM(2, 1, BOOST_PP_ITERATION_LIMITS)
#    include <boost/preprocessor/iteration/detail/bounds/upper2.hpp>
#    define BOOST_PP_ITERATION_FLAGS_2() 0
#    undef BOOST_PP_ITERATION_LIMITS
# elif defined(BOOST_PP_ITERATION_PARAMS_2)
#    define BOOST_PP_VALUE BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ITERATION_PARAMS_2)
#    include <boost/preprocessor/iteration/detail/bounds/lower2.hpp>
#    define BOOST_PP_VALUE BOOST_PP_ARRAY_ELEM(1, BOOST_PP_ITERATION_PARAMS_2)
#    include <boost/preprocessor/iteration/detail/bounds/upper2.hpp>
#    define BOOST_PP_FILENAME_2 BOOST_PP_ARRAY_ELEM(2, BOOST_PP_ITERATION_PARAMS_2)
#    if BOOST_PP_ARRAY_SIZE(BOOST_PP_ITERATION_PARAMS_2) >= 4
#        define BOOST_PP_ITERATION_FLAGS_2() BOOST_PP_ARRAY_ELEM(3, BOOST_PP_ITERATION_PARAMS_2)
#    else
#        define BOOST_PP_ITERATION_FLAGS_2() 0
#    endif
# else
#    error BOOST_PP_ERROR:  depth #2 iteration boundaries or filename not defined
# endif
#
# undef BOOST_PP_ITERATION_DEPTH
# define BOOST_PP_ITERATION_DEPTH() 2
#
# if (BOOST_PP_ITERATION_START_2) > (BOOST_PP_ITERATION_FINISH_2)
#    include <boost/preprocessor/iteration/detail/iter/reverse2.hpp>
# else
#    if BOOST_PP_ITERATION_START_2 <= 0 && BOOST_PP_ITERATION_FINISH_2 >= 0
#        define BOOST_PP_ITERATION_2 0
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 1 && BOOST_PP_ITERATION_FINISH_2 >= 1
#        define BOOST_PP_ITERATION_2 1
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 2 && BOOST_PP_ITERATION_FINISH_2 >= 2
#        define BOOST_PP_ITERATION_2 2
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 3 && BOOST_PP_ITERATION_FINISH_2 >= 3
#        define BOOST_PP_ITERATION_2 3
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 4 && BOOST_PP_ITERATION_FINISH_2 >= 4
#        define BOOST_PP_ITERATION_2 4
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 5 && BOOST_PP_ITERATION_FINISH_2 >= 5
#        define BOOST_PP_ITERATION_2 5
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 6 && BOOST_PP_ITERATION_FINISH_2 >= 6
#        define BOOST_PP_ITERATION_2 6
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 7 && BOOST_PP_ITERATION_FINISH_2 >= 7
#        define BOOST_PP_ITERATION_2 7
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 8 && BOOST_PP_ITERATION_FINISH_2 >= 8
#        define BOOST_PP_ITERATION_2 8
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 9 && BOOST_PP_ITERATION_FINISH_2 >= 9
#        define BOOST_PP_ITERATION_2 9
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 10 && BOOST_PP_ITERATION_FINISH_2 >= 10
#        define BOOST_PP_ITERATION_2 10
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 11 && BOOST_PP_ITERATION_FINISH_2 >= 11
#        define BOOST_PP_ITERATION_2 11
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 12 && BOOST_PP_ITERATION_FINISH_2 >= 12
#        define BOOST_PP_ITERATION_2 12
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 13 && BOOST_PP_ITERATION_FINISH_2 >= 13
#        define BOOST_PP_ITERATION_2 13
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 14 && BOOST_PP_ITERATION_FINISH_2 >= 14
#        define BOOST_PP_ITERATION_2 14
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 15 && BOOST_PP_ITERATION_FINISH_2 >= 15
#        define BOOST_PP_ITERATION_2 15
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 16 && BOOST_PP_ITERATION_FINISH_2 >= 16
#        define BOOST_PP_ITERATION_2 16
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 17 && BOOST_PP_ITERATION_FINISH_2 >= 17
#        define BOOST_PP_ITERATION_2 17
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 18 && BOOST_PP_ITERATION_FINISH_2 >= 18
#        define BOOST_PP_ITERATION_2 18
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 19 && BOOST_PP_ITERATION_FINISH_2 >= 19
#        define BOOST_PP_ITERATION_2 19
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 20 && BOOST_PP_ITERATION_FINISH_2 >= 20
#        define BOOST_PP_ITERATION_2 20
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 21 && BOOST_PP_ITERATION_FINISH_2 >= 21
#        define BOOST_PP_ITERATION_2 21
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 22 && BOOST_PP_ITERATION_FINISH_2 >= 22
#        define BOOST_PP_ITERATION_2 22
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 23 && BOOST_PP_ITERATION_FINISH_2 >= 23
#        define BOOST_PP_ITERATION_2 23
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 24 && BOOST_PP_ITERATION_FINISH_2 >= 24
#        define BOOST_PP_ITERATION_2 24
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 25 && BOOST_PP_ITERATION_FINISH_2 >= 25
#        define BOOST_PP_ITERATION_2 25
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 26 && BOOST_PP_ITERATION_FINISH_2 >= 26
#        define BOOST_PP_ITERATION_2 26
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 27 && BOOST_PP_ITERATION_FINISH_2 >= 27
#        define BOOST_PP_ITERATION_2 27
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 28 && BOOST_PP_ITERATION_FINISH_2 >= 28
#        define BOOST_PP_ITERATION_2 28
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 29 && BOOST_PP_ITERATION_FINISH_2 >= 29
#        define BOOST_PP_ITERATION_2 29
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 30 && BOOST_PP_ITERATION_FINISH_2 >= 30
#        define BOOST_PP_ITERATION_2 30
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 31 && BOOST_PP_ITERATION_FINISH_2 >= 31
#        define BOOST_PP_ITERATION_2 31
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 32 && BOOST_PP_ITERATION_FINISH_2 >= 32
#        define BOOST_PP_ITERATION_2 32
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 33 && BOOST_PP_ITERATION_FINISH_2 >= 33
#        define BOOST_PP_ITERATION_2 33
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 34 && BOOST_PP_ITERATION_FINISH_2 >= 34
#        define BOOST_PP_ITERATION_2 34
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 35 && BOOST_PP_ITERATION_FINISH_2 >= 35
#        define BOOST_PP_ITERATION_2 35
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 36 && BOOST_PP_ITERATION_FINISH_2 >= 36
#        define BOOST_PP_ITERATION_2 36
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 37 && BOOST_PP_ITERATION_FINISH_2 >= 37
#        define BOOST_PP_ITERATION_2 37
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 38 && BOOST_PP_ITERATION_FINISH_2 >= 38
#        define BOOST_PP_ITERATION_2 38
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 39 && BOOST_PP_ITERATION_FINISH_2 >= 39
#        define BOOST_PP_ITERATION_2 39
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 40 && BOOST_PP_ITERATION_FINISH_2 >= 40
#        define BOOST_PP_ITERATION_2 40
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 41 && BOOST_PP_ITERATION_FINISH_2 >= 41
#        define BOOST_PP_ITERATION_2 41
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 42 && BOOST_PP_ITERATION_FINISH_2 >= 42
#        define BOOST_PP_ITERATION_2 42
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 43 && BOOST_PP_ITERATION_FINISH_2 >= 43
#        define BOOST_PP_ITERATION_2 43
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 44 && BOOST_PP_ITERATION_FINISH_2 >= 44
#        define BOOST_PP_ITERATION_2 44
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 45 && BOOST_PP_ITERATION_FINISH_2 >= 45
#        define BOOST_PP_ITERATION_2 45
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 46 && BOOST_PP_ITERATION_FINISH_2 >= 46
#        define BOOST_PP_ITERATION_2 46
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 47 && BOOST_PP_ITERATION_FINISH_2 >= 47
#        define BOOST_PP_ITERATION_2 47
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 48 && BOOST_PP_ITERATION_FINISH_2 >= 48
#        define BOOST_PP_ITERATION_2 48
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 49 && BOOST_PP_ITERATION_FINISH_2 >= 49
#        define BOOST_PP_ITERATION_2 49
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 50 && BOOST_PP_ITERATION_FINISH_2 >= 50
#        define BOOST_PP_ITERATION_2 50
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 51 && BOOST_PP_ITERATION_FINISH_2 >= 51
#        define BOOST_PP_ITERATION_2 51
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 52 && BOOST_PP_ITERATION_FINISH_2 >= 52
#        define BOOST_PP_ITERATION_2 52
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 53 && BOOST_PP_ITERATION_FINISH_2 >= 53
#        define BOOST_PP_ITERATION_2 53
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 54 && BOOST_PP_ITERATION_FINISH_2 >= 54
#        define BOOST_PP_ITERATION_2 54
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 55 && BOOST_PP_ITERATION_FINISH_2 >= 55
#        define BOOST_PP_ITERATION_2 55
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 56 && BOOST_PP_ITERATION_FINISH_2 >= 56
#        define BOOST_PP_ITERATION_2 56
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 57 && BOOST_PP_ITERATION_FINISH_2 >= 57
#        define BOOST_PP_ITERATION_2 57
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 58 && BOOST_PP_ITERATION_FINISH_2 >= 58
#        define BOOST_PP_ITERATION_2 58
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 59 && BOOST_PP_ITERATION_FINISH_2 >= 59
#        define BOOST_PP_ITERATION_2 59
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 60 && BOOST_PP_ITERATION_FINISH_2 >= 60
#        define BOOST_PP_ITERATION_2 60
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 61 && BOOST_PP_ITERATION_FINISH_2 >= 61
#        define BOOST_PP_ITERATION_2 61
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 62 && BOOST_PP_ITERATION_FINISH_2 >= 62
#        define BOOST_PP_ITERATION_2 62
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 63 && BOOST_PP_ITERATION_FINISH_2 >= 63
#        define BOOST_PP_ITERATION_2 63
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 64 && BOOST_PP_ITERATION_FINISH_2 >= 64
#        define BOOST_PP_ITERATION_2 64
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 65 && BOOST_PP_ITERATION_FINISH_2 >= 65
#        define BOOST_PP_ITERATION_2 65
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 66 && BOOST_PP_ITERATION_FINISH_2 >= 66
#        define BOOST_PP_ITERATION_2 66
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 67 && BOOST_PP_ITERATION_FINISH_2 >= 67
#        define BOOST_PP_ITERATION_2 67
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 68 && BOOST_PP_ITERATION_FINISH_2 >= 68
#        define BOOST_PP_ITERATION_2 68
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 69 && BOOST_PP_ITERATION_FINISH_2 >= 69
#        define BOOST_PP_ITERATION_2 69
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 70 && BOOST_PP_ITERATION_FINISH_2 >= 70
#        define BOOST_PP_ITERATION_2 70
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 71 && BOOST_PP_ITERATION_FINISH_2 >= 71
#        define BOOST_PP_ITERATION_2 71
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 72 && BOOST_PP_ITERATION_FINISH_2 >= 72
#        define BOOST_PP_ITERATION_2 72
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 73 && BOOST_PP_ITERATION_FINISH_2 >= 73
#        define BOOST_PP_ITERATION_2 73
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 74 && BOOST_PP_ITERATION_FINISH_2 >= 74
#        define BOOST_PP_ITERATION_2 74
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 75 && BOOST_PP_ITERATION_FINISH_2 >= 75
#        define BOOST_PP_ITERATION_2 75
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 76 && BOOST_PP_ITERATION_FINISH_2 >= 76
#        define BOOST_PP_ITERATION_2 76
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 77 && BOOST_PP_ITERATION_FINISH_2 >= 77
#        define BOOST_PP_ITERATION_2 77
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 78 && BOOST_PP_ITERATION_FINISH_2 >= 78
#        define BOOST_PP_ITERATION_2 78
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 79 && BOOST_PP_ITERATION_FINISH_2 >= 79
#        define BOOST_PP_ITERATION_2 79
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 80 && BOOST_PP_ITERATION_FINISH_2 >= 80
#        define BOOST_PP_ITERATION_2 80
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 81 && BOOST_PP_ITERATION_FINISH_2 >= 81
#        define BOOST_PP_ITERATION_2 81
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 82 && BOOST_PP_ITERATION_FINISH_2 >= 82
#        define BOOST_PP_ITERATION_2 82
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 83 && BOOST_PP_ITERATION_FINISH_2 >= 83
#        define BOOST_PP_ITERATION_2 83
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 84 && BOOST_PP_ITERATION_FINISH_2 >= 84
#        define BOOST_PP_ITERATION_2 84
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 85 && BOOST_PP_ITERATION_FINISH_2 >= 85
#        define BOOST_PP_ITERATION_2 85
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 86 && BOOST_PP_ITERATION_FINISH_2 >= 86
#        define BOOST_PP_ITERATION_2 86
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 87 && BOOST_PP_ITERATION_FINISH_2 >= 87
#        define BOOST_PP_ITERATION_2 87
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 88 && BOOST_PP_ITERATION_FINISH_2 >= 88
#        define BOOST_PP_ITERATION_2 88
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 89 && BOOST_PP_ITERATION_FINISH_2 >= 89
#        define BOOST_PP_ITERATION_2 89
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 90 && BOOST_PP_ITERATION_FINISH_2 >= 90
#        define BOOST_PP_ITERATION_2 90
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 91 && BOOST_PP_ITERATION_FINISH_2 >= 91
#        define BOOST_PP_ITERATION_2 91
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 92 && BOOST_PP_ITERATION_FINISH_2 >= 92
#        define BOOST_PP_ITERATION_2 92
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 93 && BOOST_PP_ITERATION_FINISH_2 >= 93
#        define BOOST_PP_ITERATION_2 93
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 94 && BOOST_PP_ITERATION_FINISH_2 >= 94
#        define BOOST_PP_ITERATION_2 94
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 95 && BOOST_PP_ITERATION_FINISH_2 >= 95
#        define BOOST_PP_ITERATION_2 95
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 96 && BOOST_PP_ITERATION_FINISH_2 >= 96
#        define BOOST_PP_ITERATION_2 96
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 97 && BOOST_PP_ITERATION_FINISH_2 >= 97
#        define BOOST_PP_ITERATION_2 97
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 98 && BOOST_PP_ITERATION_FINISH_2 >= 98
#        define BOOST_PP_ITERATION_2 98
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 99 && BOOST_PP_ITERATION_FINISH_2 >= 99
#        define BOOST_PP_ITERATION_2 99
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 100 && BOOST_PP_ITERATION_FINISH_2 >= 100
#        define BOOST_PP_ITERATION_2 100
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 101 && BOOST_PP_ITERATION_FINISH_2 >= 101
#        define BOOST_PP_ITERATION_2 101
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 102 && BOOST_PP_ITERATION_FINISH_2 >= 102
#        define BOOST_PP_ITERATION_2 102
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 103 && BOOST_PP_ITERATION_FINISH_2 >= 103
#        define BOOST_PP_ITERATION_2 103
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 104 && BOOST_PP_ITERATION_FINISH_2 >= 104
#        define BOOST_PP_ITERATION_2 104
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 105 && BOOST_PP_ITERATION_FINISH_2 >= 105
#        define BOOST_PP_ITERATION_2 105
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 106 && BOOST_PP_ITERATION_FINISH_2 >= 106
#        define BOOST_PP_ITERATION_2 106
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 107 && BOOST_PP_ITERATION_FINISH_2 >= 107
#        define BOOST_PP_ITERATION_2 107
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 108 && BOOST_PP_ITERATION_FINISH_2 >= 108
#        define BOOST_PP_ITERATION_2 108
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 109 && BOOST_PP_ITERATION_FINISH_2 >= 109
#        define BOOST_PP_ITERATION_2 109
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 110 && BOOST_PP_ITERATION_FINISH_2 >= 110
#        define BOOST_PP_ITERATION_2 110
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 111 && BOOST_PP_ITERATION_FINISH_2 >= 111
#        define BOOST_PP_ITERATION_2 111
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 112 && BOOST_PP_ITERATION_FINISH_2 >= 112
#        define BOOST_PP_ITERATION_2 112
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 113 && BOOST_PP_ITERATION_FINISH_2 >= 113
#        define BOOST_PP_ITERATION_2 113
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 114 && BOOST_PP_ITERATION_FINISH_2 >= 114
#        define BOOST_PP_ITERATION_2 114
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 115 && BOOST_PP_ITERATION_FINISH_2 >= 115
#        define BOOST_PP_ITERATION_2 115
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 116 && BOOST_PP_ITERATION_FINISH_2 >= 116
#        define BOOST_PP_ITERATION_2 116
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 117 && BOOST_PP_ITERATION_FINISH_2 >= 117
#        define BOOST_PP_ITERATION_2 117
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 118 && BOOST_PP_ITERATION_FINISH_2 >= 118
#        define BOOST_PP_ITERATION_2 118
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 119 && BOOST_PP_ITERATION_FINISH_2 >= 119
#        define BOOST_PP_ITERATION_2 119
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 120 && BOOST_PP_ITERATION_FINISH_2 >= 120
#        define BOOST_PP_ITERATION_2 120
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 121 && BOOST_PP_ITERATION_FINISH_2 >= 121
#        define BOOST_PP_ITERATION_2 121
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 122 && BOOST_PP_ITERATION_FINISH_2 >= 122
#        define BOOST_PP_ITERATION_2 122
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 123 && BOOST_PP_ITERATION_FINISH_2 >= 123
#        define BOOST_PP_ITERATION_2 123
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 124 && BOOST_PP_ITERATION_FINISH_2 >= 124
#        define BOOST_PP_ITERATION_2 124
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 125 && BOOST_PP_ITERATION_FINISH_2 >= 125
#        define BOOST_PP_ITERATION_2 125
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 126 && BOOST_PP_ITERATION_FINISH_2 >= 126
#        define BOOST_PP_ITERATION_2 126
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 127 && BOOST_PP_ITERATION_FINISH_2 >= 127
#        define BOOST_PP_ITERATION_2 127
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 128 && BOOST_PP_ITERATION_FINISH_2 >= 128
#        define BOOST_PP_ITERATION_2 128
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 129 && BOOST_PP_ITERATION_FINISH_2 >= 129
#        define BOOST_PP_ITERATION_2 129
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 130 && BOOST_PP_ITERATION_FINISH_2 >= 130
#        define BOOST_PP_ITERATION_2 130
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 131 && BOOST_PP_ITERATION_FINISH_2 >= 131
#        define BOOST_PP_ITERATION_2 131
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 132 && BOOST_PP_ITERATION_FINISH_2 >= 132
#        define BOOST_PP_ITERATION_2 132
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 133 && BOOST_PP_ITERATION_FINISH_2 >= 133
#        define BOOST_PP_ITERATION_2 133
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 134 && BOOST_PP_ITERATION_FINISH_2 >= 134
#        define BOOST_PP_ITERATION_2 134
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 135 && BOOST_PP_ITERATION_FINISH_2 >= 135
#        define BOOST_PP_ITERATION_2 135
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 136 && BOOST_PP_ITERATION_FINISH_2 >= 136
#        define BOOST_PP_ITERATION_2 136
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 137 && BOOST_PP_ITERATION_FINISH_2 >= 137
#        define BOOST_PP_ITERATION_2 137
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 138 && BOOST_PP_ITERATION_FINISH_2 >= 138
#        define BOOST_PP_ITERATION_2 138
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 139 && BOOST_PP_ITERATION_FINISH_2 >= 139
#        define BOOST_PP_ITERATION_2 139
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 140 && BOOST_PP_ITERATION_FINISH_2 >= 140
#        define BOOST_PP_ITERATION_2 140
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 141 && BOOST_PP_ITERATION_FINISH_2 >= 141
#        define BOOST_PP_ITERATION_2 141
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 142 && BOOST_PP_ITERATION_FINISH_2 >= 142
#        define BOOST_PP_ITERATION_2 142
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 143 && BOOST_PP_ITERATION_FINISH_2 >= 143
#        define BOOST_PP_ITERATION_2 143
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 144 && BOOST_PP_ITERATION_FINISH_2 >= 144
#        define BOOST_PP_ITERATION_2 144
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 145 && BOOST_PP_ITERATION_FINISH_2 >= 145
#        define BOOST_PP_ITERATION_2 145
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 146 && BOOST_PP_ITERATION_FINISH_2 >= 146
#        define BOOST_PP_ITERATION_2 146
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 147 && BOOST_PP_ITERATION_FINISH_2 >= 147
#        define BOOST_PP_ITERATION_2 147
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 148 && BOOST_PP_ITERATION_FINISH_2 >= 148
#        define BOOST_PP_ITERATION_2 148
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 149 && BOOST_PP_ITERATION_FINISH_2 >= 149
#        define BOOST_PP_ITERATION_2 149
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 150 && BOOST_PP_ITERATION_FINISH_2 >= 150
#        define BOOST_PP_ITERATION_2 150
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 151 && BOOST_PP_ITERATION_FINISH_2 >= 151
#        define BOOST_PP_ITERATION_2 151
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 152 && BOOST_PP_ITERATION_FINISH_2 >= 152
#        define BOOST_PP_ITERATION_2 152
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 153 && BOOST_PP_ITERATION_FINISH_2 >= 153
#        define BOOST_PP_ITERATION_2 153
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 154 && BOOST_PP_ITERATION_FINISH_2 >= 154
#        define BOOST_PP_ITERATION_2 154
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 155 && BOOST_PP_ITERATION_FINISH_2 >= 155
#        define BOOST_PP_ITERATION_2 155
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 156 && BOOST_PP_ITERATION_FINISH_2 >= 156
#        define BOOST_PP_ITERATION_2 156
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 157 && BOOST_PP_ITERATION_FINISH_2 >= 157
#        define BOOST_PP_ITERATION_2 157
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 158 && BOOST_PP_ITERATION_FINISH_2 >= 158
#        define BOOST_PP_ITERATION_2 158
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 159 && BOOST_PP_ITERATION_FINISH_2 >= 159
#        define BOOST_PP_ITERATION_2 159
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 160 && BOOST_PP_ITERATION_FINISH_2 >= 160
#        define BOOST_PP_ITERATION_2 160
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 161 && BOOST_PP_ITERATION_FINISH_2 >= 161
#        define BOOST_PP_ITERATION_2 161
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 162 && BOOST_PP_ITERATION_FINISH_2 >= 162
#        define BOOST_PP_ITERATION_2 162
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 163 && BOOST_PP_ITERATION_FINISH_2 >= 163
#        define BOOST_PP_ITERATION_2 163
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 164 && BOOST_PP_ITERATION_FINISH_2 >= 164
#        define BOOST_PP_ITERATION_2 164
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 165 && BOOST_PP_ITERATION_FINISH_2 >= 165
#        define BOOST_PP_ITERATION_2 165
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 166 && BOOST_PP_ITERATION_FINISH_2 >= 166
#        define BOOST_PP_ITERATION_2 166
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 167 && BOOST_PP_ITERATION_FINISH_2 >= 167
#        define BOOST_PP_ITERATION_2 167
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 168 && BOOST_PP_ITERATION_FINISH_2 >= 168
#        define BOOST_PP_ITERATION_2 168
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 169 && BOOST_PP_ITERATION_FINISH_2 >= 169
#        define BOOST_PP_ITERATION_2 169
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 170 && BOOST_PP_ITERATION_FINISH_2 >= 170
#        define BOOST_PP_ITERATION_2 170
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 171 && BOOST_PP_ITERATION_FINISH_2 >= 171
#        define BOOST_PP_ITERATION_2 171
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 172 && BOOST_PP_ITERATION_FINISH_2 >= 172
#        define BOOST_PP_ITERATION_2 172
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 173 && BOOST_PP_ITERATION_FINISH_2 >= 173
#        define BOOST_PP_ITERATION_2 173
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 174 && BOOST_PP_ITERATION_FINISH_2 >= 174
#        define BOOST_PP_ITERATION_2 174
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 175 && BOOST_PP_ITERATION_FINISH_2 >= 175
#        define BOOST_PP_ITERATION_2 175
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 176 && BOOST_PP_ITERATION_FINISH_2 >= 176
#        define BOOST_PP_ITERATION_2 176
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 177 && BOOST_PP_ITERATION_FINISH_2 >= 177
#        define BOOST_PP_ITERATION_2 177
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 178 && BOOST_PP_ITERATION_FINISH_2 >= 178
#        define BOOST_PP_ITERATION_2 178
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 179 && BOOST_PP_ITERATION_FINISH_2 >= 179
#        define BOOST_PP_ITERATION_2 179
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 180 && BOOST_PP_ITERATION_FINISH_2 >= 180
#        define BOOST_PP_ITERATION_2 180
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 181 && BOOST_PP_ITERATION_FINISH_2 >= 181
#        define BOOST_PP_ITERATION_2 181
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 182 && BOOST_PP_ITERATION_FINISH_2 >= 182
#        define BOOST_PP_ITERATION_2 182
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 183 && BOOST_PP_ITERATION_FINISH_2 >= 183
#        define BOOST_PP_ITERATION_2 183
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 184 && BOOST_PP_ITERATION_FINISH_2 >= 184
#        define BOOST_PP_ITERATION_2 184
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 185 && BOOST_PP_ITERATION_FINISH_2 >= 185
#        define BOOST_PP_ITERATION_2 185
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 186 && BOOST_PP_ITERATION_FINISH_2 >= 186
#        define BOOST_PP_ITERATION_2 186
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 187 && BOOST_PP_ITERATION_FINISH_2 >= 187
#        define BOOST_PP_ITERATION_2 187
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 188 && BOOST_PP_ITERATION_FINISH_2 >= 188
#        define BOOST_PP_ITERATION_2 188
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 189 && BOOST_PP_ITERATION_FINISH_2 >= 189
#        define BOOST_PP_ITERATION_2 189
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 190 && BOOST_PP_ITERATION_FINISH_2 >= 190
#        define BOOST_PP_ITERATION_2 190
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 191 && BOOST_PP_ITERATION_FINISH_2 >= 191
#        define BOOST_PP_ITERATION_2 191
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 192 && BOOST_PP_ITERATION_FINISH_2 >= 192
#        define BOOST_PP_ITERATION_2 192
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 193 && BOOST_PP_ITERATION_FINISH_2 >= 193
#        define BOOST_PP_ITERATION_2 193
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 194 && BOOST_PP_ITERATION_FINISH_2 >= 194
#        define BOOST_PP_ITERATION_2 194
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 195 && BOOST_PP_ITERATION_FINISH_2 >= 195
#        define BOOST_PP_ITERATION_2 195
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 196 && BOOST_PP_ITERATION_FINISH_2 >= 196
#        define BOOST_PP_ITERATION_2 196
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 197 && BOOST_PP_ITERATION_FINISH_2 >= 197
#        define BOOST_PP_ITERATION_2 197
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 198 && BOOST_PP_ITERATION_FINISH_2 >= 198
#        define BOOST_PP_ITERATION_2 198
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 199 && BOOST_PP_ITERATION_FINISH_2 >= 199
#        define BOOST_PP_ITERATION_2 199
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 200 && BOOST_PP_ITERATION_FINISH_2 >= 200
#        define BOOST_PP_ITERATION_2 200
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 201 && BOOST_PP_ITERATION_FINISH_2 >= 201
#        define BOOST_PP_ITERATION_2 201
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 202 && BOOST_PP_ITERATION_FINISH_2 >= 202
#        define BOOST_PP_ITERATION_2 202
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 203 && BOOST_PP_ITERATION_FINISH_2 >= 203
#        define BOOST_PP_ITERATION_2 203
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 204 && BOOST_PP_ITERATION_FINISH_2 >= 204
#        define BOOST_PP_ITERATION_2 204
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 205 && BOOST_PP_ITERATION_FINISH_2 >= 205
#        define BOOST_PP_ITERATION_2 205
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 206 && BOOST_PP_ITERATION_FINISH_2 >= 206
#        define BOOST_PP_ITERATION_2 206
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 207 && BOOST_PP_ITERATION_FINISH_2 >= 207
#        define BOOST_PP_ITERATION_2 207
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 208 && BOOST_PP_ITERATION_FINISH_2 >= 208
#        define BOOST_PP_ITERATION_2 208
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 209 && BOOST_PP_ITERATION_FINISH_2 >= 209
#        define BOOST_PP_ITERATION_2 209
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 210 && BOOST_PP_ITERATION_FINISH_2 >= 210
#        define BOOST_PP_ITERATION_2 210
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 211 && BOOST_PP_ITERATION_FINISH_2 >= 211
#        define BOOST_PP_ITERATION_2 211
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 212 && BOOST_PP_ITERATION_FINISH_2 >= 212
#        define BOOST_PP_ITERATION_2 212
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 213 && BOOST_PP_ITERATION_FINISH_2 >= 213
#        define BOOST_PP_ITERATION_2 213
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 214 && BOOST_PP_ITERATION_FINISH_2 >= 214
#        define BOOST_PP_ITERATION_2 214
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 215 && BOOST_PP_ITERATION_FINISH_2 >= 215
#        define BOOST_PP_ITERATION_2 215
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 216 && BOOST_PP_ITERATION_FINISH_2 >= 216
#        define BOOST_PP_ITERATION_2 216
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 217 && BOOST_PP_ITERATION_FINISH_2 >= 217
#        define BOOST_PP_ITERATION_2 217
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 218 && BOOST_PP_ITERATION_FINISH_2 >= 218
#        define BOOST_PP_ITERATION_2 218
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 219 && BOOST_PP_ITERATION_FINISH_2 >= 219
#        define BOOST_PP_ITERATION_2 219
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 220 && BOOST_PP_ITERATION_FINISH_2 >= 220
#        define BOOST_PP_ITERATION_2 220
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 221 && BOOST_PP_ITERATION_FINISH_2 >= 221
#        define BOOST_PP_ITERATION_2 221
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 222 && BOOST_PP_ITERATION_FINISH_2 >= 222
#        define BOOST_PP_ITERATION_2 222
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 223 && BOOST_PP_ITERATION_FINISH_2 >= 223
#        define BOOST_PP_ITERATION_2 223
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 224 && BOOST_PP_ITERATION_FINISH_2 >= 224
#        define BOOST_PP_ITERATION_2 224
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 225 && BOOST_PP_ITERATION_FINISH_2 >= 225
#        define BOOST_PP_ITERATION_2 225
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 226 && BOOST_PP_ITERATION_FINISH_2 >= 226
#        define BOOST_PP_ITERATION_2 226
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 227 && BOOST_PP_ITERATION_FINISH_2 >= 227
#        define BOOST_PP_ITERATION_2 227
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 228 && BOOST_PP_ITERATION_FINISH_2 >= 228
#        define BOOST_PP_ITERATION_2 228
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 229 && BOOST_PP_ITERATION_FINISH_2 >= 229
#        define BOOST_PP_ITERATION_2 229
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 230 && BOOST_PP_ITERATION_FINISH_2 >= 230
#        define BOOST_PP_ITERATION_2 230
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 231 && BOOST_PP_ITERATION_FINISH_2 >= 231
#        define BOOST_PP_ITERATION_2 231
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 232 && BOOST_PP_ITERATION_FINISH_2 >= 232
#        define BOOST_PP_ITERATION_2 232
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 233 && BOOST_PP_ITERATION_FINISH_2 >= 233
#        define BOOST_PP_ITERATION_2 233
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 234 && BOOST_PP_ITERATION_FINISH_2 >= 234
#        define BOOST_PP_ITERATION_2 234
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 235 && BOOST_PP_ITERATION_FINISH_2 >= 235
#        define BOOST_PP_ITERATION_2 235
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 236 && BOOST_PP_ITERATION_FINISH_2 >= 236
#        define BOOST_PP_ITERATION_2 236
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 237 && BOOST_PP_ITERATION_FINISH_2 >= 237
#        define BOOST_PP_ITERATION_2 237
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 238 && BOOST_PP_ITERATION_FINISH_2 >= 238
#        define BOOST_PP_ITERATION_2 238
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 239 && BOOST_PP_ITERATION_FINISH_2 >= 239
#        define BOOST_PP_ITERATION_2 239
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 240 && BOOST_PP_ITERATION_FINISH_2 >= 240
#        define BOOST_PP_ITERATION_2 240
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 241 && BOOST_PP_ITERATION_FINISH_2 >= 241
#        define BOOST_PP_ITERATION_2 241
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 242 && BOOST_PP_ITERATION_FINISH_2 >= 242
#        define BOOST_PP_ITERATION_2 242
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 243 && BOOST_PP_ITERATION_FINISH_2 >= 243
#        define BOOST_PP_ITERATION_2 243
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 244 && BOOST_PP_ITERATION_FINISH_2 >= 244
#        define BOOST_PP_ITERATION_2 244
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 245 && BOOST_PP_ITERATION_FINISH_2 >= 245
#        define BOOST_PP_ITERATION_2 245
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 246 && BOOST_PP_ITERATION_FINISH_2 >= 246
#        define BOOST_PP_ITERATION_2 246
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 247 && BOOST_PP_ITERATION_FINISH_2 >= 247
#        define BOOST_PP_ITERATION_2 247
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 248 && BOOST_PP_ITERATION_FINISH_2 >= 248
#        define BOOST_PP_ITERATION_2 248
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 249 && BOOST_PP_ITERATION_FINISH_2 >= 249
#        define BOOST_PP_ITERATION_2 249
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 250 && BOOST_PP_ITERATION_FINISH_2 >= 250
#        define BOOST_PP_ITERATION_2 250
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 251 && BOOST_PP_ITERATION_FINISH_2 >= 251
#        define BOOST_PP_ITERATION_2 251
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 252 && BOOST_PP_ITERATION_FINISH_2 >= 252
#        define BOOST_PP_ITERATION_2 252
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 253 && BOOST_PP_ITERATION_FINISH_2 >= 253
#        define BOOST_PP_ITERATION_2 253
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 254 && BOOST_PP_ITERATION_FINISH_2 >= 254
#        define BOOST_PP_ITERATION_2 254
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 255 && BOOST_PP_ITERATION_FINISH_2 >= 255
#        define BOOST_PP_ITERATION_2 255
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
#    if BOOST_PP_ITERATION_START_2 <= 256 && BOOST_PP_ITERATION_FINISH_2 >= 256
#        define BOOST_PP_ITERATION_2 256
#        include BOOST_PP_FILENAME_2
#        undef BOOST_PP_ITERATION_2
#    endif
# endif
#
# undef BOOST_PP_ITERATION_DEPTH
# define BOOST_PP_ITERATION_DEPTH() 1
#
# undef BOOST_PP_ITERATION_START_2
# undef BOOST_PP_ITERATION_FINISH_2
# undef BOOST_PP_FILENAME_2
#
# undef BOOST_PP_ITERATION_FLAGS_2
# undef BOOST_PP_ITERATION_PARAMS_2


code:
//---------------------------------------------------------------------------//
// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com>
//
// Distributed under the Boost Software License, Version 1.0
// See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt
//
// See http://boostorg.github.com/compute for more information.
//---------------------------------------------------------------------------//

#ifndef BOOST_COMPUTE_DETAIL_GLOBAL_STATIC_HPP
#define BOOST_COMPUTE_DETAIL_GLOBAL_STATIC_HPP

#include <boost/compute/config.hpp>

#ifdef BOOST_COMPUTE_THREAD_SAFE
#  ifdef BOOST_COMPUTE_HAVE_THREAD_LOCAL
     // use c++11 thread local storage
#    define BOOST_COMPUTE_DETAIL_GLOBAL_STATIC(type, name, ctor) \
       thread_local type name ctor;
#  else
      // use thread_specific_ptr from boost.thread
#     include <boost/thread/tss.hpp>
#     define BOOST_COMPUTE_DETAIL_GLOBAL_STATIC(type, name, ctor) \
        static ::boost::thread_specific_ptr< type > BOOST_PP_CAT(name, _tls_ptr_); \
        if(!BOOST_PP_CAT(name, _tls_ptr_).get()){ \
            BOOST_PP_CAT(name, _tls_ptr_).reset(new type ctor); \
        } \
        static type &name = *BOOST_PP_CAT(name, _tls_ptr_);
#  endif
#else
   // no thread-safety, just use static
#  define BOOST_COMPUTE_DETAIL_GLOBAL_STATIC(type, name, ctor) \
     static type name ctor;
#endif

#endif // BOOST_COMPUTE_DETAIL_GLOBAL_STATIC_HPP

license: mit


code:
//  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000-2005.
//  Use, modification and distribution are subject to the Boost Software License,
//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt).
//
//  See http://www.boost.org/libs/type_traits for most recent version including documentation.

#ifndef BOOST_TYPE_TRAITS_IS_FLOATING_HPP_INCLUDED
#define BOOST_TYPE_TRAITS_IS_FLOATING_HPP_INCLUDED

#include <boost/type_traits/integral_constant.hpp>

namespace boost {

//* is a type T a floating-point type described in the standard (3.9.1p8)
   template <class T> struct is_floating_point : public false_type{};
   template <class T> struct is_floating_point<const T> : public is_floating_point<T>{};
   template <class T> struct is_floating_point<volatile const T> : public is_floating_point<T>{};
   template <class T> struct is_floating_point<volatile T> : public is_floating_point<T>{};
   template<> struct is_floating_point<float> : public true_type{};
   template<> struct is_floating_point<double> : public true_type{};
   template<> struct is_floating_point<long double> : public true_type{};

#if defined(BOOST_HAS_FLOAT128)
   template<> struct is_floating_point<__float128> : public true_type{};
#endif

} // namespace boost

#endif // BOOST_TYPE_TRAITS_IS_FLOAT_HPP_INCLUDED


code:
// Copyright (C) 2005-2006 The Trustees of Indiana University.

// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)

//  Authors: Jeremiah Willcock
//           Douglas Gregor
//           Andrew Lumsdaine

// Two bit per color property map

#ifndef BOOST_TWO_BIT_COLOR_MAP_HPP
#define BOOST_TWO_BIT_COLOR_MAP_HPP

#include <boost/property_map/property_map.hpp>
#include <boost/graph/properties.hpp>
#include <boost/shared_array.hpp>
#include <boost/config.hpp>
#include <boost/assert.hpp>
#include <algorithm>
#include <limits>

namespace boost {

enum two_bit_color_type {
  two_bit_white = 0,
  two_bit_gray  = 1,
  two_bit_green = 2,
  two_bit_black = 3
};

template <>
struct color_traits<two_bit_color_type>
{
  static two_bit_color_type white() { return two_bit_white; }
  static two_bit_color_type gray()  { return two_bit_gray; }
  static two_bit_color_type green() { return two_bit_green; }
  static two_bit_color_type black() { return two_bit_black; }
};

template<typename IndexMap = identity_property_map>
struct two_bit_color_map
{
  std::size_t n;
  IndexMap index;
  shared_array<unsigned char> data;

  BOOST_STATIC_CONSTANT(int, bits_per_char = std::numeric_limits<unsigned char>::digits);
  BOOST_STATIC_CONSTANT(int, elements_per_char = bits_per_char / 2);
  typedef typename property_traits<IndexMap>::key_type key_type;
  typedef two_bit_color_type value_type;
  typedef void reference;
  typedef read_write_property_map_tag category;

  explicit two_bit_color_map(std::size_t n, const IndexMap& index = IndexMap())
    : n(n), index(index), data(new unsigned char[(n + elements_per_char - 1) / elements_per_char])
  {
    // Fill to white
    std::fill(data.get(), data.get() + (n + elements_per_char - 1) / elements_per_char, 0);
  }
};

template<typename IndexMap>
inline two_bit_color_type
get(const two_bit_color_map<IndexMap>& pm,
    typename property_traits<IndexMap>::key_type key)
{
  BOOST_STATIC_CONSTANT(int, elements_per_char = two_bit_color_map<IndexMap>::elements_per_char);
  typename property_traits<IndexMap>::value_type i = get(pm.index, key);
  BOOST_ASSERT ((std::size_t)i < pm.n);
  std::size_t byte_num = i / elements_per_char;
  std::size_t bit_position = ((i % elements_per_char) * 2);
  return two_bit_color_type((pm.data.get()[byte_num] >> bit_position) & 3);
}

template<typename IndexMap>
inline void
put(const two_bit_color_map<IndexMap>& pm,
    typename property_traits<IndexMap>::key_type key,
    two_bit_color_type value)
{
  BOOST_STATIC_CONSTANT(int, elements_per_char = two_bit_color_map<IndexMap>::elements_per_char);
  typename property_traits<IndexMap>::value_type i = get(pm.index, key);
  BOOST_ASSERT ((std::size_t)i < pm.n);
  BOOST_ASSERT (value >= 0 && value < 4);
  std::size_t byte_num = i / elements_per_char;
  std::size_t bit_position = ((i % elements_per_char) * 2);
    pm.data.get()[byte_num] =
      (unsigned char)
        ((pm.data.get()[byte_num] & ~(3 << bit_position))
         | (value << bit_position));
}

template<typename IndexMap>
inline two_bit_color_map<IndexMap>
make_two_bit_color_map(std::size_t n, const IndexMap& index_map)
{
  return two_bit_color_map<IndexMap>(n, index_map);
}

} // end namespace boost

#endif // BOOST_TWO_BIT_COLOR_MAP_HPP

#ifdef BOOST_GRAPH_USE_MPI
#  include <boost/graph/distributed/two_bit_color_map.hpp>
#endif


code:
#ifndef BOOST_MPL_PAIR_HPP_INCLUDED
#define BOOST_MPL_PAIR_HPP_INCLUDED

// Copyright Aleksey Gurtovoy 2001-2004
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// See http://www.boost.org/libs/mpl for documentation.

// $Id$
// $Date$
// $Revision$

#include <boost/mpl/aux_/msvc_eti_base.hpp>
#include <boost/mpl/aux_/na_spec.hpp>
#include <boost/mpl/aux_/lambda_support.hpp>
#include <boost/mpl/aux_/config/eti.hpp>

namespace boost { namespace mpl {

template<
      typename BOOST_MPL_AUX_NA_PARAM(T1)
    , typename BOOST_MPL_AUX_NA_PARAM(T2)
    >
struct pair
{
    typedef pair type;
    typedef T1 first;
    typedef T2 second;

    BOOST_MPL_AUX_LAMBDA_SUPPORT(2,pair,(T1,T2))
};

template<
      typename BOOST_MPL_AUX_NA_PARAM(P)
    >
struct first
{
#if !defined(BOOST_MPL_CFG_MSVC_70_ETI_BUG)
    typedef typename P::first type;
#else
    typedef typename aux::msvc_eti_base<P>::first type;
#endif
    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,first,(P))
};

template<
      typename BOOST_MPL_AUX_NA_PARAM(P)
    >
struct second
{
#if !defined(BOOST_MPL_CFG_MSVC_70_ETI_BUG)
    typedef typename P::second type;
#else
    typedef typename aux::msvc_eti_base<P>::second type;
#endif
    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,second,(P))
};

BOOST_MPL_AUX_NA_SPEC_NO_ETI(2, pair)
BOOST_MPL_AUX_NA_SPEC(1, first)
BOOST_MPL_AUX_NA_SPEC(1, second)

}}

#endif // BOOST_MPL_PAIR_HPP_INCLUDED


code:
// Copyright David Abrahams 2002.
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef WORKAROUND_DWA2002126_HPP
# define WORKAROUND_DWA2002126_HPP

// Compiler/library version workaround macro
//
// Usage:
//
//     #if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
//        // workaround for eVC4 and VC6
//        ... // workaround code here
//     #endif
//
// When BOOST_STRICT_CONFIG is defined, expands to 0. Otherwise, the
// first argument must be undefined or expand to a numeric
// value. The above expands to:
//
//     (BOOST_MSVC) != 0 && (BOOST_MSVC) < 1300
//
// When used for workarounds that apply to the latest known version
// and all earlier versions of a compiler, the following convention
// should be observed:
//
//     #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1301))
//
// The version number in this case corresponds to the last version in
// which the workaround was known to have been required. When
// BOOST_DETECT_OUTDATED_WORKAROUNDS is not the defined, the macro
// BOOST_TESTED_AT(x) expands to "!= 0", which effectively activates
// the workaround for any version of the compiler. When
// BOOST_DETECT_OUTDATED_WORKAROUNDS is defined, a compiler warning or
// error will be issued if the compiler version exceeds the argument
// to BOOST_TESTED_AT().  This can be used to locate workarounds which
// may be obsoleted by newer versions.

# ifndef BOOST_STRICT_CONFIG

#include <boost/config.hpp>

#ifndef __BORLANDC__
#define __BORLANDC___WORKAROUND_GUARD 1
#else
#define __BORLANDC___WORKAROUND_GUARD 0
#endif
#ifndef __CODEGEARC__
#define __CODEGEARC___WORKAROUND_GUARD 1
#else
#define __CODEGEARC___WORKAROUND_GUARD 0
#endif
#ifndef _MSC_VER
#define _MSC_VER_WORKAROUND_GUARD 1
#else
#define _MSC_VER_WORKAROUND_GUARD 0
#endif
#ifndef _MSC_FULL_VER
#define _MSC_FULL_VER_WORKAROUND_GUARD 1
#else
#define _MSC_FULL_VER_WORKAROUND_GUARD 0
#endif
#ifndef BOOST_MSVC
#define BOOST_MSVC_WORKAROUND_GUARD 1
#else
#define BOOST_MSVC_WORKAROUND_GUARD 0
#endif
#ifndef BOOST_MSVC_FULL_VER
#define BOOST_MSVC_FULL_VER_WORKAROUND_GUARD 1
#else
#define BOOST_MSVC_FULL_VER_WORKAROUND_GUARD 0
#endif
#ifndef __GNUC__
#define __GNUC___WORKAROUND_GUARD 1
#else
#define __GNUC___WORKAROUND_GUARD 0
#endif
#ifndef __GNUC_MINOR__
#define __GNUC_MINOR___WORKAROUND_GUARD 1
#else
#define __GNUC_MINOR___WORKAROUND_GUARD 0
#endif
#ifndef __GNUC_PATCHLEVEL__
#define __GNUC_PATCHLEVEL___WORKAROUND_GUARD 1
#else
#define __GNUC_PATCHLEVEL___WORKAROUND_GUARD 0
#endif
#ifndef __IBMCPP__
#define __IBMCPP___WORKAROUND_GUARD 1
#else
#define __IBMCPP___WORKAROUND_GUARD 0
#endif
#ifndef __SUNPRO_CC
#define __SUNPRO_CC_WORKAROUND_GUARD 1
#else
#define __SUNPRO_CC_WORKAROUND_GUARD 0
#endif
#ifndef __DECCXX_VER
#define __DECCXX_VER_WORKAROUND_GUARD 1
#else
#define __DECCXX_VER_WORKAROUND_GUARD 0
#endif
#ifndef __MWERKS__
#define __MWERKS___WORKAROUND_GUARD 1
#else
#define __MWERKS___WORKAROUND_GUARD 0
#endif
#ifndef __EDG__
#define __EDG___WORKAROUND_GUARD 1
#else
#define __EDG___WORKAROUND_GUARD 0
#endif
#ifndef __EDG_VERSION__
#define __EDG_VERSION___WORKAROUND_GUARD 1
#else
#define __EDG_VERSION___WORKAROUND_GUARD 0
#endif
#ifndef __HP_aCC
#define __HP_aCC_WORKAROUND_GUARD 1
#else
#define __HP_aCC_WORKAROUND_GUARD 0
#endif
#ifndef __hpxstd98
#define __hpxstd98_WORKAROUND_GUARD 1
#else
#define __hpxstd98_WORKAROUND_GUARD 0
#endif
#ifndef _CRAYC
#define _CRAYC_WORKAROUND_GUARD 1
#else
#define _CRAYC_WORKAROUND_GUARD 0
#endif
#ifndef __DMC__
#define __DMC___WORKAROUND_GUARD 1
#else
#define __DMC___WORKAROUND_GUARD 0
#endif
#ifndef MPW_CPLUS
#define MPW_CPLUS_WORKAROUND_GUARD 1
#else
#define MPW_CPLUS_WORKAROUND_GUARD 0
#endif
#ifndef __COMO__
#define __COMO___WORKAROUND_GUARD 1
#else
#define __COMO___WORKAROUND_GUARD 0
#endif
#ifndef __COMO_VERSION__
#define __COMO_VERSION___WORKAROUND_GUARD 1
#else
#define __COMO_VERSION___WORKAROUND_GUARD 0
#endif
#ifndef __INTEL_COMPILER
#define __INTEL_COMPILER_WORKAROUND_GUARD 1
#else
#define __INTEL_COMPILER_WORKAROUND_GUARD 0
#endif
#ifndef __ICL
#define __ICL_WORKAROUND_GUARD 1
#else
#define __ICL_WORKAROUND_GUARD 0
#endif
#ifndef _COMPILER_VERSION
#define _COMPILER_VERSION_WORKAROUND_GUARD 1
#else
#define _COMPILER_VERSION_WORKAROUND_GUARD 0
#endif

#ifndef _RWSTD_VER
#define _RWSTD_VER_WORKAROUND_GUARD 1
#else
#define _RWSTD_VER_WORKAROUND_GUARD 0
#endif
#ifndef BOOST_RWSTD_VER
#define BOOST_RWSTD_VER_WORKAROUND_GUARD 1
#else
#define BOOST_RWSTD_VER_WORKAROUND_GUARD 0
#endif
#ifndef __GLIBCPP__
#define __GLIBCPP___WORKAROUND_GUARD 1
#else
#define __GLIBCPP___WORKAROUND_GUARD 0
#endif
#ifndef _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
#define _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC_WORKAROUND_GUARD 1
#else
#define _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC_WORKAROUND_GUARD 0
#endif
#ifndef __SGI_STL_PORT
#define __SGI_STL_PORT_WORKAROUND_GUARD 1
#else
#define __SGI_STL_PORT_WORKAROUND_GUARD 0
#endif
#ifndef _STLPORT_VERSION
#define _STLPORT_VERSION_WORKAROUND_GUARD 1
#else
#define _STLPORT_VERSION_WORKAROUND_GUARD 0
#endif
#ifndef __LIBCOMO_VERSION__
#define __LIBCOMO_VERSION___WORKAROUND_GUARD 1
#else
#define __LIBCOMO_VERSION___WORKAROUND_GUARD 0
#endif
#ifndef _CPPLIB_VER
#define _CPPLIB_VER_WORKAROUND_GUARD 1
#else
#define _CPPLIB_VER_WORKAROUND_GUARD 0
#endif

#ifndef BOOST_INTEL_CXX_VERSION
#define BOOST_INTEL_CXX_VERSION_WORKAROUND_GUARD 1
#else
#define BOOST_INTEL_CXX_VERSION_WORKAROUND_GUARD 0
#endif
#ifndef BOOST_INTEL_WIN
#define BOOST_INTEL_WIN_WORKAROUND_GUARD 1
#else
#define BOOST_INTEL_WIN_WORKAROUND_GUARD 0
#endif
#ifndef BOOST_DINKUMWARE_STDLIB
#define BOOST_DINKUMWARE_STDLIB_WORKAROUND_GUARD 1
#else
#define BOOST_DINKUMWARE_STDLIB_WORKAROUND_GUARD 0
#endif
#ifndef BOOST_INTEL
#define BOOST_INTEL_WORKAROUND_GUARD 1
#else
#define BOOST_INTEL_WORKAROUND_GUARD 0
#endif
// Always define to zero, if it's used it'll be defined my MPL:
#define BOOST_MPL_CFG_GCC_WORKAROUND_GUARD 0

#  define BOOST_WORKAROUND(symbol, test)                \
         ((symbol ## _WORKAROUND_GUARD + 0 == 0) &&     \
         (symbol != 0) && (1 % (( (symbol test) ) + 1)))
//                              ^ ^           ^ ^
// The extra level of parenthesis nesting above, along with the
// BOOST_OPEN_PAREN indirection below, is required to satisfy the
// broken preprocessor in MWCW 8.3 and earlier.
//
// The basic mechanism works as follows:
//      (symbol test) + 1        =>   if (symbol test) then 2 else 1
//      1 % ((symbol test) + 1)  =>   if (symbol test) then 1 else 0
//
// The complication with % is for cooperation with BOOST_TESTED_AT().
// When "test" is BOOST_TESTED_AT(x) and
// BOOST_DETECT_OUTDATED_WORKAROUNDS is #defined,
//
//      symbol test              =>   if (symbol <= x) then 1 else -1
//      (symbol test) + 1        =>   if (symbol <= x) then 2 else 0
//      1 % ((symbol test) + 1)  =>   if (symbol <= x) then 1 else divide-by-zero
//

#  ifdef BOOST_DETECT_OUTDATED_WORKAROUNDS
#   define BOOST_OPEN_PAREN (
#   define BOOST_TESTED_AT(value)  > value) ?(-1): BOOST_OPEN_PAREN 1
#  else
#   define BOOST_TESTED_AT(value) != ((value)-(value))
#  endif

# else

#  define BOOST_WORKAROUND(symbol, test) 0

# endif

#endif // WORKAROUND_DWA2002126_HPP


code:
#ifndef BOOST_MPL_LAMBDA_FWD_HPP_INCLUDED
#define BOOST_MPL_LAMBDA_FWD_HPP_INCLUDED

// Copyright Aleksey Gurtovoy 2001-2004
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// See http://www.boost.org/libs/mpl for documentation.

// $Id$
// $Date$
// $Revision$

#include <boost/mpl/void_fwd.hpp>
#include <boost/mpl/aux_/na.hpp>
#include <boost/mpl/aux_/config/lambda.hpp>

#if !defined(BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT)

#   include <boost/mpl/int.hpp>
#   include <boost/mpl/aux_/lambda_arity_param.hpp>
#   include <boost/mpl/aux_/template_arity_fwd.hpp>

namespace boost { namespace mpl {

template<
      typename T = na
    , typename Tag = void_
    BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(
          typename Arity = int_< aux::template_arity<T>::value >
        )
    >
struct lambda;

}}

#else // BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT

#   include <boost/mpl/bool.hpp>

namespace boost { namespace mpl {

template<
      typename T = na
    , typename Tag = void_
    , typename Protect = true_
    >
struct lambda;

}}

#endif

#endif // BOOST_MPL_LAMBDA_FWD_HPP_INCLUDED


code:
// Boost.Range library
//
//  Copyright Thorsten Ottosen 2003-2004. Use, modification and
//  distribution is subject to the Boost Software License, Version
//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)
//
// For more information, see http://www.boost.org/libs/range/
//

#ifndef BOOST_RANGE_SIZE_TYPE_HPP
#define BOOST_RANGE_SIZE_TYPE_HPP

#if defined(_MSC_VER)
# pragma once
#endif

#include <boost/range/config.hpp>
#include <boost/range/difference_type.hpp>
#include <boost/range/concepts.hpp>
#include <boost/range/has_range_iterator.hpp>

#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/make_unsigned.hpp>
#include <boost/type_traits/remove_const.hpp>
#include <cstddef>
#include <utility>

namespace boost
{
    namespace detail
    {

        //////////////////////////////////////////////////////////////////////////
        // default
        //////////////////////////////////////////////////////////////////////////

        template<typename T>
        class has_size_type
        {
            typedef char no_type;
            struct yes_type { char dummy[2]; };

            template<typename C>
            static yes_type test(BOOST_DEDUCED_TYPENAME C::size_type x);

            template<typename C>
            static no_type test(...);

        public:
            static const bool value = sizeof(test<T>(0)) == sizeof(yes_type);
        };

        template<typename C, typename Enabler=void>
        struct range_size_
        {
            typedef BOOST_DEDUCED_TYPENAME make_unsigned<
                BOOST_DEDUCED_TYPENAME range_difference<C>::type
            >::type type;
        };

        template<typename C>
        struct range_size_<
            C,
            BOOST_DEDUCED_TYPENAME ::boost::enable_if<has_size_type<C>, void>::type
        >
        {
            typedef BOOST_DEDUCED_TYPENAME C::size_type type;
        };

        template<typename C, bool B = range_detail::has_type< range_iterator<C> >::value>
        struct range_size
        { };

        template<typename C>
        struct range_size<C, true>
          : range_size_<C>
        { };
    }

    template< class T >
    struct range_size :
        detail::range_size<T>
    { };

} // namespace boost

#endif


code:
/*==============================================================================
    Copyright (c) 2011 Hartmut Kaiser

    Distributed under the Boost Software License, Version 1.0. (See accompanying
    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/

#if !defined(BOOST_PHOENIX_PREPROCESSED_CATCH_PUSH_BACK)
#define BOOST_PHOENIX_PREPROCESSED_CATCH_PUSH_BACK

#if BOOST_PHOENIX_LIMIT <= 10
#include <boost/phoenix/statement/detail/preprocessed/catch_push_back_10.hpp>
#elif BOOST_PHOENIX_LIMIT <= 20
#include <boost/phoenix/statement/detail/preprocessed/catch_push_back_20.hpp>
#elif BOOST_PHOENIX_LIMIT <= 30
#include <boost/phoenix/statement/detail/preprocessed/catch_push_back_30.hpp>
#elif BOOST_PHOENIX_LIMIT <= 40
#include <boost/phoenix/statement/detail/preprocessed/catch_push_back_40.hpp>
#elif BOOST_PHOENIX_LIMIT <= 50
#include <boost/phoenix/statement/detail/preprocessed/catch_push_back_50.hpp>
#else
#error "BOOST_PHOENIX_LIMIT out of bounds for preprocessed headers"
#endif

#endif


code:
/////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gaztanaga  2014-2015
//
// Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE_1_0.txt or copy at
//          http://www.boost.org/LICENSE_1_0.txt)
//
// See http://www.boost.org/libs/intrusive for documentation.
//
/////////////////////////////////////////////////////////////////////////////
#ifndef BOOST_INTRUSIVE_DETAIL_MINIMAL_PAIR_HEADER_HPP
#define BOOST_INTRUSIVE_DETAIL_MINIMAL_PAIR_HEADER_HPP
#
#if defined(BOOST_HAS_PRAGMA_ONCE)
#  pragma once
#endif
#
#ifndef BOOST_CONFIG_HPP
#  include <boost/config.hpp>
#endif
#
#//Try to avoid including <utility>, as it's quite big in C++11
#if defined(BOOST_GNU_STDLIB)
#  include <bits/stl_pair.h>
#else
#  include <utility>    //Fallback
#endif
#
#endif //BOOST_INTRUSIVE_DETAIL_MINIMAL_PAIR_HEADER_HPP


code:
!
! readwav - open and read the header of a WAV format file
!
! On successful exit the file is left positioned at the start of the
! data.
!
! Example of usage:
!
!  use readwav
!  integer*2 sample
!  type(wav_header) wav
!  call wav%read ('file.wav')
!  write (*,*) 'Sample rate is: ', wav%audio_format%sample_rate
!  do i=0,wav%data_size
!    read (unit=wav%lun) sample
!    ! process sample
!  end do
!
module readwav
  implicit none

  type format_chunk
     integer*2 audio_format
     integer*2 num_channels
     integer sample_rate
     integer byte_rate
     integer*2 block_align
     integer*2 bits_per_sample
  end type format_chunk

  type, public :: wav_header
     integer :: lun
     type(format_chunk) :: audio_format
     integer :: data_size
   contains
     procedure :: read
  end type wav_header

  private
contains
  subroutine read (this, filename)
    implicit none

    type riff_descriptor
       character(len=4) :: id
       integer :: size
    end type riff_descriptor

    class(wav_header), intent(inout) :: this
    character(len=*), intent(in) :: filename

    integer :: filepos
    type(riff_descriptor) :: desc
    character(len=4) :: riff_type

    open (newunit=this%lun, file=filename, access='stream', form='unformatted', status='old')
    read (unit=this%lun) desc,riff_type
    inquire (unit=this%lun, pos=filepos)
    do
       read (unit=this%lun, pos=filepos) desc
       inquire (unit=this%lun, pos=filepos)
       if (desc%id .eq. 'fmt ') then
          read (unit=this%lun) this%audio_format
       else if (desc%id .eq. 'data') then
          this%data_size = desc%size
          exit
       end if
       filepos = filepos + (desc%size + 1) / 2 * 2 ! pad to even alignment
    end do
  end subroutine read
end module readwav


code:
/*
 [auto_generated]
 boost/numeric/odeint/integrate/detail/integrate_const.hpp

 [begin_description]
 integrate const implementation
 [end_description]

 Copyright 2009-2012 Karsten Ahnert
 Copyright 2009-2012 Mario Mulansky

 Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE_1_0.txt or
 copy at http://www.boost.org/LICENSE_1_0.txt)
 */

#ifndef BOOST_NUMERIC_ODEINT_INTEGRATE_DETAIL_INTEGRATE_CONST_HPP_INCLUDED
#define BOOST_NUMERIC_ODEINT_INTEGRATE_DETAIL_INTEGRATE_CONST_HPP_INCLUDED

#include <boost/range/algorithm/for_each.hpp>

#include <boost/numeric/odeint/util/unwrap_reference.hpp>
#include <boost/numeric/odeint/stepper/stepper_categories.hpp>
#include <boost/numeric/odeint/util/unit_helper.hpp>
#include <boost/numeric/odeint/iterator/const_step_time_iterator.hpp>
#include <boost/numeric/odeint/iterator/integrate/detail/integrate_adaptive.hpp>
#include <boost/numeric/odeint/iterator/integrate/detail/functors.hpp>
#include <boost/numeric/odeint/util/detail/less_with_sign.hpp>

namespace boost {
namespace numeric {
namespace odeint {
namespace detail {

// forward declaration
template< class Stepper , class System , class State , class Time , class Observer >
size_t integrate_adaptive(
        Stepper stepper , System system , State &start_state ,
        Time &start_time , Time end_time , Time &dt ,
        Observer observer , controlled_stepper_tag
);

template< class Stepper , class System , class State , class Time , class Observer >
size_t integrate_const(
        Stepper stepper , System system , State &start_state ,
        Time start_time , Time end_time , Time dt ,
        Observer observer , stepper_tag
)
{
    size_t obs_calls = 0;

    boost::for_each( make_const_step_time_range( stepper , system , start_state ,
                                                 start_time , end_time , dt ) ,
                     // should we use traits<Stepper>::state_type here instead of State? NO!
                     obs_caller< Observer >( obs_calls , observer ) );

    // step integration steps gives step+1 observer calls
    return obs_calls-1;
}

template< class Stepper , class System , class State , class Time , class Observer >
size_t integrate_const(
        Stepper stepper , System system , State &start_state ,
        Time start_time , Time end_time , Time dt ,
        Observer observer , controlled_stepper_tag
)
{
    typename odeint::unwrap_reference< Observer >::type &obs = observer;

    Time time = start_time;
    const Time time_step = dt;
    int step = 0;

    while( less_eq_with_sign( static_cast<Time>(time+time_step) , end_time , dt ) )
    {
        obs( start_state , time );
        detail::integrate_adaptive( stepper , system , start_state , time , time+time_step , dt ,
                                    null_observer() , controlled_stepper_tag() );
        // direct computation of the time avoids error propagation happening when using time += dt
        // we need clumsy type analysis to get boost units working here
        ++step;
        time = start_time + static_cast< typename unit_value_type<Time>::type >(step) * time_step;
    }
    obs( start_state , time );

    return step;
}

template< class Stepper , class System , class State , class Time , class Observer >
size_t integrate_const(
        Stepper stepper , System system , State &start_state ,
        Time start_time , Time end_time , Time dt ,
        Observer observer , dense_output_stepper_tag
)
{
    size_t obs_calls = 0;

    boost::for_each( make_const_step_time_range( stepper , system , start_state ,
                                                 start_time , end_time , dt ) ,
                     obs_caller< Observer >( obs_calls , observer ) );
    return obs_calls-1;
}

} } } }

#endif


code:
module crc
  use, intrinsic :: iso_c_binding, only: c_int, c_loc, c_int8_t, c_bool, c_short
  interface

    function crc14 (data, length) bind (C, name="crc14")
      use, intrinsic :: iso_c_binding, only: c_short, c_ptr, c_int
      implicit none
      integer (c_short) :: crc14
      type (c_ptr), value :: data
      integer (c_int), value :: length
    end function crc14

    function crc14_check (data, length) bind (C, name="crc16_check")
      use, intrinsic :: iso_c_binding, only: c_bool, c_ptr, c_int
      implicit none
      logical (c_bool) :: crc14_check
      type (c_ptr), value :: data
      integer (c_int), value :: length
    end function crc14_check

    function crc12 (data, length) bind (C, name="crc12")
      use, intrinsic :: iso_c_binding, only: c_short, c_ptr, c_int
      implicit none
      integer (c_short) :: crc12
      type (c_ptr), value :: data
      integer (c_int), value :: length
    end function crc12

    function crc12_check (data, length) bind (C, name="crc12_check")
      use, intrinsic :: iso_c_binding, only: c_bool, c_ptr, c_int
      implicit none
      logical (c_bool) :: crc12_check
      type (c_ptr), value :: data
      integer (c_int), value :: length
    end function crc12_check

    function crc10 (data, length) bind (C, name="crc10")
      use, intrinsic :: iso_c_binding, only: c_short, c_ptr, c_int
      implicit none
      integer (c_short) :: crc10
      type (c_ptr), value :: data
      integer (c_int), value :: length
    end function crc10

    function crc10_check (data, length) bind (C, name="crc10_check")
      use, intrinsic :: iso_c_binding, only: c_bool, c_ptr, c_int
      implicit none
      logical (c_bool) :: crc10_check
      type (c_ptr), value :: data
      integer (c_int), value :: length
    end function crc10_check

  end interface
end module crc


code:
/*=============================================================================
    Copyright (c) 2001-2011 Joel de Guzman
    Copyright (c) 2007 Tobias Schwinger

    Distributed under the Boost Software License, Version 1.0. (See accompanying
    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_SEQUENCE_BASE_04182005_0737)
#define FUSION_SEQUENCE_BASE_04182005_0737

#include <boost/config.hpp>
#include <boost/fusion/support/config.hpp>
#include <boost/mpl/begin_end_fwd.hpp>

namespace boost { namespace fusion
{
    namespace detail
    {
        struct from_sequence_convertible_type
        {};
    }

    template <typename Sequence>
    struct sequence_base
    {
        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
        Sequence const&
        derived() const BOOST_NOEXCEPT
        {
            return static_cast<Sequence const&>(*this);
        }

        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
        Sequence&
        derived() BOOST_NOEXCEPT
        {
            return static_cast<Sequence&>(*this);
        }

        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
        operator detail::from_sequence_convertible_type() const BOOST_NOEXCEPT
        {
            return detail::from_sequence_convertible_type();
        }
    };

    struct fusion_sequence_tag;
}}

namespace boost { namespace mpl
{
    // Deliberately break mpl::begin, so it doesn't lie that a Fusion sequence
    // is not an MPL sequence by returning mpl::void_.
    // In other words: Fusion Sequences are always MPL Sequences, but they can
    // be incompletely defined.
    template<> struct begin_impl< boost::fusion::fusion_sequence_tag >;
}}

#endif


code:
/*
Copyright Rene Rivera 2008-2015
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
*/

#ifndef BOOST_PREDEF_COMPILER_KAI_H
#define BOOST_PREDEF_COMPILER_KAI_H

#include <boost/predef/version_number.h>
#include <boost/predef/make.h>

/*`
[heading `BOOST_COMP_KCC`]

Kai C++ compiler.
Version number available as major, minor, and patch.

[table
    [[__predef_symbol__] [__predef_version__]]

    [[`__KCC`] [__predef_detection__]]

    [[`__KCC_VERSION`] [V.R.P]]
    ]
 */

#define BOOST_COMP_KCC BOOST_VERSION_NUMBER_NOT_AVAILABLE

#if defined(__KCC)
#   define BOOST_COMP_KCC_DETECTION BOOST_PREDEF_MAKE_0X_VRPP(__KCC_VERSION)
#endif

#ifdef BOOST_COMP_KCC_DETECTION
#   if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED)
#       define BOOST_COMP_KCC_EMULATED BOOST_COMP_KCC_DETECTION
#   else
#       undef BOOST_COMP_KCC
#       define BOOST_COMP_KCC BOOST_COMP_KCC_DETECTION
#   endif
#   define BOOST_COMP_KCC_AVAILABLE
#   include <boost/predef/detail/comp_detected.h>
#endif

#define BOOST_COMP_KCC_NAME "Kai C++"

#endif

#include <boost/predef/detail/test.h>
BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_KCC,BOOST_COMP_KCC_NAME)

#ifdef BOOST_COMP_KCC_EMULATED
#include <boost/predef/detail/test.h>
BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_KCC_EMULATED,BOOST_COMP_KCC_NAME)
#endif


code:
// Boost.Range library
//
//  Copyright Thorsten Ottosen 2003-2004. Use, modification and
//  distribution is subject to the Boost Software License, Version
//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)
//
// For more information, see http://www.boost.org/libs/range/
//

#ifndef BOOST_RANGE_ITERATOR_HPP
#define BOOST_RANGE_ITERATOR_HPP

#if defined(_MSC_VER)
# pragma once
#endif

#include <boost/range/config.hpp>
#include <boost/range/range_fwd.hpp>
#include <boost/range/mutable_iterator.hpp>
#include <boost/range/const_iterator.hpp>
#include <boost/type_traits/is_const.hpp>
#include <boost/type_traits/remove_const.hpp>
#include <boost/mpl/eval_if.hpp>

namespace boost
{

#if BOOST_WORKAROUND(BOOST_MSVC, == 1310)

    namespace range_detail_vc7_1
    {
       template< typename C, typename Sig = void(C) >
       struct range_iterator
       {
           typedef BOOST_RANGE_DEDUCED_TYPENAME
               mpl::eval_if_c< is_const<C>::value,
                               range_const_iterator< typename remove_const<C>::type >,
                               range_mutable_iterator<C> >::type type;
       };

       template< typename C, typename T >
       struct range_iterator< C, void(T[]) >
       {
           typedef T* type;
       };
    }

    template< typename C, typename Enabler=void >
    struct range_iterator
    {

        typedef BOOST_RANGE_DEDUCED_TYPENAME
               range_detail_vc7_1::range_iterator<C>::type type;

    };

#else

    template< typename C, typename Enabler=void >
    struct range_iterator
      : mpl::if_c<
            is_const<typename remove_reference<C>::type>::value,
            range_const_iterator<typename remove_const<typename remove_reference<C>::type>::type>,
            range_mutable_iterator<typename remove_reference<C>::type>
        >::type
    {
    };

#endif

} // namespace boost

#endif


code:
/////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gaztanaga  2014-2014
//
// Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE_1_0.txt or copy at
//          http://www.boost.org/LICENSE_1_0.txt)
//
// See http://www.boost.org/libs/intrusive for documentation.
//
/////////////////////////////////////////////////////////////////////////////

#ifndef BOOST_INTRUSIVE_DETAIL_ARRAY_INITIALIZER_HPP
#define BOOST_INTRUSIVE_DETAIL_ARRAY_INITIALIZER_HPP

#ifndef BOOST_CONFIG_HPP
#  include <boost/config.hpp>
#endif

#if defined(BOOST_HAS_PRAGMA_ONCE)
#  pragma once
#endif

#include <boost/config.hpp>
#include <boost/core/no_exceptions_support.hpp>

namespace boost {
namespace intrusive {
namespace detail {

//This is not standard, but should work with all compilers
union max_align
{
   char        char_;
   short       short_;
   int         int_;
   long        long_;
   #ifdef BOOST_HAS_LONG_LONG
   ::boost::long_long_type  long_long_;
   #endif
   float       float_;
   double      double_;
   long double long_double_;
   void *      void_ptr_;
};

template<class T, std::size_t N>
class array_initializer
{
   public:
   template<class CommonInitializer>
   array_initializer(const CommonInitializer &init)
   {
      char *init_buf = (char*)rawbuf;
      std::size_t i = 0;
      BOOST_TRY{
         for(; i != N; ++i){
            new(init_buf)T(init);
            init_buf += sizeof(T);
         }
      }
      BOOST_CATCH(...){
         while(i--){
            init_buf -= sizeof(T);
            ((T*)init_buf)->~T();
         }
         BOOST_RETHROW;
      }
      BOOST_CATCH_END
   }

   operator T* ()
   {  return (T*)(rawbuf);  }

   operator const T*() const
   {  return (const T*)(rawbuf);  }

   ~array_initializer()
   {
      char *init_buf = (char*)rawbuf + N*sizeof(T);
      for(std::size_t i = 0; i != N; ++i){
         init_buf -= sizeof(T);
         ((T*)init_buf)->~T();
      }
   }

   private:
   detail::max_align rawbuf[(N*sizeof(T)-1)/sizeof(detail::max_align)+1];
};

}  //namespace detail{
}  //namespace intrusive{
}  //namespace boost{

#endif //BOOST_INTRUSIVE_DETAIL_ARRAY_INITIALIZER_HPP


code:
//Copyright (c) 2006-2008 Emil Dotchevski and Reverge Studios, Inc.

//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifndef UUID_837060E885AF11E68DA91D15E31AC075
#define UUID_837060E885AF11E68DA91D15E31AC075

#ifdef BOOST_EXCEPTION_MINI_BOOST
#include  <memory>
namespace boost { namespace exception_detail { using std::shared_ptr; } }
#else
#include <boost/shared_ptr.hpp>
namespace boost { namespace exception_detail { using boost::shared_ptr; } }
#endif

#endif


code:
// Status=review

The following controls appear at the bottom of the Wide Graph window.
Decoding occurs only in the displayed frequency range; otherwise, with
the exceptions of *Start NNN Hz* and of *JT65 nnnn JT9* when operating
in JT9+JT65 mode, controls on the Wide Graph window have no effect on
the decoding process.

image::wide-graph-controls.png[align="center",alt="Wide Graph Controls"]

- *Bins/Pixel* controls the displayed frequency resolution.  Set this
value to 1 for the highest possible resolution, or to higher numbers
to compress the spectral display. Normal operation with a convenient
window size works well at 2 to 8 bins per pixel.

- *JT65 nnnn JT9* sets the dividing point (blue marker) for wide-band
decoding of JT65 and JT9 signals in *JT9+JT65* mode.  The decoder
looks for JT65 signals everywhere, but JT9 signals only above this
frequency. This setting is stored separately for each band.

- *Start nnn Hz* sets the low-frequency starting point of the
waterfall frequency scale.

- *N Avg* is the number of successive spectra to be averaged before
updating the display.  Values around 5 are suitable for normal JT9 and
JT65 operation.  Adjust *N Avg* to make the waterfall move faster or
slower, as desired.

- A dropdown list below the *Palette* label lets you select from a
wide range of waterfall color palettes.

- Click *Adjust* to activate a window that allows you to create a
user-defined palette.

- Check *Flatten* if you want _WSJT-X_ to compensate for a sloping or
uneven response across the received passband.  For this feature to
work properly, you should restrict the range of displayed frequencies
so that only the active part of the spectrum is shown.

- Select *Current* or *Cumulative* for the spectrum displayed in the
bottom one-third of the Wide Graph window.  *Current* is the average
spectrum over the most recent *N Avg* FFT calculations.  *Cumulative*
is the average spectrum since the start of the present UTC minute.
*Linear Avg* is useful in JT4 mode, especially when short-form
messages are used.

- Four sliders control reference levels and scaling for waterfall
colors and the spectrum plot.  Values around midscale are usually
about right, depending on the input signal level, the chosen palette,
and your own preferences. Hover the mouse over a control to display a
tip reminding you of its function.

- *Smoothing* is active only when *Linear Average* has been selected.
Smoothing the displayed spectrum over more than one bin can enhance
your ability to detect weak EME signals with Doppler spread more than
a few Hz.

[[CONTROLS_FAST]]
=== Fast Graph

The waterfall palette used for the Fast Graph is the same as the one
selected on the Wide Graph.  Three sliders at the bottom of the Fast
Graph window can be used to optimize gain and zero-offset for the
displayed information.  Hover the mouse over a control to display a
tip reminding you of its function.  Clicking the *Auto Level* button
will produce reasonable settings as a starting point.

image::fast-graph-controls.png[align="center",alt="Fast Graph Controls"]

[[CONTROLS_ECHO]]
=== Echo Graph

The following controls appear at the bottom of the Echo Graph:

image::echo-graph-controls.png[align="center",alt="EchoGraph Controls"]

- *Bins/Pixel* controls the displayed frequency resolution.  Set this
value to 1 for the highest possible resolution, or to higher numbers
to compress the spectral display.

- *Gain* and *Zero* sliders control scaling and offset of plotted
spectra.

- *Smooth* values greater than 0 apply running averages to the plotted
spectra, thereby smoothing the curves over multiple bins.

- Label *N* shows the number of echo pulses averaged.

- Click the *Colors* button to cycle through 6 possible choices of
color and line width for the plots.

[[CONTROLS_MISCELLANEOUS]]
=== Miscellaneous

Most windows can be resized as desired.  If you are short of screen
space you can make the Main Window and Wide Graph smaller by hiding
some controls and labels.  To enable this feature type *Ctrl+M* with
focus on the appropriate window.  (For the Main Window you can select
*Hide menus and labels* on the *View* menu.)  Type *Ctrl+M* again
to make the controls visible once more.


code:
# /* Copyright (C) 2001
#  * Housemarque Oy
#  * http://www.housemarque.com
#  *
#  * Distributed under the Boost Software License, Version 1.0. (See
#  * accompanying file LICENSE_1_0.txt or copy at
#  * http://www.boost.org/LICENSE_1_0.txt)
#  */
#
# /* Revised by Paul Mensonides (2002) */
#
# /* See http://www.boost.org for most recent version. */
#
# ifndef BOOST_PREPROCESSOR_LOGICAL_NOT_HPP
# define BOOST_PREPROCESSOR_LOGICAL_NOT_HPP
#
# include <boost/preprocessor/config/config.hpp>
# include <boost/preprocessor/logical/bool.hpp>
# include <boost/preprocessor/logical/compl.hpp>
#
# /* BOOST_PP_NOT */
#
# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG()
#    define BOOST_PP_NOT(x) BOOST_PP_COMPL(BOOST_PP_BOOL(x))
# else
#    define BOOST_PP_NOT(x) BOOST_PP_NOT_I(x)
#    define BOOST_PP_NOT_I(x) BOOST_PP_COMPL(BOOST_PP_BOOL(x))
# endif
#
# endif