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 BOOST_PP_ITERATION_FINISH_1 <= 256 && BOOST_PP_ITERATION_START_1 >= 256
#    define BOOST_PP_ITERATION_1 256
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 255 && BOOST_PP_ITERATION_START_1 >= 255
#    define BOOST_PP_ITERATION_1 255
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 254 && BOOST_PP_ITERATION_START_1 >= 254
#    define BOOST_PP_ITERATION_1 254
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 253 && BOOST_PP_ITERATION_START_1 >= 253
#    define BOOST_PP_ITERATION_1 253
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 252 && BOOST_PP_ITERATION_START_1 >= 252
#    define BOOST_PP_ITERATION_1 252
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 251 && BOOST_PP_ITERATION_START_1 >= 251
#    define BOOST_PP_ITERATION_1 251
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 250 && BOOST_PP_ITERATION_START_1 >= 250
#    define BOOST_PP_ITERATION_1 250
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 249 && BOOST_PP_ITERATION_START_1 >= 249
#    define BOOST_PP_ITERATION_1 249
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 248 && BOOST_PP_ITERATION_START_1 >= 248
#    define BOOST_PP_ITERATION_1 248
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 247 && BOOST_PP_ITERATION_START_1 >= 247
#    define BOOST_PP_ITERATION_1 247
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 246 && BOOST_PP_ITERATION_START_1 >= 246
#    define BOOST_PP_ITERATION_1 246
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 245 && BOOST_PP_ITERATION_START_1 >= 245
#    define BOOST_PP_ITERATION_1 245
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 244 && BOOST_PP_ITERATION_START_1 >= 244
#    define BOOST_PP_ITERATION_1 244
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 243 && BOOST_PP_ITERATION_START_1 >= 243
#    define BOOST_PP_ITERATION_1 243
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 242 && BOOST_PP_ITERATION_START_1 >= 242
#    define BOOST_PP_ITERATION_1 242
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 241 && BOOST_PP_ITERATION_START_1 >= 241
#    define BOOST_PP_ITERATION_1 241
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 240 && BOOST_PP_ITERATION_START_1 >= 240
#    define BOOST_PP_ITERATION_1 240
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 239 && BOOST_PP_ITERATION_START_1 >= 239
#    define BOOST_PP_ITERATION_1 239
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 238 && BOOST_PP_ITERATION_START_1 >= 238
#    define BOOST_PP_ITERATION_1 238
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 237 && BOOST_PP_ITERATION_START_1 >= 237
#    define BOOST_PP_ITERATION_1 237
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 236 && BOOST_PP_ITERATION_START_1 >= 236
#    define BOOST_PP_ITERATION_1 236
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 235 && BOOST_PP_ITERATION_START_1 >= 235
#    define BOOST_PP_ITERATION_1 235
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 234 && BOOST_PP_ITERATION_START_1 >= 234
#    define BOOST_PP_ITERATION_1 234
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 233 && BOOST_PP_ITERATION_START_1 >= 233
#    define BOOST_PP_ITERATION_1 233
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 232 && BOOST_PP_ITERATION_START_1 >= 232
#    define BOOST_PP_ITERATION_1 232
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 231 && BOOST_PP_ITERATION_START_1 >= 231
#    define BOOST_PP_ITERATION_1 231
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 230 && BOOST_PP_ITERATION_START_1 >= 230
#    define BOOST_PP_ITERATION_1 230
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 229 && BOOST_PP_ITERATION_START_1 >= 229
#    define BOOST_PP_ITERATION_1 229
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 228 && BOOST_PP_ITERATION_START_1 >= 228
#    define BOOST_PP_ITERATION_1 228
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 227 && BOOST_PP_ITERATION_START_1 >= 227
#    define BOOST_PP_ITERATION_1 227
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 226 && BOOST_PP_ITERATION_START_1 >= 226
#    define BOOST_PP_ITERATION_1 226
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 225 && BOOST_PP_ITERATION_START_1 >= 225
#    define BOOST_PP_ITERATION_1 225
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 224 && BOOST_PP_ITERATION_START_1 >= 224
#    define BOOST_PP_ITERATION_1 224
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 223 && BOOST_PP_ITERATION_START_1 >= 223
#    define BOOST_PP_ITERATION_1 223
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 222 && BOOST_PP_ITERATION_START_1 >= 222
#    define BOOST_PP_ITERATION_1 222
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 221 && BOOST_PP_ITERATION_START_1 >= 221
#    define BOOST_PP_ITERATION_1 221
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 220 && BOOST_PP_ITERATION_START_1 >= 220
#    define BOOST_PP_ITERATION_1 220
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 219 && BOOST_PP_ITERATION_START_1 >= 219
#    define BOOST_PP_ITERATION_1 219
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 218 && BOOST_PP_ITERATION_START_1 >= 218
#    define BOOST_PP_ITERATION_1 218
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 217 && BOOST_PP_ITERATION_START_1 >= 217
#    define BOOST_PP_ITERATION_1 217
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 216 && BOOST_PP_ITERATION_START_1 >= 216
#    define BOOST_PP_ITERATION_1 216
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 215 && BOOST_PP_ITERATION_START_1 >= 215
#    define BOOST_PP_ITERATION_1 215
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 214 && BOOST_PP_ITERATION_START_1 >= 214
#    define BOOST_PP_ITERATION_1 214
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 213 && BOOST_PP_ITERATION_START_1 >= 213
#    define BOOST_PP_ITERATION_1 213
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 212 && BOOST_PP_ITERATION_START_1 >= 212
#    define BOOST_PP_ITERATION_1 212
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 211 && BOOST_PP_ITERATION_START_1 >= 211
#    define BOOST_PP_ITERATION_1 211
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 210 && BOOST_PP_ITERATION_START_1 >= 210
#    define BOOST_PP_ITERATION_1 210
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 209 && BOOST_PP_ITERATION_START_1 >= 209
#    define BOOST_PP_ITERATION_1 209
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 208 && BOOST_PP_ITERATION_START_1 >= 208
#    define BOOST_PP_ITERATION_1 208
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 207 && BOOST_PP_ITERATION_START_1 >= 207
#    define BOOST_PP_ITERATION_1 207
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 206 && BOOST_PP_ITERATION_START_1 >= 206
#    define BOOST_PP_ITERATION_1 206
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 205 && BOOST_PP_ITERATION_START_1 >= 205
#    define BOOST_PP_ITERATION_1 205
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 204 && BOOST_PP_ITERATION_START_1 >= 204
#    define BOOST_PP_ITERATION_1 204
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 203 && BOOST_PP_ITERATION_START_1 >= 203
#    define BOOST_PP_ITERATION_1 203
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 202 && BOOST_PP_ITERATION_START_1 >= 202
#    define BOOST_PP_ITERATION_1 202
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 201 && BOOST_PP_ITERATION_START_1 >= 201
#    define BOOST_PP_ITERATION_1 201
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 200 && BOOST_PP_ITERATION_START_1 >= 200
#    define BOOST_PP_ITERATION_1 200
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 199 && BOOST_PP_ITERATION_START_1 >= 199
#    define BOOST_PP_ITERATION_1 199
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 198 && BOOST_PP_ITERATION_START_1 >= 198
#    define BOOST_PP_ITERATION_1 198
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 197 && BOOST_PP_ITERATION_START_1 >= 197
#    define BOOST_PP_ITERATION_1 197
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 196 && BOOST_PP_ITERATION_START_1 >= 196
#    define BOOST_PP_ITERATION_1 196
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 195 && BOOST_PP_ITERATION_START_1 >= 195
#    define BOOST_PP_ITERATION_1 195
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 194 && BOOST_PP_ITERATION_START_1 >= 194
#    define BOOST_PP_ITERATION_1 194
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 193 && BOOST_PP_ITERATION_START_1 >= 193
#    define BOOST_PP_ITERATION_1 193
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 192 && BOOST_PP_ITERATION_START_1 >= 192
#    define BOOST_PP_ITERATION_1 192
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 191 && BOOST_PP_ITERATION_START_1 >= 191
#    define BOOST_PP_ITERATION_1 191
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 190 && BOOST_PP_ITERATION_START_1 >= 190
#    define BOOST_PP_ITERATION_1 190
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 189 && BOOST_PP_ITERATION_START_1 >= 189
#    define BOOST_PP_ITERATION_1 189
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 188 && BOOST_PP_ITERATION_START_1 >= 188
#    define BOOST_PP_ITERATION_1 188
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 187 && BOOST_PP_ITERATION_START_1 >= 187
#    define BOOST_PP_ITERATION_1 187
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 186 && BOOST_PP_ITERATION_START_1 >= 186
#    define BOOST_PP_ITERATION_1 186
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 185 && BOOST_PP_ITERATION_START_1 >= 185
#    define BOOST_PP_ITERATION_1 185
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 184 && BOOST_PP_ITERATION_START_1 >= 184
#    define BOOST_PP_ITERATION_1 184
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 183 && BOOST_PP_ITERATION_START_1 >= 183
#    define BOOST_PP_ITERATION_1 183
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 182 && BOOST_PP_ITERATION_START_1 >= 182
#    define BOOST_PP_ITERATION_1 182
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 181 && BOOST_PP_ITERATION_START_1 >= 181
#    define BOOST_PP_ITERATION_1 181
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 180 && BOOST_PP_ITERATION_START_1 >= 180
#    define BOOST_PP_ITERATION_1 180
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 179 && BOOST_PP_ITERATION_START_1 >= 179
#    define BOOST_PP_ITERATION_1 179
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 178 && BOOST_PP_ITERATION_START_1 >= 178
#    define BOOST_PP_ITERATION_1 178
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 177 && BOOST_PP_ITERATION_START_1 >= 177
#    define BOOST_PP_ITERATION_1 177
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 176 && BOOST_PP_ITERATION_START_1 >= 176
#    define BOOST_PP_ITERATION_1 176
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 175 && BOOST_PP_ITERATION_START_1 >= 175
#    define BOOST_PP_ITERATION_1 175
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 174 && BOOST_PP_ITERATION_START_1 >= 174
#    define BOOST_PP_ITERATION_1 174
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 173 && BOOST_PP_ITERATION_START_1 >= 173
#    define BOOST_PP_ITERATION_1 173
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 172 && BOOST_PP_ITERATION_START_1 >= 172
#    define BOOST_PP_ITERATION_1 172
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 171 && BOOST_PP_ITERATION_START_1 >= 171
#    define BOOST_PP_ITERATION_1 171
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 170 && BOOST_PP_ITERATION_START_1 >= 170
#    define BOOST_PP_ITERATION_1 170
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 169 && BOOST_PP_ITERATION_START_1 >= 169
#    define BOOST_PP_ITERATION_1 169
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 168 && BOOST_PP_ITERATION_START_1 >= 168
#    define BOOST_PP_ITERATION_1 168
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 167 && BOOST_PP_ITERATION_START_1 >= 167
#    define BOOST_PP_ITERATION_1 167
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 166 && BOOST_PP_ITERATION_START_1 >= 166
#    define BOOST_PP_ITERATION_1 166
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 165 && BOOST_PP_ITERATION_START_1 >= 165
#    define BOOST_PP_ITERATION_1 165
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 164 && BOOST_PP_ITERATION_START_1 >= 164
#    define BOOST_PP_ITERATION_1 164
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 163 && BOOST_PP_ITERATION_START_1 >= 163
#    define BOOST_PP_ITERATION_1 163
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 162 && BOOST_PP_ITERATION_START_1 >= 162
#    define BOOST_PP_ITERATION_1 162
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 161 && BOOST_PP_ITERATION_START_1 >= 161
#    define BOOST_PP_ITERATION_1 161
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 160 && BOOST_PP_ITERATION_START_1 >= 160
#    define BOOST_PP_ITERATION_1 160
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 159 && BOOST_PP_ITERATION_START_1 >= 159
#    define BOOST_PP_ITERATION_1 159
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 158 && BOOST_PP_ITERATION_START_1 >= 158
#    define BOOST_PP_ITERATION_1 158
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 157 && BOOST_PP_ITERATION_START_1 >= 157
#    define BOOST_PP_ITERATION_1 157
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 156 && BOOST_PP_ITERATION_START_1 >= 156
#    define BOOST_PP_ITERATION_1 156
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 155 && BOOST_PP_ITERATION_START_1 >= 155
#    define BOOST_PP_ITERATION_1 155
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 154 && BOOST_PP_ITERATION_START_1 >= 154
#    define BOOST_PP_ITERATION_1 154
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 153 && BOOST_PP_ITERATION_START_1 >= 153
#    define BOOST_PP_ITERATION_1 153
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 152 && BOOST_PP_ITERATION_START_1 >= 152
#    define BOOST_PP_ITERATION_1 152
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 151 && BOOST_PP_ITERATION_START_1 >= 151
#    define BOOST_PP_ITERATION_1 151
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 150 && BOOST_PP_ITERATION_START_1 >= 150
#    define BOOST_PP_ITERATION_1 150
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 149 && BOOST_PP_ITERATION_START_1 >= 149
#    define BOOST_PP_ITERATION_1 149
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 148 && BOOST_PP_ITERATION_START_1 >= 148
#    define BOOST_PP_ITERATION_1 148
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 147 && BOOST_PP_ITERATION_START_1 >= 147
#    define BOOST_PP_ITERATION_1 147
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 146 && BOOST_PP_ITERATION_START_1 >= 146
#    define BOOST_PP_ITERATION_1 146
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 145 && BOOST_PP_ITERATION_START_1 >= 145
#    define BOOST_PP_ITERATION_1 145
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 144 && BOOST_PP_ITERATION_START_1 >= 144
#    define BOOST_PP_ITERATION_1 144
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 143 && BOOST_PP_ITERATION_START_1 >= 143
#    define BOOST_PP_ITERATION_1 143
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 142 && BOOST_PP_ITERATION_START_1 >= 142
#    define BOOST_PP_ITERATION_1 142
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 141 && BOOST_PP_ITERATION_START_1 >= 141
#    define BOOST_PP_ITERATION_1 141
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 140 && BOOST_PP_ITERATION_START_1 >= 140
#    define BOOST_PP_ITERATION_1 140
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 139 && BOOST_PP_ITERATION_START_1 >= 139
#    define BOOST_PP_ITERATION_1 139
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 138 && BOOST_PP_ITERATION_START_1 >= 138
#    define BOOST_PP_ITERATION_1 138
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 137 && BOOST_PP_ITERATION_START_1 >= 137
#    define BOOST_PP_ITERATION_1 137
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 136 && BOOST_PP_ITERATION_START_1 >= 136
#    define BOOST_PP_ITERATION_1 136
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 135 && BOOST_PP_ITERATION_START_1 >= 135
#    define BOOST_PP_ITERATION_1 135
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 134 && BOOST_PP_ITERATION_START_1 >= 134
#    define BOOST_PP_ITERATION_1 134
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 133 && BOOST_PP_ITERATION_START_1 >= 133
#    define BOOST_PP_ITERATION_1 133
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 132 && BOOST_PP_ITERATION_START_1 >= 132
#    define BOOST_PP_ITERATION_1 132
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 131 && BOOST_PP_ITERATION_START_1 >= 131
#    define BOOST_PP_ITERATION_1 131
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 130 && BOOST_PP_ITERATION_START_1 >= 130
#    define BOOST_PP_ITERATION_1 130
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 129 && BOOST_PP_ITERATION_START_1 >= 129
#    define BOOST_PP_ITERATION_1 129
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 128 && BOOST_PP_ITERATION_START_1 >= 128
#    define BOOST_PP_ITERATION_1 128
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 127 && BOOST_PP_ITERATION_START_1 >= 127
#    define BOOST_PP_ITERATION_1 127
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 126 && BOOST_PP_ITERATION_START_1 >= 126
#    define BOOST_PP_ITERATION_1 126
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 125 && BOOST_PP_ITERATION_START_1 >= 125
#    define BOOST_PP_ITERATION_1 125
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 124 && BOOST_PP_ITERATION_START_1 >= 124
#    define BOOST_PP_ITERATION_1 124
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 123 && BOOST_PP_ITERATION_START_1 >= 123
#    define BOOST_PP_ITERATION_1 123
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 122 && BOOST_PP_ITERATION_START_1 >= 122
#    define BOOST_PP_ITERATION_1 122
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 121 && BOOST_PP_ITERATION_START_1 >= 121
#    define BOOST_PP_ITERATION_1 121
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 120 && BOOST_PP_ITERATION_START_1 >= 120
#    define BOOST_PP_ITERATION_1 120
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 119 && BOOST_PP_ITERATION_START_1 >= 119
#    define BOOST_PP_ITERATION_1 119
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 118 && BOOST_PP_ITERATION_START_1 >= 118
#    define BOOST_PP_ITERATION_1 118
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 117 && BOOST_PP_ITERATION_START_1 >= 117
#    define BOOST_PP_ITERATION_1 117
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 116 && BOOST_PP_ITERATION_START_1 >= 116
#    define BOOST_PP_ITERATION_1 116
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 115 && BOOST_PP_ITERATION_START_1 >= 115
#    define BOOST_PP_ITERATION_1 115
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 114 && BOOST_PP_ITERATION_START_1 >= 114
#    define BOOST_PP_ITERATION_1 114
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 113 && BOOST_PP_ITERATION_START_1 >= 113
#    define BOOST_PP_ITERATION_1 113
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 112 && BOOST_PP_ITERATION_START_1 >= 112
#    define BOOST_PP_ITERATION_1 112
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 111 && BOOST_PP_ITERATION_START_1 >= 111
#    define BOOST_PP_ITERATION_1 111
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 110 && BOOST_PP_ITERATION_START_1 >= 110
#    define BOOST_PP_ITERATION_1 110
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 109 && BOOST_PP_ITERATION_START_1 >= 109
#    define BOOST_PP_ITERATION_1 109
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 108 && BOOST_PP_ITERATION_START_1 >= 108
#    define BOOST_PP_ITERATION_1 108
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 107 && BOOST_PP_ITERATION_START_1 >= 107
#    define BOOST_PP_ITERATION_1 107
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 106 && BOOST_PP_ITERATION_START_1 >= 106
#    define BOOST_PP_ITERATION_1 106
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 105 && BOOST_PP_ITERATION_START_1 >= 105
#    define BOOST_PP_ITERATION_1 105
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 104 && BOOST_PP_ITERATION_START_1 >= 104
#    define BOOST_PP_ITERATION_1 104
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 103 && BOOST_PP_ITERATION_START_1 >= 103
#    define BOOST_PP_ITERATION_1 103
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 102 && BOOST_PP_ITERATION_START_1 >= 102
#    define BOOST_PP_ITERATION_1 102
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 101 && BOOST_PP_ITERATION_START_1 >= 101
#    define BOOST_PP_ITERATION_1 101
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 100 && BOOST_PP_ITERATION_START_1 >= 100
#    define BOOST_PP_ITERATION_1 100
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 99 && BOOST_PP_ITERATION_START_1 >= 99
#    define BOOST_PP_ITERATION_1 99
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 98 && BOOST_PP_ITERATION_START_1 >= 98
#    define BOOST_PP_ITERATION_1 98
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 97 && BOOST_PP_ITERATION_START_1 >= 97
#    define BOOST_PP_ITERATION_1 97
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 96 && BOOST_PP_ITERATION_START_1 >= 96
#    define BOOST_PP_ITERATION_1 96
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 95 && BOOST_PP_ITERATION_START_1 >= 95
#    define BOOST_PP_ITERATION_1 95
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 94 && BOOST_PP_ITERATION_START_1 >= 94
#    define BOOST_PP_ITERATION_1 94
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 93 && BOOST_PP_ITERATION_START_1 >= 93
#    define BOOST_PP_ITERATION_1 93
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 92 && BOOST_PP_ITERATION_START_1 >= 92
#    define BOOST_PP_ITERATION_1 92
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 91 && BOOST_PP_ITERATION_START_1 >= 91
#    define BOOST_PP_ITERATION_1 91
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 90 && BOOST_PP_ITERATION_START_1 >= 90
#    define BOOST_PP_ITERATION_1 90
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 89 && BOOST_PP_ITERATION_START_1 >= 89
#    define BOOST_PP_ITERATION_1 89
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 88 && BOOST_PP_ITERATION_START_1 >= 88
#    define BOOST_PP_ITERATION_1 88
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 87 && BOOST_PP_ITERATION_START_1 >= 87
#    define BOOST_PP_ITERATION_1 87
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 86 && BOOST_PP_ITERATION_START_1 >= 86
#    define BOOST_PP_ITERATION_1 86
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 85 && BOOST_PP_ITERATION_START_1 >= 85
#    define BOOST_PP_ITERATION_1 85
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 84 && BOOST_PP_ITERATION_START_1 >= 84
#    define BOOST_PP_ITERATION_1 84
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 83 && BOOST_PP_ITERATION_START_1 >= 83
#    define BOOST_PP_ITERATION_1 83
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 82 && BOOST_PP_ITERATION_START_1 >= 82
#    define BOOST_PP_ITERATION_1 82
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 81 && BOOST_PP_ITERATION_START_1 >= 81
#    define BOOST_PP_ITERATION_1 81
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 80 && BOOST_PP_ITERATION_START_1 >= 80
#    define BOOST_PP_ITERATION_1 80
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 79 && BOOST_PP_ITERATION_START_1 >= 79
#    define BOOST_PP_ITERATION_1 79
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 78 && BOOST_PP_ITERATION_START_1 >= 78
#    define BOOST_PP_ITERATION_1 78
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 77 && BOOST_PP_ITERATION_START_1 >= 77
#    define BOOST_PP_ITERATION_1 77
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 76 && BOOST_PP_ITERATION_START_1 >= 76
#    define BOOST_PP_ITERATION_1 76
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 75 && BOOST_PP_ITERATION_START_1 >= 75
#    define BOOST_PP_ITERATION_1 75
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 74 && BOOST_PP_ITERATION_START_1 >= 74
#    define BOOST_PP_ITERATION_1 74
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 73 && BOOST_PP_ITERATION_START_1 >= 73
#    define BOOST_PP_ITERATION_1 73
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 72 && BOOST_PP_ITERATION_START_1 >= 72
#    define BOOST_PP_ITERATION_1 72
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 71 && BOOST_PP_ITERATION_START_1 >= 71
#    define BOOST_PP_ITERATION_1 71
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 70 && BOOST_PP_ITERATION_START_1 >= 70
#    define BOOST_PP_ITERATION_1 70
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 69 && BOOST_PP_ITERATION_START_1 >= 69
#    define BOOST_PP_ITERATION_1 69
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 68 && BOOST_PP_ITERATION_START_1 >= 68
#    define BOOST_PP_ITERATION_1 68
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 67 && BOOST_PP_ITERATION_START_1 >= 67
#    define BOOST_PP_ITERATION_1 67
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 66 && BOOST_PP_ITERATION_START_1 >= 66
#    define BOOST_PP_ITERATION_1 66
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 65 && BOOST_PP_ITERATION_START_1 >= 65
#    define BOOST_PP_ITERATION_1 65
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 64 && BOOST_PP_ITERATION_START_1 >= 64
#    define BOOST_PP_ITERATION_1 64
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 63 && BOOST_PP_ITERATION_START_1 >= 63
#    define BOOST_PP_ITERATION_1 63
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 62 && BOOST_PP_ITERATION_START_1 >= 62
#    define BOOST_PP_ITERATION_1 62
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 61 && BOOST_PP_ITERATION_START_1 >= 61
#    define BOOST_PP_ITERATION_1 61
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 60 && BOOST_PP_ITERATION_START_1 >= 60
#    define BOOST_PP_ITERATION_1 60
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 59 && BOOST_PP_ITERATION_START_1 >= 59
#    define BOOST_PP_ITERATION_1 59
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 58 && BOOST_PP_ITERATION_START_1 >= 58
#    define BOOST_PP_ITERATION_1 58
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 57 && BOOST_PP_ITERATION_START_1 >= 57
#    define BOOST_PP_ITERATION_1 57
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 56 && BOOST_PP_ITERATION_START_1 >= 56
#    define BOOST_PP_ITERATION_1 56
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 55 && BOOST_PP_ITERATION_START_1 >= 55
#    define BOOST_PP_ITERATION_1 55
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 54 && BOOST_PP_ITERATION_START_1 >= 54
#    define BOOST_PP_ITERATION_1 54
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 53 && BOOST_PP_ITERATION_START_1 >= 53
#    define BOOST_PP_ITERATION_1 53
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 52 && BOOST_PP_ITERATION_START_1 >= 52
#    define BOOST_PP_ITERATION_1 52
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 51 && BOOST_PP_ITERATION_START_1 >= 51
#    define BOOST_PP_ITERATION_1 51
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 50 && BOOST_PP_ITERATION_START_1 >= 50
#    define BOOST_PP_ITERATION_1 50
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 49 && BOOST_PP_ITERATION_START_1 >= 49
#    define BOOST_PP_ITERATION_1 49
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 48 && BOOST_PP_ITERATION_START_1 >= 48
#    define BOOST_PP_ITERATION_1 48
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 47 && BOOST_PP_ITERATION_START_1 >= 47
#    define BOOST_PP_ITERATION_1 47
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 46 && BOOST_PP_ITERATION_START_1 >= 46
#    define BOOST_PP_ITERATION_1 46
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 45 && BOOST_PP_ITERATION_START_1 >= 45
#    define BOOST_PP_ITERATION_1 45
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 44 && BOOST_PP_ITERATION_START_1 >= 44
#    define BOOST_PP_ITERATION_1 44
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 43 && BOOST_PP_ITERATION_START_1 >= 43
#    define BOOST_PP_ITERATION_1 43
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 42 && BOOST_PP_ITERATION_START_1 >= 42
#    define BOOST_PP_ITERATION_1 42
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 41 && BOOST_PP_ITERATION_START_1 >= 41
#    define BOOST_PP_ITERATION_1 41
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 40 && BOOST_PP_ITERATION_START_1 >= 40
#    define BOOST_PP_ITERATION_1 40
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 39 && BOOST_PP_ITERATION_START_1 >= 39
#    define BOOST_PP_ITERATION_1 39
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 38 && BOOST_PP_ITERATION_START_1 >= 38
#    define BOOST_PP_ITERATION_1 38
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 37 && BOOST_PP_ITERATION_START_1 >= 37
#    define BOOST_PP_ITERATION_1 37
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 36 && BOOST_PP_ITERATION_START_1 >= 36
#    define BOOST_PP_ITERATION_1 36
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 35 && BOOST_PP_ITERATION_START_1 >= 35
#    define BOOST_PP_ITERATION_1 35
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 34 && BOOST_PP_ITERATION_START_1 >= 34
#    define BOOST_PP_ITERATION_1 34
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 33 && BOOST_PP_ITERATION_START_1 >= 33
#    define BOOST_PP_ITERATION_1 33
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 32 && BOOST_PP_ITERATION_START_1 >= 32
#    define BOOST_PP_ITERATION_1 32
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 31 && BOOST_PP_ITERATION_START_1 >= 31
#    define BOOST_PP_ITERATION_1 31
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 30 && BOOST_PP_ITERATION_START_1 >= 30
#    define BOOST_PP_ITERATION_1 30
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 29 && BOOST_PP_ITERATION_START_1 >= 29
#    define BOOST_PP_ITERATION_1 29
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 28 && BOOST_PP_ITERATION_START_1 >= 28
#    define BOOST_PP_ITERATION_1 28
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 27 && BOOST_PP_ITERATION_START_1 >= 27
#    define BOOST_PP_ITERATION_1 27
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 26 && BOOST_PP_ITERATION_START_1 >= 26
#    define BOOST_PP_ITERATION_1 26
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 25 && BOOST_PP_ITERATION_START_1 >= 25
#    define BOOST_PP_ITERATION_1 25
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 24 && BOOST_PP_ITERATION_START_1 >= 24
#    define BOOST_PP_ITERATION_1 24
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 23 && BOOST_PP_ITERATION_START_1 >= 23
#    define BOOST_PP_ITERATION_1 23
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 22 && BOOST_PP_ITERATION_START_1 >= 22
#    define BOOST_PP_ITERATION_1 22
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 21 && BOOST_PP_ITERATION_START_1 >= 21
#    define BOOST_PP_ITERATION_1 21
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 20 && BOOST_PP_ITERATION_START_1 >= 20
#    define BOOST_PP_ITERATION_1 20
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 19 && BOOST_PP_ITERATION_START_1 >= 19
#    define BOOST_PP_ITERATION_1 19
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 18 && BOOST_PP_ITERATION_START_1 >= 18
#    define BOOST_PP_ITERATION_1 18
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 17 && BOOST_PP_ITERATION_START_1 >= 17
#    define BOOST_PP_ITERATION_1 17
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 16 && BOOST_PP_ITERATION_START_1 >= 16
#    define BOOST_PP_ITERATION_1 16
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 15 && BOOST_PP_ITERATION_START_1 >= 15
#    define BOOST_PP_ITERATION_1 15
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 14 && BOOST_PP_ITERATION_START_1 >= 14
#    define BOOST_PP_ITERATION_1 14
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 13 && BOOST_PP_ITERATION_START_1 >= 13
#    define BOOST_PP_ITERATION_1 13
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 12 && BOOST_PP_ITERATION_START_1 >= 12
#    define BOOST_PP_ITERATION_1 12
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 11 && BOOST_PP_ITERATION_START_1 >= 11
#    define BOOST_PP_ITERATION_1 11
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 10 && BOOST_PP_ITERATION_START_1 >= 10
#    define BOOST_PP_ITERATION_1 10
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 9 && BOOST_PP_ITERATION_START_1 >= 9
#    define BOOST_PP_ITERATION_1 9
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 8 && BOOST_PP_ITERATION_START_1 >= 8
#    define BOOST_PP_ITERATION_1 8
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 7 && BOOST_PP_ITERATION_START_1 >= 7
#    define BOOST_PP_ITERATION_1 7
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 6 && BOOST_PP_ITERATION_START_1 >= 6
#    define BOOST_PP_ITERATION_1 6
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 5 && BOOST_PP_ITERATION_START_1 >= 5
#    define BOOST_PP_ITERATION_1 5
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 4 && BOOST_PP_ITERATION_START_1 >= 4
#    define BOOST_PP_ITERATION_1 4
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 3 && BOOST_PP_ITERATION_START_1 >= 3
#    define BOOST_PP_ITERATION_1 3
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 2 && BOOST_PP_ITERATION_START_1 >= 2
#    define BOOST_PP_ITERATION_1 2
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 1 && BOOST_PP_ITERATION_START_1 >= 1
#    define BOOST_PP_ITERATION_1 1
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif
# if BOOST_PP_ITERATION_FINISH_1 <= 0 && BOOST_PP_ITERATION_START_1 >= 0
#    define BOOST_PP_ITERATION_1 0
#    include BOOST_PP_FILENAME_1
#    undef BOOST_PP_ITERATION_1
# endif


code:
// Boost.Range library
//
//  Copyright Neil Groves 2009. 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)
//
// Acknowledgements:
// aschoedl contributed an improvement to the determination
// of the Reference type parameter.
//
// Leonid Gershanovich reported Trac ticket 7376 about the dereference operator
// requiring identical reference types due to using the ternary if.
//
// For more information, see http://www.boost.org/libs/range/
//
#ifndef BOOST_RANGE_DETAIL_JOIN_ITERATOR_HPP_INCLUDED
#define BOOST_RANGE_DETAIL_JOIN_ITERATOR_HPP_INCLUDED

#include <iterator>
#include <boost/assert.hpp>
#include <boost/iterator/iterator_traits.hpp>
#include <boost/iterator/iterator_facade.hpp>
#include <boost/range/begin.hpp>
#include <boost/range/end.hpp>
#include <boost/range/empty.hpp>
#include <boost/range/detail/demote_iterator_traversal_tag.hpp>
#include <boost/range/value_type.hpp>
#include <boost/type_traits/add_const.hpp>
#include <boost/type_traits/add_reference.hpp>
#include <boost/type_traits/remove_const.hpp>
#include <boost/type_traits/remove_reference.hpp>
#include <boost/next_prior.hpp>

namespace boost
{
    namespace range_detail
    {

template<typename Iterator1, typename Iterator2>
struct join_iterator_link
{
public:
    join_iterator_link(Iterator1 last1, Iterator2 first2)
        :    last1(last1)
        ,    first2(first2)
    {
    }

    Iterator1 last1;
    Iterator2 first2;

private:
    join_iterator_link() /* = delete */ ;
};

class join_iterator_begin_tag {};
class join_iterator_end_tag {};

template<typename Iterator1
       , typename Iterator2
       , typename Reference
>
class join_iterator_union
{
public:
    typedef Iterator1 iterator1_t;
    typedef Iterator2 iterator2_t;

    join_iterator_union() {}
    join_iterator_union(unsigned int /*selected*/, const iterator1_t& it1, const iterator2_t& it2) : m_it1(it1), m_it2(it2) {}

    iterator1_t& it1() { return m_it1; }
    const iterator1_t& it1() const { return m_it1; }

    iterator2_t& it2() { return m_it2; }
    const iterator2_t& it2() const { return m_it2; }

    Reference dereference(unsigned int selected) const
    {
        if (selected)
            return *m_it2;
        return *m_it1;
    }

    bool equal(const join_iterator_union& other, unsigned int selected) const
    {
        return selected
            ? m_it2 == other.m_it2
            : m_it1 == other.m_it1;
    }

private:
    iterator1_t m_it1;
    iterator2_t m_it2;
};

template<class Iterator, class Reference>
class join_iterator_union<Iterator, Iterator, Reference>
{
public:
    typedef Iterator iterator1_t;
    typedef Iterator iterator2_t;

    join_iterator_union() {}

    join_iterator_union(unsigned int selected, const iterator1_t& it1, const iterator2_t& it2)
        : m_it(selected ? it2 : it1)
    {
    }

    iterator1_t& it1() { return m_it; }
    const iterator1_t& it1() const { return m_it; }

    iterator2_t& it2() { return m_it; }
    const iterator2_t& it2() const { return m_it; }

    Reference dereference(unsigned int) const
    {
        return *m_it;
    }

    bool equal(const join_iterator_union& other,
               unsigned int /*selected*/) const
    {
        return m_it == other.m_it;
    }

private:
    iterator1_t m_it;
};

template<typename Iterator1
       , typename Iterator2
       , typename ValueType = typename iterator_value<Iterator1>::type
       // find least demanding, commonly supported reference type, in the order &, const&, and by-value:
       , typename Reference = typename mpl::if_c<
                !is_reference<typename iterator_reference<Iterator1>::type>::value
             || !is_reference<typename iterator_reference<Iterator2>::type>::value,
                        typename remove_const<
                            typename remove_reference<
                                typename iterator_reference<Iterator1>::type
                            >::type
                        >::type,
                        typename mpl::if_c<
                            is_const<
                                typename remove_reference<
                                    typename iterator_reference<Iterator1>::type
                                >::type
                            >::value
                            || is_const<
                                typename remove_reference<
                                    typename iterator_reference<Iterator2>::type
                                >::type
                            >::value,
                            typename add_const<
                                typename iterator_reference<Iterator1>::type
                            >::type,
                            typename iterator_reference<Iterator1>::type
                        >::type
                    >::type
       , typename Traversal = typename demote_iterator_traversal_tag<
                                  typename iterator_traversal<Iterator1>::type
                                , typename iterator_traversal<Iterator2>::type>::type
>
class join_iterator
    : public iterator_facade<join_iterator<Iterator1,Iterator2,ValueType,Reference,Traversal>, ValueType, Traversal, Reference>
{
    typedef join_iterator_link<Iterator1, Iterator2> link_t;
    typedef join_iterator_union<Iterator1, Iterator2, Reference> iterator_union;
public:
    typedef Iterator1 iterator1_t;
    typedef Iterator2 iterator2_t;

    join_iterator()
        : m_section(0u)
        , m_it(0u, iterator1_t(), iterator2_t())
        , m_link(link_t(iterator1_t(), iterator2_t()))
    {}

    join_iterator(unsigned int section, Iterator1 current1, Iterator1 last1, Iterator2 first2, Iterator2 current2)
        : m_section(section)
        , m_it(section, current1, current2)
        , m_link(link_t(last1, first2))
        {
        }

    template<typename Range1, typename Range2>
    join_iterator(Range1& r1, Range2& r2, join_iterator_begin_tag)
        : m_section(boost::empty(r1) ? 1u : 0u)
        , m_it(boost::empty(r1) ? 1u : 0u, boost::begin(r1), boost::begin(r2))
        , m_link(link_t(boost::end(r1), boost::begin(r2)))
    {
    }

    template<typename Range1, typename Range2>
    join_iterator(const Range1& r1, const Range2& r2, join_iterator_begin_tag)
        : m_section(boost::empty(r1) ? 1u : 0u)
        , m_it(boost::empty(r1) ? 1u : 0u, boost::const_begin(r1), boost::const_begin(r2))
        , m_link(link_t(boost::const_end(r1), boost::const_begin(r2)))
    {
    }

    template<typename Range1, typename Range2>
    join_iterator(Range1& r1, Range2& r2, join_iterator_end_tag)
        : m_section(1u)
        , m_it(1u, boost::end(r1), boost::end(r2))
        , m_link(link_t(boost::end(r1), boost::begin(r2)))
    {
    }

    template<typename Range1, typename Range2>
    join_iterator(const Range1& r1, const Range2& r2, join_iterator_end_tag)
        : m_section(1u)
        , m_it(1u, boost::const_end(r1), boost::const_end(r2))
        , m_link(link_t(boost::const_end(r1), boost::const_begin(r2)))
    {
    }

private:
    void increment()
    {
        if (m_section)
            ++m_it.it2();
        else
        {
            ++m_it.it1();
            if (m_it.it1() == m_link.last1)
            {
                m_it.it2() = m_link.first2;
                m_section = 1u;
            }
        }
    }

    void decrement()
    {
        if (m_section)
        {
            if (m_it.it2() == m_link.first2)
            {
                m_it.it1() = boost::prior(m_link.last1);
                m_section = 0u;
            }
            else
                --m_it.it2();
        }
        else
            --m_it.it1();
    }

    typename join_iterator::reference dereference() const
    {
        return m_it.dereference(m_section);
    }

    bool equal(const join_iterator& other) const
    {
        return m_section == other.m_section
            && m_it.equal(other.m_it, m_section);
    }

    void advance(typename join_iterator::difference_type offset)
    {
        if (m_section)
            advance_from_range2(offset);
        else
            advance_from_range1(offset);
    }

    typename join_iterator::difference_type distance_to(const join_iterator& other) const
    {
        typename join_iterator::difference_type result;
        if (m_section)
        {
            if (other.m_section)
                result = other.m_it.it2() - m_it.it2();
            else
            {
                result = (m_link.first2 - m_it.it2())
                       + (other.m_it.it1() - m_link.last1);

                BOOST_ASSERT( result <= 0 );
            }
        }
        else
        {
            if (other.m_section)
            {
                result = (m_link.last1 - m_it.it1())
                       + (other.m_it.it2() - m_link.first2);
            }
            else
                result = other.m_it.it1() - m_it.it1();
        }
        return result;
    }

    void advance_from_range2(typename join_iterator::difference_type offset)
    {
        typedef typename join_iterator::difference_type difference_t;
        BOOST_ASSERT( m_section == 1u );
        if (offset < 0)
        {
            difference_t r2_dist = m_link.first2 - m_it.it2();
            BOOST_ASSERT( r2_dist <= 0 );
            if (offset >= r2_dist)
                std::advance(m_it.it2(), offset);
            else
            {
                difference_t r1_dist = offset - r2_dist;
                BOOST_ASSERT( r1_dist <= 0 );
                m_it.it1() = m_link.last1 + r1_dist;
                m_section = 0u;
            }
        }
        else
            std::advance(m_it.it2(), offset);
    }

    void advance_from_range1(typename join_iterator::difference_type offset)
    {
        typedef typename join_iterator::difference_type difference_t;
        BOOST_ASSERT( m_section == 0u );
        if (offset > 0)
        {
            difference_t r1_dist = m_link.last1 - m_it.it1();
            BOOST_ASSERT( r1_dist >= 0 );
            if (offset < r1_dist)
                std::advance(m_it.it1(), offset);
            else
            {
                difference_t r2_dist = offset - r1_dist;
                BOOST_ASSERT( r2_dist >= 0 );
                m_it.it2() = m_link.first2 + r2_dist;
                m_section = 1u;
            }
        }
        else
            std::advance(m_it.it1(), offset);
    }

    unsigned int m_section;
    iterator_union m_it;
    link_t m_link;

    friend class ::boost::iterator_core_access;
};

    } // namespace range_detail

} // namespace boost

#endif // include guard

license: mit


code:
#ifndef BOOST_ARCHIVE_DETAIL_BASIC_IARCHIVE_HPP
#define BOOST_ARCHIVE_DETAIL_BASIC_IARCHIVE_HPP

// MS compatible compilers support #pragma once
#if defined(_MSC_VER)
# pragma once
#endif

/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// basic_iarchive.hpp:

// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// 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)

//  See http://www.boost.org for updates, documentation, and revision history.

// can't use this - much as I'd like to as borland doesn't support it

#include <boost/config.hpp>
#include <boost/noncopyable.hpp>
#include <boost/scoped_ptr.hpp>

#include <boost/serialization/tracking_enum.hpp>
#include <boost/archive/basic_archive.hpp>
#include <boost/archive/detail/decl.hpp>
#include <boost/archive/detail/helper_collection.hpp>
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header

namespace boost {
namespace serialization {
    class extended_type_info;
} // namespace serialization

namespace archive {
namespace detail {

class basic_iarchive_impl;
class basic_iserializer;
class basic_pointer_iserializer;

//////////////////////////////////////////////////////////////////////
// class basic_iarchive - read serialized objects from a input stream
class BOOST_SYMBOL_VISIBLE basic_iarchive :
    private boost::noncopyable,
    public boost::archive::detail::helper_collection
{
    friend class basic_iarchive_impl;
    // hide implementation of this class to minimize header conclusion
    boost::scoped_ptr<basic_iarchive_impl> pimpl;

    virtual void vload(version_type &t) =  0;
    virtual void vload(object_id_type &t) =  0;
    virtual void vload(class_id_type &t) =  0;
    virtual void vload(class_id_optional_type &t) = 0;
    virtual void vload(class_name_type &t) = 0;
    virtual void vload(tracking_type &t) = 0;
protected:
    BOOST_ARCHIVE_DECL basic_iarchive(unsigned int flags);
    boost::archive::detail::helper_collection &
    get_helper_collection(){
        return *this;
    }
public:
    // some msvc versions require that the following function be public
    // otherwise it should really protected.
    virtual BOOST_ARCHIVE_DECL ~basic_iarchive();
    // note: NOT part of the public API.
    BOOST_ARCHIVE_DECL void next_object_pointer(void *t);
    BOOST_ARCHIVE_DECL void register_basic_serializer(
        const basic_iserializer & bis
    );
    BOOST_ARCHIVE_DECL void load_object(
        void *t,
        const basic_iserializer & bis
    );
    BOOST_ARCHIVE_DECL const basic_pointer_iserializer *
    load_pointer(
        void * & t,
        const basic_pointer_iserializer * bpis_ptr,
        const basic_pointer_iserializer * (*finder)(
            const boost::serialization::extended_type_info & eti
        )
    );
    // real public API starts here
    BOOST_ARCHIVE_DECL void
    set_library_version(library_version_type archive_library_version);
    BOOST_ARCHIVE_DECL library_version_type
    get_library_version() const;
    BOOST_ARCHIVE_DECL unsigned int
    get_flags() const;
    BOOST_ARCHIVE_DECL void
    reset_object_address(const void * new_address, const void * old_address);
    BOOST_ARCHIVE_DECL void
    delete_created_pointers();
};

} // namespace detail
} // namespace archive
} // namespace boost

#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas

#endif //BOOST_ARCHIVE_DETAIL_BASIC_IARCHIVE_HPP


code:
//  (C) Copyright John Maddock 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)
//
// The aim of this header is just to include <complex> but to do
// so in a way that does not result in recursive inclusion of
// the Boost TR1 components if boost/tr1/tr1/complex is in the
// include search path.  We have to do this to avoid circular
// dependencies:
//

#ifndef BOOST_CONFIG_COMPLEX
#  define BOOST_CONFIG_COMPLEX

#  ifndef BOOST_TR1_NO_RECURSION
#     define BOOST_TR1_NO_RECURSION
#     define BOOST_CONFIG_NO_COMPLEX_RECURSION
#  endif

#  include <complex>

#  ifdef BOOST_CONFIG_NO_COMPLEX_RECURSION
#     undef BOOST_TR1_NO_RECURSION
#     undef BOOST_CONFIG_NO_COMPLEX_RECURSION
#  endif

#endif


code:
/*==============================================================================
    Copyright (c) 2010 Thomas Heller

    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_PHOENIX_SUPPORT_ITERATE_HPP
#define BOOST_PHOENIX_SUPPORT_ITERATE_HPP

#include <boost/preprocessor/iteration/iterate.hpp>

#define BOOST_PHOENIX_IS_ITERATING 0

#define BOOST_PHOENIX_ITERATE()                                                 \
    <boost/phoenix/support/detail/iterate.hpp>

#include <boost/phoenix/support/detail/iterate_define.hpp>

#endif


code:
/*
 [auto_generated]
 boost/numeric/odeint/util/detail/less_with_sign.hpp

 [begin_description]
 Helper function to compare times taking into account the sign of dt
 [end_description]

 Copyright 2012-2015 Mario Mulansky
 Copyright 2012 Karsten Ahnert

 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_LESS_WITH_SIGN_HPP_INCLUDED
#define BOOST_NUMERIC_ODEINT_INTEGRATE_DETAIL_LESS_WITH_SIGN_HPP_INCLUDED

#include <limits>

#include <boost/numeric/odeint/util/unit_helper.hpp>

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

/**
 * return t1 < t2 if dt > 0 and t1 > t2 if dt < 0 with epsilon accuracy
 */
template< typename T >
bool less_with_sign( T t1 , T t2 , T dt )
{
    if( get_unit_value(dt) > 0 )
        //return t1 < t2;
        return t2-t1 > std::numeric_limits<T>::epsilon();
    else
        //return t1 > t2;
        return t1-t2 > std::numeric_limits<T>::epsilon();
}

/**
 * return t1 <= t2 if dt > 0 and t1 => t2 if dt < 0 with epsilon accuracy
 */
template< typename T >
bool less_eq_with_sign( T t1 , T t2 , T dt )
{
    if( get_unit_value(dt) > 0 )
        return t1-t2 <= std::numeric_limits<T>::epsilon();
    else
        return t2-t1 <= std::numeric_limits<T>::epsilon();
}

template< typename T >
T min_abs( T t1 , T t2 )
{
    BOOST_USING_STD_MIN();
    BOOST_USING_STD_MAX();
    if( get_unit_value(t1)>0 )
        return min BOOST_PREVENT_MACRO_SUBSTITUTION ( t1 , t2 );
    else
        return max BOOST_PREVENT_MACRO_SUBSTITUTION ( t1 , t2 );
}

template< typename T >
T max_abs( T t1 , T t2 )
{
    BOOST_USING_STD_MIN();
    BOOST_USING_STD_MAX();
    if( get_unit_value(t1)>0 )
        return max BOOST_PREVENT_MACRO_SUBSTITUTION ( t1 , t2 );
    else
        return min BOOST_PREVENT_MACRO_SUBSTITUTION ( t1 , t2 );
}
} } } }

#endif


code:
// (C) Copyright 2005 Matthias Troyer

// 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)

//  Authors: Matthias Troyer

#ifndef BOOST_MPI_PACKED_OPRIMITIVE_HPP
#define BOOST_MPI_PACKED_OPRIMITIVE_HPP

#include <boost/mpi/config.hpp>
#include <cstddef> // size_t
#include <boost/config.hpp>

#include <boost/mpi/datatype.hpp>
#include <boost/mpi/exception.hpp>
#include <boost/serialization/detail/get_data.hpp>
#include <boost/serialization/array.hpp>
#include <boost/assert.hpp>
#include <vector>
#include <boost/mpi/allocator.hpp>

namespace boost { namespace mpi {

/// serialization using MPI::Pack

class BOOST_MPI_DECL packed_oprimitive
{
public:
    /// the type of the buffer into which the data is packed upon serialization
    typedef std::vector<char, allocator<char> > buffer_type;

    packed_oprimitive(buffer_type & b, MPI_Comm const & comm)
         : buffer_(b),
           comm(comm)
        {
        }

    void const * address() const
    {
      return &buffer_[0];
    }

    const std::size_t& size() const
    {
      return size_ = buffer_.size();
    }

    void save_binary(void const *address, std::size_t count)
        {
          save_impl(address,MPI_BYTE,count);
        }

    // fast saving of arrays
    template<class T>
    void save_array(serialization::array_wrapper<T> const& x, unsigned int /* file_version */)
    {
        if (x.count())
          save_impl(x.address(), get_mpi_datatype(*x.address()), x.count());
    }

    typedef is_mpi_datatype<mpl::_1> use_array_optimization;

#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
    friend class archive::save_access;
protected:
#else
public:
#endif

    // default saving of primitives.
    template<class T>
    void save(const T & t)
    {
      save_impl(&t, get_mpi_datatype<T>(t), 1);
    }

    template<class CharType>
    void save(const std::basic_string<CharType> &s)
    {
      unsigned int l = static_cast<unsigned int>(s.size());
      save(l);
      if (l)
        save_impl(s.data(),get_mpi_datatype(CharType()),s.size());
    }

private:

    void save_impl(void const * p, MPI_Datatype t, int l)
    {
      // allocate enough memory
      int memory_needed;
      BOOST_MPI_CHECK_RESULT(MPI_Pack_size,(l,t,comm,&memory_needed));

      int position = buffer_.size();
      buffer_.resize(position + memory_needed);

      // pack the data into the buffer
      BOOST_MPI_CHECK_RESULT(MPI_Pack,
      (const_cast<void*>(p), l, t, boost::serialization::detail::get_data(buffer_), buffer_.size(), &position, comm));
      // reduce the buffer size if needed
      BOOST_ASSERT(std::size_t(position) <= buffer_.size());
      if (std::size_t(position) < buffer_.size())
          buffer_.resize(position);
    }

  buffer_type& buffer_;
  mutable std::size_t size_;
  MPI_Comm comm;
};

} } // end namespace boost::mpi

#endif // BOOST_MPI_PACKED_OPRIMITIVE_HPP


code:
//  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
//  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_TT_IS_INTEGRAL_HPP_INCLUDED
#define BOOST_TT_IS_INTEGRAL_HPP_INCLUDED

#include <boost/config.hpp>
#include <boost/type_traits/integral_constant.hpp>

namespace boost {

#if defined( __CODEGEARC__ )
   template <class T>
   struct is_integral : public integral_constant<bool, __is_integral(T)> {};
#else

template <class T> struct is_integral : public false_type {};
template <class T> struct is_integral<const T> : public is_integral<T> {};
template <class T> struct is_integral<volatile const T> : public is_integral<T>{};
template <class T> struct is_integral<volatile T> : public is_integral<T>{};

//* is a type T an [cv-qualified-] integral type described in the standard (3.9.1p3)
// as an extension we include long long, as this is likely to be added to the
// standard at a later date
template<> struct is_integral<unsigned char> : public true_type {};
template<> struct is_integral<unsigned short> : public true_type{};
template<> struct is_integral<unsigned int> : public true_type{};
template<> struct is_integral<unsigned long> : public true_type{};

template<> struct is_integral<signed char> : public true_type{};
template<> struct is_integral<short> : public true_type{};
template<> struct is_integral<int> : public true_type{};
template<> struct is_integral<long> : public true_type{};

template<> struct is_integral<char> : public true_type{};
template<> struct is_integral<bool> : public true_type{};

#ifndef BOOST_NO_INTRINSIC_WCHAR_T
// If the following line fails to compile and you're using the Intel
// compiler, see http://lists.boost.org/MailArchives/boost-users/msg06567.php,
// and define BOOST_NO_INTRINSIC_WCHAR_T on the command line.
template<> struct is_integral<wchar_t> : public true_type{};
#endif

// Same set of integral types as in boost/type_traits/integral_promotion.hpp.
// Please, keep in sync. -- Alexander Nasonov
#if (defined(BOOST_INTEL_CXX_VERSION) && defined(_MSC_VER) && (BOOST_INTEL_CXX_VERSION <= 600)) \
    || (defined(__BORLANDC__) && (__BORLANDC__ == 0x600) && (_MSC_VER < 1300))
template<> struct is_integral<unsigned __int8> : public true_type{};
template<> struct is_integral<unsigned __int16> : public true_type{};
template<> struct is_integral<unsigned __int32> : public true_type{};
template<> struct is_integral<__int8> : public true_type{};
template<> struct is_integral<__int16> : public true_type{};
template<> struct is_integral<__int32> : public true_type{};
#ifdef __BORLANDC__
template<> struct is_integral<unsigned __int64> : public true_type{};
template<> struct is_integral<__int64> : public true_type{};
#endif
#endif

# if defined(BOOST_HAS_LONG_LONG)
template<> struct is_integral< ::boost::ulong_long_type> : public true_type{};
template<> struct is_integral< ::boost::long_long_type> : public true_type{};
#elif defined(BOOST_HAS_MS_INT64)
template<> struct is_integral<unsigned __int64> : public true_type{};
template<> struct is_integral<__int64> : public true_type{};
#endif

#ifdef BOOST_HAS_INT128
template<> struct is_integral<boost::int128_type> : public true_type{};
template<> struct is_integral<boost::uint128_type> : public true_type{};
#endif
#ifndef BOOST_NO_CXX11_CHAR16_T
template<> struct is_integral<char16_t> : public true_type{};
#endif
#ifndef BOOST_NO_CXX11_CHAR32_T
template<> struct is_integral<char32_t> : public true_type{};
#endif

#endif  // non-CodeGear implementation

} // namespace boost

#endif // BOOST_TT_IS_INTEGRAL_HPP_INCLUDED


code:
//  (C) Copyright 2009-2011 Frederic Bron.
//
//  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_TT_HAS_LOGICAL_AND_HPP_INCLUDED
#define BOOST_TT_HAS_LOGICAL_AND_HPP_INCLUDED

#define BOOST_TT_TRAIT_NAME has_logical_and
#define BOOST_TT_TRAIT_OP &&
#define BOOST_TT_FORBIDDEN_IF\
   /* pointer with fundamental non convertible to bool */\
   (\
      (\
         ::boost::is_pointer< Lhs_noref >::value && \
         ( \
            ::boost::is_fundamental< Rhs_nocv >::value && \
            (!  ::boost::is_convertible< Rhs_nocv, bool >::value )\
          )\
      )||\
      (\
         ::boost::is_pointer< Rhs_noref >::value && \
         ( \
            ::boost::is_fundamental< Lhs_nocv >::value && \
            (!  ::boost::is_convertible< Lhs_nocv, bool >::value )\
         )\
      )\
      )

#include <boost/type_traits/detail/has_binary_operator.hpp>

#undef BOOST_TT_TRAIT_NAME
#undef BOOST_TT_TRAIT_OP
#undef BOOST_TT_FORBIDDEN_IF

#endif


code:
//---------------------------------------------------------------------------//
// Copyright (c) 2014 Roshan <thisisroshansmail@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_ALGORITHM_SET_INTERSECTION_HPP
#define BOOST_COMPUTE_ALGORITHM_SET_INTERSECTION_HPP

#include <iterator>

#include <boost/compute/algorithm/detail/compact.hpp>
#include <boost/compute/algorithm/detail/balanced_path.hpp>
#include <boost/compute/algorithm/exclusive_scan.hpp>
#include <boost/compute/algorithm/fill_n.hpp>
#include <boost/compute/container/vector.hpp>
#include <boost/compute/detail/iterator_range_size.hpp>
#include <boost/compute/detail/meta_kernel.hpp>
#include <boost/compute/system.hpp>

namespace boost {
namespace compute {
namespace detail {

///
/// \brief Serial set intersection kernel class
///
/// Subclass of meta_kernel to perform serial set intersection after tiling
///
class serial_set_intersection_kernel : meta_kernel
{
public:
    unsigned int tile_size;

    serial_set_intersection_kernel() : meta_kernel("set_intersection")
    {
        tile_size = 4;
    }

    template<class InputIterator1, class InputIterator2,
             class InputIterator3, class InputIterator4,
             class OutputIterator1, class OutputIterator2>
    void set_range(InputIterator1 first1,
                    InputIterator2 first2,
                    InputIterator3 tile_first1,
                    InputIterator3 tile_last1,
                    InputIterator4 tile_first2,
                    OutputIterator1 result,
                    OutputIterator2 counts)
    {
        m_count = iterator_range_size(tile_first1, tile_last1) - 1;

        *this <<
        "uint i = get_global_id(0);\n" <<
        "uint start1 = " << tile_first1[expr<uint_>("i")] << ";\n" <<
        "uint end1 = " << tile_first1[expr<uint_>("i+1")] << ";\n" <<
        "uint start2 = " << tile_first2[expr<uint_>("i")] << ";\n" <<
        "uint end2 = " << tile_first2[expr<uint_>("i+1")] << ";\n" <<
        "uint index = i*" << tile_size << ";\n" <<
        "uint count = 0;\n" <<
        "while(start1<end1 && start2<end2)\n" <<
        "{\n" <<
        "   if(" << first1[expr<uint_>("start1")] << " == " <<
                    first2[expr<uint_>("start2")] << ")\n" <<
        "   {\n" <<
                result[expr<uint_>("index")] <<
                    " = " << first1[expr<uint_>("start1")] << ";\n" <<
        "       index++; count++;\n" <<
        "       start1++; start2++;\n" <<
        "   }\n" <<
        "   else if(" << first1[expr<uint_>("start1")] << " < " <<
                        first2[expr<uint_>("start2")] << ")\n" <<
        "       start1++;\n" <<
        "   else start2++;\n" <<
        "}\n" <<
        counts[expr<uint_>("i")] << " = count;\n";
    }

    event exec(command_queue &queue)
    {
        if(m_count == 0) {
            return event();
        }

        return exec_1d(queue, 0, m_count);
    }

private:
    size_t m_count;
};

} //end detail namespace

///
/// \brief Set intersection algorithm
///
/// Finds the intersection of the sorted range [first1, last1) with the sorted
/// range [first2, last2) and stores it in range starting at result
/// \return Iterator pointing to end of intersection
///
/// \param first1 Iterator pointing to start of first set
/// \param last1 Iterator pointing to end of first set
/// \param first2 Iterator pointing to start of second set
/// \param last2 Iterator pointing to end of second set
/// \param result Iterator pointing to start of range in which the intersection
/// will be stored
/// \param queue Queue on which to execute
///
template<class InputIterator1, class InputIterator2, class OutputIterator>
inline OutputIterator set_intersection(InputIterator1 first1,
                                       InputIterator1 last1,
                                       InputIterator2 first2,
                                       InputIterator2 last2,
                                       OutputIterator result,
                                       command_queue &queue = system::default_queue())
{
    typedef typename std::iterator_traits<InputIterator1>::value_type value_type;

    int tile_size = 1024;

    int count1 = detail::iterator_range_size(first1, last1);
    int count2 = detail::iterator_range_size(first2, last2);

    vector<uint_> tile_a((count1+count2+tile_size-1)/tile_size+1, queue.get_context());
    vector<uint_> tile_b((count1+count2+tile_size-1)/tile_size+1, queue.get_context());

    // Tile the sets
    detail::balanced_path_kernel tiling_kernel;
    tiling_kernel.tile_size = tile_size;
    tiling_kernel.set_range(first1, last1, first2, last2,
                            tile_a.begin()+1, tile_b.begin()+1);
    fill_n(tile_a.begin(), 1, 0, queue);
    fill_n(tile_b.begin(), 1, 0, queue);
    tiling_kernel.exec(queue);

    fill_n(tile_a.end()-1, 1, count1, queue);
    fill_n(tile_b.end()-1, 1, count2, queue);

    vector<value_type> temp_result(count1+count2, queue.get_context());
    vector<uint_> counts((count1+count2+tile_size-1)/tile_size + 1, queue.get_context());
    fill_n(counts.end()-1, 1, 0, queue);

    // Find individual intersections
    detail::serial_set_intersection_kernel intersection_kernel;
    intersection_kernel.tile_size = tile_size;
    intersection_kernel.set_range(first1, first2, tile_a.begin(), tile_a.end(),
                                  tile_b.begin(), temp_result.begin(), counts.begin());

    intersection_kernel.exec(queue);

    exclusive_scan(counts.begin(), counts.end(), counts.begin(), queue);

    // Compact the results
    detail::compact_kernel compact_kernel;
    compact_kernel.tile_size = tile_size;
    compact_kernel.set_range(temp_result.begin(), counts.begin(), counts.end(), result);

    compact_kernel.exec(queue);

    return result + (counts.end() - 1).read(queue);
}

} //end compute namespace
} //end boost namespace

#endif // BOOST_COMPUTE_ALGORITHM_SET_INTERSECTION_HPP


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

    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_CLEAR_10022005_1442)
#define FUSION_CLEAR_10022005_1442

#include <boost/fusion/support/config.hpp>
#include <boost/fusion/container/vector/vector_fwd.hpp>
#include <boost/fusion/container/list/list_fwd.hpp>
#include <boost/fusion/container/map/map_fwd.hpp>
#include <boost/fusion/container/set/set_fwd.hpp>
#include <boost/fusion/container/deque/deque_fwd.hpp>

namespace boost { namespace fusion
{
    struct cons_tag;
    struct map_tag;
    struct set_tag;
    struct vector_tag;
    struct deque_tag;

    namespace detail
    {
        template <typename Tag>
        struct clear;

        template <>
        struct clear<cons_tag> : mpl::identity<list<> > {};

        template <>
        struct clear<map_tag> : mpl::identity<map<> > {};

        template <>
        struct clear<set_tag> : mpl::identity<set<> > {};

        template <>
        struct clear<vector_tag> : mpl::identity<vector<> > {};

        template <>
        struct clear<deque_tag> : mpl::identity<deque<> > {};
    }
}}

#endif


code:
/*
Copyright Rene Rivera 2011-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_ARCHITECTURE_PYRAMID_H
#define BOOST_PREDEF_ARCHITECTURE_PYRAMID_H

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

/*`
[heading `BOOST_ARCH_PYRAMID`]

Pyramid 9810 architecture.

[table
    [[__predef_symbol__] [__predef_version__]]

    [[`pyr`] [__predef_detection__]]
    ]
 */

#define BOOST_ARCH_PYRAMID BOOST_VERSION_NUMBER_NOT_AVAILABLE

#if defined(pyr)
#   undef BOOST_ARCH_PYRAMID
#   define BOOST_ARCH_PYRAMID BOOST_VERSION_NUMBER_AVAILABLE
#endif

#if BOOST_ARCH_PYRAMID
#   define BOOST_ARCH_PYRAMID_AVAILABLE
#endif

#define BOOST_ARCH_PYRAMID_NAME "Pyramid 9810"

#endif

#include <boost/predef/detail/test.h>
BOOST_PREDEF_DECLARE_TEST(BOOST_ARCH_PYRAMID,BOOST_ARCH_PYRAMID_NAME)