3rdparty/boost/boost/fusion/container/vector/detail/cpp03/preprocessed/vector10.hpp

   1 /*=============================================================================
   2     Copyright (c) 2001-2011 Joel de Guzman
   3
   4     Distributed under the Boost Software License, Version 1.0. (See accompanying
   5     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   6
   7     This is an auto-generated file. Do not edit!
   8 ==============================================================================*/
   9 namespace boost { namespace fusion
  10 {
  11     struct vector_tag;
  12     struct fusion_sequence_tag;
  13     struct random_access_traversal_tag;
  14     template <typename T0>
  15     struct vector_data1
  16     {
  17         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
  18         vector_data1()
  19             : m0() {}
  20 # if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
  21         template <typename U0>
  22 # if !defined(BOOST_CLANG)
  23         BOOST_CXX14_CONSTEXPR
  24 # endif
  25         BOOST_FUSION_GPU_ENABLED
  26         vector_data1(U0 && arg0
  27           , typename boost::enable_if<is_convertible<U0, T0> >::type* = 0
  28         )
  29             : m0(std::forward<U0>( arg0)) {}
  30         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
  31         vector_data1(
  32             vector_data1&& other)
  33             : m0(std::forward<T0>( other.m0)) {}
  34 # endif
  35 # if !defined(BOOST_CLANG)
  36     BOOST_CONSTEXPR
  37 # endif
  38         BOOST_FUSION_GPU_ENABLED
  39         vector_data1(
  40             typename detail::call_param<T0 >::type arg0)
  41             : m0(arg0) {}
  42         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
  43         vector_data1(
  44             vector_data1 const& other)
  45             : m0(other.m0) {}
  46         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
  47         vector_data1&
  48         operator=(vector_data1 const& vec)
  49         {
  50             this->m0 = vec.m0;
  51             return *this;
  52         }
  53         template <typename Sequence>
  54 # if !defined(BOOST_CLANG)
  55     BOOST_CXX14_CONSTEXPR
  56 # endif
  57         BOOST_FUSION_GPU_ENABLED
  58         static vector_data1
  59         init_from_sequence(Sequence const& seq)
  60         {
  61             typedef typename result_of::begin<Sequence const>::type I0;
  62             I0 i0 = fusion::begin(seq);
  63
  64             return vector_data1(*i0);
  65         }
  66         template <typename Sequence>
  67 # if !defined(BOOST_CLANG)
  68     BOOST_CXX14_CONSTEXPR
  69 # endif
  70         BOOST_FUSION_GPU_ENABLED
  71         static vector_data1
  72         init_from_sequence(Sequence& seq)
  73         {
  74             typedef typename result_of::begin<Sequence>::type I0;
  75             I0 i0 = fusion::begin(seq);
  76
  77             return vector_data1(*i0);
  78         }
  79         T0 m0;
  80     };
  81     template <typename T0>
  82     struct vector1
  83       : vector_data1<T0>
  84       , sequence_base<vector1<T0> >
  85     {
  86         typedef vector1<T0> this_type;
  87         typedef vector_data1<T0> base_type;
  88         typedef mpl::vector1<T0> types;
  89         typedef vector_tag fusion_tag;
  90         typedef fusion_sequence_tag tag;
  91         typedef mpl::false_ is_view;
  92         typedef random_access_traversal_tag category;
  93         typedef mpl::int_<1> size;
  94         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
  95         vector1() {}
  96 # if !defined(BOOST_CLANG)
  97     BOOST_CONSTEXPR
  98 # endif
  99         BOOST_FUSION_GPU_ENABLED
 100         explicit
 101         vector1(
 102             typename detail::call_param<T0 >::type arg0)
 103             : base_type(arg0) {}
 104 # if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
 105         template <typename U0>
 106 # if !defined(BOOST_CLANG)
 107         BOOST_CXX14_CONSTEXPR
 108 # endif
 109         BOOST_FUSION_GPU_ENABLED
 110         explicit
 111         vector1(U0&& _0
 112           , typename boost::enable_if<is_convertible<U0, T0> >::type* = 0
 113           )
 114          : base_type(std::forward<U0>( _0)) {}
 115         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 116         vector1(vector1&& rhs)
 117             : base_type(std::forward<base_type>(rhs)) {}
 118         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 119         vector1(vector1 const& rhs)
 120             : base_type(static_cast<base_type const&>(rhs)) {}
 121         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 122         vector1&
 123         operator=(vector1 const& vec)
 124         {
 125             base_type::operator=(vec);
 126             return *this;
 127         }
 128         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 129         vector1&
 130         operator=(vector1&& vec)
 131         {
 132             this->m0 = std::forward< T0>(vec.m0);
 133             return *this;
 134         }
 135 # endif
 136         template <typename U0>
 137 # if !defined(BOOST_CLANG)
 138     BOOST_CXX14_CONSTEXPR
 139 # endif
 140         BOOST_FUSION_GPU_ENABLED
 141         vector1(
 142             vector1<U0> const& vec)
 143             : base_type(vec.m0) {}
 144         template <typename Sequence>
 145 # if !defined(BOOST_CLANG)
 146         BOOST_CXX14_CONSTEXPR
 147 # endif
 148         BOOST_FUSION_GPU_ENABLED
 149         vector1(
 150             Sequence const& seq
 151           , typename boost::enable_if<traits::is_sequence<Sequence> >::type* = 0
 152           , typename boost::disable_if<is_convertible<Sequence, T0> >::type* = 0
 153             )
 154             : base_type(base_type::init_from_sequence(seq)) {}
 155         template <typename Sequence>
 156 # if !defined(BOOST_CLANG)
 157         BOOST_CXX14_CONSTEXPR
 158 # endif
 159         BOOST_FUSION_GPU_ENABLED
 160         vector1(
 161             Sequence& seq
 162           , typename boost::enable_if<traits::is_sequence<Sequence> >::type* = 0
 163           , typename boost::disable_if<is_convertible<Sequence, T0> >::type* = 0
 164             )
 165             : base_type(base_type::init_from_sequence(seq)) {}
 166         template <typename U0>
 167         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 168         vector1&
 169         operator=(vector1<U0> const& vec)
 170         {
 171             this->m0 = vec.m0;
 172             return *this;
 173         }
 174         template <typename Sequence>
 175         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 176         typename boost::disable_if<is_convertible<Sequence, T0>, this_type&>::type
 177         operator=(Sequence const& seq)
 178         {
 179             typedef typename result_of::begin<Sequence const>::type I0;
 180             I0 i0 = fusion::begin(seq);
 181
 182             this->m0 = *i0;
 183             return *this;
 184         }
 185         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T0>::type at_impl(mpl::int_<0>) { return this->m0; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T0>::type>::type at_impl(mpl::int_<0>) const { return this->m0; }
 186         template<typename I>
 187         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 188         typename add_reference<typename mpl::at<types, I>::type>::type
 189         at_impl(I)
 190         {
 191             return this->at_impl(mpl::int_<I::value>());
 192         }
 193         template<typename I>
 194         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 195         typename add_reference<typename add_const<typename mpl::at<types, I>::type>::type>::type
 196         at_impl(I) const
 197         {
 198             return this->at_impl(mpl::int_<I::value>());
 199         }
 200     };
 201     template <typename T0 , typename T1>
 202     struct vector_data2
 203     {
 204         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 205         vector_data2()
 206             : m0() , m1() {}
 207 # if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
 208         template <typename U0 , typename U1>
 209 # if !defined(BOOST_CLANG)
 210         BOOST_CXX14_CONSTEXPR
 211 # endif
 212         BOOST_FUSION_GPU_ENABLED
 213         vector_data2(U0 && arg0 , U1 && arg1
 214           , typename boost::enable_if<is_convertible<U0, T0> >::type* = 0
 215         )
 216             : m0(std::forward<U0>( arg0)) , m1(std::forward<U1>( arg1)) {}
 217         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 218         vector_data2(
 219             vector_data2&& other)
 220             : m0(std::forward<T0>( other.m0)) , m1(std::forward<T1>( other.m1)) {}
 221 # endif
 222 # if !defined(BOOST_CLANG)
 223     BOOST_CONSTEXPR
 224 # endif
 225         BOOST_FUSION_GPU_ENABLED
 226         vector_data2(
 227             typename detail::call_param<T0 >::type arg0 , typename detail::call_param<T1 >::type arg1)
 228             : m0(arg0) , m1(arg1) {}
 229         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 230         vector_data2(
 231             vector_data2 const& other)
 232             : m0(other.m0) , m1(other.m1) {}
 233         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 234         vector_data2&
 235         operator=(vector_data2 const& vec)
 236         {
 237             this->m0 = vec.m0; this->m1 = vec.m1;
 238             return *this;
 239         }
 240         template <typename Sequence>
 241 # if !defined(BOOST_CLANG)
 242     BOOST_CXX14_CONSTEXPR
 243 # endif
 244         BOOST_FUSION_GPU_ENABLED
 245         static vector_data2
 246         init_from_sequence(Sequence const& seq)
 247         {
 248             typedef typename result_of::begin<Sequence const>::type I0;
 249             I0 i0 = fusion::begin(seq);
 250             typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0);
 251             return vector_data2(*i0 , *i1);
 252         }
 253         template <typename Sequence>
 254 # if !defined(BOOST_CLANG)
 255     BOOST_CXX14_CONSTEXPR
 256 # endif
 257         BOOST_FUSION_GPU_ENABLED
 258         static vector_data2
 259         init_from_sequence(Sequence& seq)
 260         {
 261             typedef typename result_of::begin<Sequence>::type I0;
 262             I0 i0 = fusion::begin(seq);
 263             typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0);
 264             return vector_data2(*i0 , *i1);
 265         }
 266         T0 m0; T1 m1;
 267     };
 268     template <typename T0 , typename T1>
 269     struct vector2
 270       : vector_data2<T0 , T1>
 271       , sequence_base<vector2<T0 , T1> >
 272     {
 273         typedef vector2<T0 , T1> this_type;
 274         typedef vector_data2<T0 , T1> base_type;
 275         typedef mpl::vector2<T0 , T1> types;
 276         typedef vector_tag fusion_tag;
 277         typedef fusion_sequence_tag tag;
 278         typedef mpl::false_ is_view;
 279         typedef random_access_traversal_tag category;
 280         typedef mpl::int_<2> size;
 281         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 282         vector2() {}
 283 # if !defined(BOOST_CLANG)
 284     BOOST_CONSTEXPR
 285 # endif
 286         BOOST_FUSION_GPU_ENABLED
 287         vector2(
 288             typename detail::call_param<T0 >::type arg0 , typename detail::call_param<T1 >::type arg1)
 289             : base_type(arg0 , arg1) {}
 290 # if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
 291         template <typename U0 , typename U1>
 292 # if !defined(BOOST_CLANG)
 293         BOOST_CXX14_CONSTEXPR
 294 # endif
 295         BOOST_FUSION_GPU_ENABLED
 296         vector2(U0 && arg0 , U1 && arg1)
 297             : base_type(std::forward<U0>( arg0) , std::forward<U1>( arg1)) {}
 298         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 299         vector2(vector2&& rhs)
 300             : base_type(std::forward<base_type>(rhs)) {}
 301         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 302         vector2(vector2 const& rhs)
 303             : base_type(static_cast<base_type const&>(rhs)) {}
 304         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 305         vector2&
 306         operator=(vector2 const& vec)
 307         {
 308             base_type::operator=(vec);
 309             return *this;
 310         }
 311         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 312         vector2&
 313         operator=(vector2&& vec)
 314         {
 315             this->m0 = std::forward< T0>(vec.m0); this->m1 = std::forward< T1>(vec.m1);
 316             return *this;
 317         }
 318 # endif
 319         template <typename U0 , typename U1>
 320 # if !defined(BOOST_CLANG)
 321     BOOST_CXX14_CONSTEXPR
 322 # endif
 323         BOOST_FUSION_GPU_ENABLED
 324         vector2(
 325             vector2<U0 , U1> const& vec)
 326             : base_type(vec.m0 , vec.m1) {}
 327         template <typename Sequence>
 328 # if !defined(BOOST_CLANG)
 329         BOOST_CXX14_CONSTEXPR
 330 # endif
 331         BOOST_FUSION_GPU_ENABLED
 332         vector2(
 333             Sequence const& seq
 334           , typename boost::enable_if<traits::is_sequence<Sequence> >::type* = 0
 335             )
 336             : base_type(base_type::init_from_sequence(seq)) {}
 337         template <typename Sequence>
 338 # if !defined(BOOST_CLANG)
 339         BOOST_CXX14_CONSTEXPR
 340 # endif
 341         BOOST_FUSION_GPU_ENABLED
 342         vector2(
 343             Sequence& seq
 344           , typename boost::enable_if<traits::is_sequence<Sequence> >::type* = 0
 345             )
 346             : base_type(base_type::init_from_sequence(seq)) {}
 347         template <typename U0 , typename U1>
 348         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 349         vector2&
 350         operator=(vector2<U0 , U1> const& vec)
 351         {
 352             this->m0 = vec.m0; this->m1 = vec.m1;
 353             return *this;
 354         }
 355         template <typename Sequence>
 356         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 357         typename boost::disable_if<is_convertible<Sequence, T0>, this_type&>::type
 358         operator=(Sequence const& seq)
 359         {
 360             typedef typename result_of::begin<Sequence const>::type I0;
 361             I0 i0 = fusion::begin(seq);
 362             typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0);
 363             this->m0 = *i0; this->m1 = *i1;
 364             return *this;
 365         }
 366         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T0>::type at_impl(mpl::int_<0>) { return this->m0; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T0>::type>::type at_impl(mpl::int_<0>) const { return this->m0; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T1>::type at_impl(mpl::int_<1>) { return this->m1; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T1>::type>::type at_impl(mpl::int_<1>) const { return this->m1; }
 367         template<typename I>
 368         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 369         typename add_reference<typename mpl::at<types, I>::type>::type
 370         at_impl(I)
 371         {
 372             return this->at_impl(mpl::int_<I::value>());
 373         }
 374         template<typename I>
 375         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 376         typename add_reference<typename add_const<typename mpl::at<types, I>::type>::type>::type
 377         at_impl(I) const
 378         {
 379             return this->at_impl(mpl::int_<I::value>());
 380         }
 381     };
 382     template <typename T0 , typename T1 , typename T2>
 383     struct vector_data3
 384     {
 385         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 386         vector_data3()
 387             : m0() , m1() , m2() {}
 388 # if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
 389         template <typename U0 , typename U1 , typename U2>
 390 # if !defined(BOOST_CLANG)
 391         BOOST_CXX14_CONSTEXPR
 392 # endif
 393         BOOST_FUSION_GPU_ENABLED
 394         vector_data3(U0 && arg0 , U1 && arg1 , U2 && arg2
 395           , typename boost::enable_if<is_convertible<U0, T0> >::type* = 0
 396         )
 397             : m0(std::forward<U0>( arg0)) , m1(std::forward<U1>( arg1)) , m2(std::forward<U2>( arg2)) {}
 398         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 399         vector_data3(
 400             vector_data3&& other)
 401             : m0(std::forward<T0>( other.m0)) , m1(std::forward<T1>( other.m1)) , m2(std::forward<T2>( other.m2)) {}
 402 # endif
 403 # if !defined(BOOST_CLANG)
 404     BOOST_CONSTEXPR
 405 # endif
 406         BOOST_FUSION_GPU_ENABLED
 407         vector_data3(
 408             typename detail::call_param<T0 >::type arg0 , typename detail::call_param<T1 >::type arg1 , typename detail::call_param<T2 >::type arg2)
 409             : m0(arg0) , m1(arg1) , m2(arg2) {}
 410         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 411         vector_data3(
 412             vector_data3 const& other)
 413             : m0(other.m0) , m1(other.m1) , m2(other.m2) {}
 414         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 415         vector_data3&
 416         operator=(vector_data3 const& vec)
 417         {
 418             this->m0 = vec.m0; this->m1 = vec.m1; this->m2 = vec.m2;
 419             return *this;
 420         }
 421         template <typename Sequence>
 422 # if !defined(BOOST_CLANG)
 423     BOOST_CXX14_CONSTEXPR
 424 # endif
 425         BOOST_FUSION_GPU_ENABLED
 426         static vector_data3
 427         init_from_sequence(Sequence const& seq)
 428         {
 429             typedef typename result_of::begin<Sequence const>::type I0;
 430             I0 i0 = fusion::begin(seq);
 431             typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0); typedef typename result_of::next< I1>::type I2; I2 i2 = fusion::next(i1);
 432             return vector_data3(*i0 , *i1 , *i2);
 433         }
 434         template <typename Sequence>
 435 # if !defined(BOOST_CLANG)
 436     BOOST_CXX14_CONSTEXPR
 437 # endif
 438         BOOST_FUSION_GPU_ENABLED
 439         static vector_data3
 440         init_from_sequence(Sequence& seq)
 441         {
 442             typedef typename result_of::begin<Sequence>::type I0;
 443             I0 i0 = fusion::begin(seq);
 444             typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0); typedef typename result_of::next< I1>::type I2; I2 i2 = fusion::next(i1);
 445             return vector_data3(*i0 , *i1 , *i2);
 446         }
 447         T0 m0; T1 m1; T2 m2;
 448     };
 449     template <typename T0 , typename T1 , typename T2>
 450     struct vector3
 451       : vector_data3<T0 , T1 , T2>
 452       , sequence_base<vector3<T0 , T1 , T2> >
 453     {
 454         typedef vector3<T0 , T1 , T2> this_type;
 455         typedef vector_data3<T0 , T1 , T2> base_type;
 456         typedef mpl::vector3<T0 , T1 , T2> types;
 457         typedef vector_tag fusion_tag;
 458         typedef fusion_sequence_tag tag;
 459         typedef mpl::false_ is_view;
 460         typedef random_access_traversal_tag category;
 461         typedef mpl::int_<3> size;
 462         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 463         vector3() {}
 464 # if !defined(BOOST_CLANG)
 465     BOOST_CONSTEXPR
 466 # endif
 467         BOOST_FUSION_GPU_ENABLED
 468         vector3(
 469             typename detail::call_param<T0 >::type arg0 , typename detail::call_param<T1 >::type arg1 , typename detail::call_param<T2 >::type arg2)
 470             : base_type(arg0 , arg1 , arg2) {}
 471 # if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
 472         template <typename U0 , typename U1 , typename U2>
 473 # if !defined(BOOST_CLANG)
 474         BOOST_CXX14_CONSTEXPR
 475 # endif
 476         BOOST_FUSION_GPU_ENABLED
 477         vector3(U0 && arg0 , U1 && arg1 , U2 && arg2)
 478             : base_type(std::forward<U0>( arg0) , std::forward<U1>( arg1) , std::forward<U2>( arg2)) {}
 479         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 480         vector3(vector3&& rhs)
 481             : base_type(std::forward<base_type>(rhs)) {}
 482         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 483         vector3(vector3 const& rhs)
 484             : base_type(static_cast<base_type const&>(rhs)) {}
 485         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 486         vector3&
 487         operator=(vector3 const& vec)
 488         {
 489             base_type::operator=(vec);
 490             return *this;
 491         }
 492         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 493         vector3&
 494         operator=(vector3&& vec)
 495         {
 496             this->m0 = std::forward< T0>(vec.m0); this->m1 = std::forward< T1>(vec.m1); this->m2 = std::forward< T2>(vec.m2);
 497             return *this;
 498         }
 499 # endif
 500         template <typename U0 , typename U1 , typename U2>
 501 # if !defined(BOOST_CLANG)
 502     BOOST_CXX14_CONSTEXPR
 503 # endif
 504         BOOST_FUSION_GPU_ENABLED
 505         vector3(
 506             vector3<U0 , U1 , U2> const& vec)
 507             : base_type(vec.m0 , vec.m1 , vec.m2) {}
 508         template <typename Sequence>
 509 # if !defined(BOOST_CLANG)
 510         BOOST_CXX14_CONSTEXPR
 511 # endif
 512         BOOST_FUSION_GPU_ENABLED
 513         vector3(
 514             Sequence const& seq
 515           , typename boost::enable_if<traits::is_sequence<Sequence> >::type* = 0
 516             )
 517             : base_type(base_type::init_from_sequence(seq)) {}
 518         template <typename Sequence>
 519 # if !defined(BOOST_CLANG)
 520         BOOST_CXX14_CONSTEXPR
 521 # endif
 522         BOOST_FUSION_GPU_ENABLED
 523         vector3(
 524             Sequence& seq
 525           , typename boost::enable_if<traits::is_sequence<Sequence> >::type* = 0
 526             )
 527             : base_type(base_type::init_from_sequence(seq)) {}
 528         template <typename U0 , typename U1 , typename U2>
 529         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 530         vector3&
 531         operator=(vector3<U0 , U1 , U2> const& vec)
 532         {
 533             this->m0 = vec.m0; this->m1 = vec.m1; this->m2 = vec.m2;
 534             return *this;
 535         }
 536         template <typename Sequence>
 537         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 538         typename boost::disable_if<is_convertible<Sequence, T0>, this_type&>::type
 539         operator=(Sequence const& seq)
 540         {
 541             typedef typename result_of::begin<Sequence const>::type I0;
 542             I0 i0 = fusion::begin(seq);
 543             typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0); typedef typename result_of::next< I1>::type I2; I2 i2 = fusion::next(i1);
 544             this->m0 = *i0; this->m1 = *i1; this->m2 = *i2;
 545             return *this;
 546         }
 547         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T0>::type at_impl(mpl::int_<0>) { return this->m0; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T0>::type>::type at_impl(mpl::int_<0>) const { return this->m0; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T1>::type at_impl(mpl::int_<1>) { return this->m1; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T1>::type>::type at_impl(mpl::int_<1>) const { return this->m1; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T2>::type at_impl(mpl::int_<2>) { return this->m2; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T2>::type>::type at_impl(mpl::int_<2>) const { return this->m2; }
 548         template<typename I>
 549         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 550         typename add_reference<typename mpl::at<types, I>::type>::type
 551         at_impl(I)
 552         {
 553             return this->at_impl(mpl::int_<I::value>());
 554         }
 555         template<typename I>
 556         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 557         typename add_reference<typename add_const<typename mpl::at<types, I>::type>::type>::type
 558         at_impl(I) const
 559         {
 560             return this->at_impl(mpl::int_<I::value>());
 561         }
 562     };
 563     template <typename T0 , typename T1 , typename T2 , typename T3>
 564     struct vector_data4
 565     {
 566         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 567         vector_data4()
 568             : m0() , m1() , m2() , m3() {}
 569 # if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
 570         template <typename U0 , typename U1 , typename U2 , typename U3>
 571 # if !defined(BOOST_CLANG)
 572         BOOST_CXX14_CONSTEXPR
 573 # endif
 574         BOOST_FUSION_GPU_ENABLED
 575         vector_data4(U0 && arg0 , U1 && arg1 , U2 && arg2 , U3 && arg3
 576           , typename boost::enable_if<is_convertible<U0, T0> >::type* = 0
 577         )
 578             : m0(std::forward<U0>( arg0)) , m1(std::forward<U1>( arg1)) , m2(std::forward<U2>( arg2)) , m3(std::forward<U3>( arg3)) {}
 579         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 580         vector_data4(
 581             vector_data4&& other)
 582             : m0(std::forward<T0>( other.m0)) , m1(std::forward<T1>( other.m1)) , m2(std::forward<T2>( other.m2)) , m3(std::forward<T3>( other.m3)) {}
 583 # endif
 584 # if !defined(BOOST_CLANG)
 585     BOOST_CONSTEXPR
 586 # endif
 587         BOOST_FUSION_GPU_ENABLED
 588         vector_data4(
 589             typename detail::call_param<T0 >::type arg0 , typename detail::call_param<T1 >::type arg1 , typename detail::call_param<T2 >::type arg2 , typename detail::call_param<T3 >::type arg3)
 590             : m0(arg0) , m1(arg1) , m2(arg2) , m3(arg3) {}
 591         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 592         vector_data4(
 593             vector_data4 const& other)
 594             : m0(other.m0) , m1(other.m1) , m2(other.m2) , m3(other.m3) {}
 595         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 596         vector_data4&
 597         operator=(vector_data4 const& vec)
 598         {
 599             this->m0 = vec.m0; this->m1 = vec.m1; this->m2 = vec.m2; this->m3 = vec.m3;
 600             return *this;
 601         }
 602         template <typename Sequence>
 603 # if !defined(BOOST_CLANG)
 604     BOOST_CXX14_CONSTEXPR
 605 # endif
 606         BOOST_FUSION_GPU_ENABLED
 607         static vector_data4
 608         init_from_sequence(Sequence const& seq)
 609         {
 610             typedef typename result_of::begin<Sequence const>::type I0;
 611             I0 i0 = fusion::begin(seq);
 612             typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0); typedef typename result_of::next< I1>::type I2; I2 i2 = fusion::next(i1); typedef typename result_of::next< I2>::type I3; I3 i3 = fusion::next(i2);
 613             return vector_data4(*i0 , *i1 , *i2 , *i3);
 614         }
 615         template <typename Sequence>
 616 # if !defined(BOOST_CLANG)
 617     BOOST_CXX14_CONSTEXPR
 618 # endif
 619         BOOST_FUSION_GPU_ENABLED
 620         static vector_data4
 621         init_from_sequence(Sequence& seq)
 622         {
 623             typedef typename result_of::begin<Sequence>::type I0;
 624             I0 i0 = fusion::begin(seq);
 625             typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0); typedef typename result_of::next< I1>::type I2; I2 i2 = fusion::next(i1); typedef typename result_of::next< I2>::type I3; I3 i3 = fusion::next(i2);
 626             return vector_data4(*i0 , *i1 , *i2 , *i3);
 627         }
 628         T0 m0; T1 m1; T2 m2; T3 m3;
 629     };
 630     template <typename T0 , typename T1 , typename T2 , typename T3>
 631     struct vector4
 632       : vector_data4<T0 , T1 , T2 , T3>
 633       , sequence_base<vector4<T0 , T1 , T2 , T3> >
 634     {
 635         typedef vector4<T0 , T1 , T2 , T3> this_type;
 636         typedef vector_data4<T0 , T1 , T2 , T3> base_type;
 637         typedef mpl::vector4<T0 , T1 , T2 , T3> types;
 638         typedef vector_tag fusion_tag;
 639         typedef fusion_sequence_tag tag;
 640         typedef mpl::false_ is_view;
 641         typedef random_access_traversal_tag category;
 642         typedef mpl::int_<4> size;
 643         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 644         vector4() {}
 645 # if !defined(BOOST_CLANG)
 646     BOOST_CONSTEXPR
 647 # endif
 648         BOOST_FUSION_GPU_ENABLED
 649         vector4(
 650             typename detail::call_param<T0 >::type arg0 , typename detail::call_param<T1 >::type arg1 , typename detail::call_param<T2 >::type arg2 , typename detail::call_param<T3 >::type arg3)
 651             : base_type(arg0 , arg1 , arg2 , arg3) {}
 652 # if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
 653         template <typename U0 , typename U1 , typename U2 , typename U3>
 654 # if !defined(BOOST_CLANG)
 655         BOOST_CXX14_CONSTEXPR
 656 # endif
 657         BOOST_FUSION_GPU_ENABLED
 658         vector4(U0 && arg0 , U1 && arg1 , U2 && arg2 , U3 && arg3)
 659             : base_type(std::forward<U0>( arg0) , std::forward<U1>( arg1) , std::forward<U2>( arg2) , std::forward<U3>( arg3)) {}
 660         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 661         vector4(vector4&& rhs)
 662             : base_type(std::forward<base_type>(rhs)) {}
 663         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 664         vector4(vector4 const& rhs)
 665             : base_type(static_cast<base_type const&>(rhs)) {}
 666         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 667         vector4&
 668         operator=(vector4 const& vec)
 669         {
 670             base_type::operator=(vec);
 671             return *this;
 672         }
 673         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 674         vector4&
 675         operator=(vector4&& vec)
 676         {
 677             this->m0 = std::forward< T0>(vec.m0); this->m1 = std::forward< T1>(vec.m1); this->m2 = std::forward< T2>(vec.m2); this->m3 = std::forward< T3>(vec.m3);
 678             return *this;
 679         }
 680 # endif
 681         template <typename U0 , typename U1 , typename U2 , typename U3>
 682 # if !defined(BOOST_CLANG)
 683     BOOST_CXX14_CONSTEXPR
 684 # endif
 685         BOOST_FUSION_GPU_ENABLED
 686         vector4(
 687             vector4<U0 , U1 , U2 , U3> const& vec)
 688             : base_type(vec.m0 , vec.m1 , vec.m2 , vec.m3) {}
 689         template <typename Sequence>
 690 # if !defined(BOOST_CLANG)
 691         BOOST_CXX14_CONSTEXPR
 692 # endif
 693         BOOST_FUSION_GPU_ENABLED
 694         vector4(
 695             Sequence const& seq
 696           , typename boost::enable_if<traits::is_sequence<Sequence> >::type* = 0
 697             )
 698             : base_type(base_type::init_from_sequence(seq)) {}
 699         template <typename Sequence>
 700 # if !defined(BOOST_CLANG)
 701         BOOST_CXX14_CONSTEXPR
 702 # endif
 703         BOOST_FUSION_GPU_ENABLED
 704         vector4(
 705             Sequence& seq
 706           , typename boost::enable_if<traits::is_sequence<Sequence> >::type* = 0
 707             )
 708             : base_type(base_type::init_from_sequence(seq)) {}
 709         template <typename U0 , typename U1 , typename U2 , typename U3>
 710         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 711         vector4&
 712         operator=(vector4<U0 , U1 , U2 , U3> const& vec)
 713         {
 714             this->m0 = vec.m0; this->m1 = vec.m1; this->m2 = vec.m2; this->m3 = vec.m3;
 715             return *this;
 716         }
 717         template <typename Sequence>
 718         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 719         typename boost::disable_if<is_convertible<Sequence, T0>, this_type&>::type
 720         operator=(Sequence const& seq)
 721         {
 722             typedef typename result_of::begin<Sequence const>::type I0;
 723             I0 i0 = fusion::begin(seq);
 724             typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0); typedef typename result_of::next< I1>::type I2; I2 i2 = fusion::next(i1); typedef typename result_of::next< I2>::type I3; I3 i3 = fusion::next(i2);
 725             this->m0 = *i0; this->m1 = *i1; this->m2 = *i2; this->m3 = *i3;
 726             return *this;
 727         }
 728         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T0>::type at_impl(mpl::int_<0>) { return this->m0; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T0>::type>::type at_impl(mpl::int_<0>) const { return this->m0; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T1>::type at_impl(mpl::int_<1>) { return this->m1; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T1>::type>::type at_impl(mpl::int_<1>) const { return this->m1; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T2>::type at_impl(mpl::int_<2>) { return this->m2; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T2>::type>::type at_impl(mpl::int_<2>) const { return this->m2; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T3>::type at_impl(mpl::int_<3>) { return this->m3; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T3>::type>::type at_impl(mpl::int_<3>) const { return this->m3; }
 729         template<typename I>
 730         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 731         typename add_reference<typename mpl::at<types, I>::type>::type
 732         at_impl(I)
 733         {
 734             return this->at_impl(mpl::int_<I::value>());
 735         }
 736         template<typename I>
 737         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 738         typename add_reference<typename add_const<typename mpl::at<types, I>::type>::type>::type
 739         at_impl(I) const
 740         {
 741             return this->at_impl(mpl::int_<I::value>());
 742         }
 743     };
 744     template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
 745     struct vector_data5
 746     {
 747         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 748         vector_data5()
 749             : m0() , m1() , m2() , m3() , m4() {}
 750 # if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
 751         template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4>
 752 # if !defined(BOOST_CLANG)
 753         BOOST_CXX14_CONSTEXPR
 754 # endif
 755         BOOST_FUSION_GPU_ENABLED
 756         vector_data5(U0 && arg0 , U1 && arg1 , U2 && arg2 , U3 && arg3 , U4 && arg4
 757           , typename boost::enable_if<is_convertible<U0, T0> >::type* = 0
 758         )
 759             : m0(std::forward<U0>( arg0)) , m1(std::forward<U1>( arg1)) , m2(std::forward<U2>( arg2)) , m3(std::forward<U3>( arg3)) , m4(std::forward<U4>( arg4)) {}
 760         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 761         vector_data5(
 762             vector_data5&& other)
 763             : m0(std::forward<T0>( other.m0)) , m1(std::forward<T1>( other.m1)) , m2(std::forward<T2>( other.m2)) , m3(std::forward<T3>( other.m3)) , m4(std::forward<T4>( other.m4)) {}
 764 # endif
 765 # if !defined(BOOST_CLANG)
 766     BOOST_CONSTEXPR
 767 # endif
 768         BOOST_FUSION_GPU_ENABLED
 769         vector_data5(
 770             typename detail::call_param<T0 >::type arg0 , typename detail::call_param<T1 >::type arg1 , typename detail::call_param<T2 >::type arg2 , typename detail::call_param<T3 >::type arg3 , typename detail::call_param<T4 >::type arg4)
 771             : m0(arg0) , m1(arg1) , m2(arg2) , m3(arg3) , m4(arg4) {}
 772         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 773         vector_data5(
 774             vector_data5 const& other)
 775             : m0(other.m0) , m1(other.m1) , m2(other.m2) , m3(other.m3) , m4(other.m4) {}
 776         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 777         vector_data5&
 778         operator=(vector_data5 const& vec)
 779         {
 780             this->m0 = vec.m0; this->m1 = vec.m1; this->m2 = vec.m2; this->m3 = vec.m3; this->m4 = vec.m4;
 781             return *this;
 782         }
 783         template <typename Sequence>
 784 # if !defined(BOOST_CLANG)
 785     BOOST_CXX14_CONSTEXPR
 786 # endif
 787         BOOST_FUSION_GPU_ENABLED
 788         static vector_data5
 789         init_from_sequence(Sequence const& seq)
 790         {
 791             typedef typename result_of::begin<Sequence const>::type I0;
 792             I0 i0 = fusion::begin(seq);
 793             typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0); typedef typename result_of::next< I1>::type I2; I2 i2 = fusion::next(i1); typedef typename result_of::next< I2>::type I3; I3 i3 = fusion::next(i2); typedef typename result_of::next< I3>::type I4; I4 i4 = fusion::next(i3);
 794             return vector_data5(*i0 , *i1 , *i2 , *i3 , *i4);
 795         }
 796         template <typename Sequence>
 797 # if !defined(BOOST_CLANG)
 798     BOOST_CXX14_CONSTEXPR
 799 # endif
 800         BOOST_FUSION_GPU_ENABLED
 801         static vector_data5
 802         init_from_sequence(Sequence& seq)
 803         {
 804             typedef typename result_of::begin<Sequence>::type I0;
 805             I0 i0 = fusion::begin(seq);
 806             typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0); typedef typename result_of::next< I1>::type I2; I2 i2 = fusion::next(i1); typedef typename result_of::next< I2>::type I3; I3 i3 = fusion::next(i2); typedef typename result_of::next< I3>::type I4; I4 i4 = fusion::next(i3);
 807             return vector_data5(*i0 , *i1 , *i2 , *i3 , *i4);
 808         }
 809         T0 m0; T1 m1; T2 m2; T3 m3; T4 m4;
 810     };
 811     template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
 812     struct vector5
 813       : vector_data5<T0 , T1 , T2 , T3 , T4>
 814       , sequence_base<vector5<T0 , T1 , T2 , T3 , T4> >
 815     {
 816         typedef vector5<T0 , T1 , T2 , T3 , T4> this_type;
 817         typedef vector_data5<T0 , T1 , T2 , T3 , T4> base_type;
 818         typedef mpl::vector5<T0 , T1 , T2 , T3 , T4> types;
 819         typedef vector_tag fusion_tag;
 820         typedef fusion_sequence_tag tag;
 821         typedef mpl::false_ is_view;
 822         typedef random_access_traversal_tag category;
 823         typedef mpl::int_<5> size;
 824         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 825         vector5() {}
 826 # if !defined(BOOST_CLANG)
 827     BOOST_CONSTEXPR
 828 # endif
 829         BOOST_FUSION_GPU_ENABLED
 830         vector5(
 831             typename detail::call_param<T0 >::type arg0 , typename detail::call_param<T1 >::type arg1 , typename detail::call_param<T2 >::type arg2 , typename detail::call_param<T3 >::type arg3 , typename detail::call_param<T4 >::type arg4)
 832             : base_type(arg0 , arg1 , arg2 , arg3 , arg4) {}
 833 # if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
 834         template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4>
 835 # if !defined(BOOST_CLANG)
 836         BOOST_CXX14_CONSTEXPR
 837 # endif
 838         BOOST_FUSION_GPU_ENABLED
 839         vector5(U0 && arg0 , U1 && arg1 , U2 && arg2 , U3 && arg3 , U4 && arg4)
 840             : base_type(std::forward<U0>( arg0) , std::forward<U1>( arg1) , std::forward<U2>( arg2) , std::forward<U3>( arg3) , std::forward<U4>( arg4)) {}
 841         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 842         vector5(vector5&& rhs)
 843             : base_type(std::forward<base_type>(rhs)) {}
 844         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 845         vector5(vector5 const& rhs)
 846             : base_type(static_cast<base_type const&>(rhs)) {}
 847         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 848         vector5&
 849         operator=(vector5 const& vec)
 850         {
 851             base_type::operator=(vec);
 852             return *this;
 853         }
 854         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 855         vector5&
 856         operator=(vector5&& vec)
 857         {
 858             this->m0 = std::forward< T0>(vec.m0); this->m1 = std::forward< T1>(vec.m1); this->m2 = std::forward< T2>(vec.m2); this->m3 = std::forward< T3>(vec.m3); this->m4 = std::forward< T4>(vec.m4);
 859             return *this;
 860         }
 861 # endif
 862         template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4>
 863 # if !defined(BOOST_CLANG)
 864     BOOST_CXX14_CONSTEXPR
 865 # endif
 866         BOOST_FUSION_GPU_ENABLED
 867         vector5(
 868             vector5<U0 , U1 , U2 , U3 , U4> const& vec)
 869             : base_type(vec.m0 , vec.m1 , vec.m2 , vec.m3 , vec.m4) {}
 870         template <typename Sequence>
 871 # if !defined(BOOST_CLANG)
 872         BOOST_CXX14_CONSTEXPR
 873 # endif
 874         BOOST_FUSION_GPU_ENABLED
 875         vector5(
 876             Sequence const& seq
 877           , typename boost::enable_if<traits::is_sequence<Sequence> >::type* = 0
 878             )
 879             : base_type(base_type::init_from_sequence(seq)) {}
 880         template <typename Sequence>
 881 # if !defined(BOOST_CLANG)
 882         BOOST_CXX14_CONSTEXPR
 883 # endif
 884         BOOST_FUSION_GPU_ENABLED
 885         vector5(
 886             Sequence& seq
 887           , typename boost::enable_if<traits::is_sequence<Sequence> >::type* = 0
 888             )
 889             : base_type(base_type::init_from_sequence(seq)) {}
 890         template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4>
 891         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 892         vector5&
 893         operator=(vector5<U0 , U1 , U2 , U3 , U4> const& vec)
 894         {
 895             this->m0 = vec.m0; this->m1 = vec.m1; this->m2 = vec.m2; this->m3 = vec.m3; this->m4 = vec.m4;
 896             return *this;
 897         }
 898         template <typename Sequence>
 899         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 900         typename boost::disable_if<is_convertible<Sequence, T0>, this_type&>::type
 901         operator=(Sequence const& seq)
 902         {
 903             typedef typename result_of::begin<Sequence const>::type I0;
 904             I0 i0 = fusion::begin(seq);
 905             typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0); typedef typename result_of::next< I1>::type I2; I2 i2 = fusion::next(i1); typedef typename result_of::next< I2>::type I3; I3 i3 = fusion::next(i2); typedef typename result_of::next< I3>::type I4; I4 i4 = fusion::next(i3);
 906             this->m0 = *i0; this->m1 = *i1; this->m2 = *i2; this->m3 = *i3; this->m4 = *i4;
 907             return *this;
 908         }
 909         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T0>::type at_impl(mpl::int_<0>) { return this->m0; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T0>::type>::type at_impl(mpl::int_<0>) const { return this->m0; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T1>::type at_impl(mpl::int_<1>) { return this->m1; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T1>::type>::type at_impl(mpl::int_<1>) const { return this->m1; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T2>::type at_impl(mpl::int_<2>) { return this->m2; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T2>::type>::type at_impl(mpl::int_<2>) const { return this->m2; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T3>::type at_impl(mpl::int_<3>) { return this->m3; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T3>::type>::type at_impl(mpl::int_<3>) const { return this->m3; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T4>::type at_impl(mpl::int_<4>) { return this->m4; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T4>::type>::type at_impl(mpl::int_<4>) const { return this->m4; }
 910         template<typename I>
 911         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 912         typename add_reference<typename mpl::at<types, I>::type>::type
 913         at_impl(I)
 914         {
 915             return this->at_impl(mpl::int_<I::value>());
 916         }
 917         template<typename I>
 918         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 919         typename add_reference<typename add_const<typename mpl::at<types, I>::type>::type>::type
 920         at_impl(I) const
 921         {
 922             return this->at_impl(mpl::int_<I::value>());
 923         }
 924     };
 925     template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
 926     struct vector_data6
 927     {
 928         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 929         vector_data6()
 930             : m0() , m1() , m2() , m3() , m4() , m5() {}
 931 # if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
 932         template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5>
 933 # if !defined(BOOST_CLANG)
 934         BOOST_CXX14_CONSTEXPR
 935 # endif
 936         BOOST_FUSION_GPU_ENABLED
 937         vector_data6(U0 && arg0 , U1 && arg1 , U2 && arg2 , U3 && arg3 , U4 && arg4 , U5 && arg5
 938           , typename boost::enable_if<is_convertible<U0, T0> >::type* = 0
 939         )
 940             : m0(std::forward<U0>( arg0)) , m1(std::forward<U1>( arg1)) , m2(std::forward<U2>( arg2)) , m3(std::forward<U3>( arg3)) , m4(std::forward<U4>( arg4)) , m5(std::forward<U5>( arg5)) {}
 941         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 942         vector_data6(
 943             vector_data6&& other)
 944             : m0(std::forward<T0>( other.m0)) , m1(std::forward<T1>( other.m1)) , m2(std::forward<T2>( other.m2)) , m3(std::forward<T3>( other.m3)) , m4(std::forward<T4>( other.m4)) , m5(std::forward<T5>( other.m5)) {}
 945 # endif
 946 # if !defined(BOOST_CLANG)
 947     BOOST_CONSTEXPR
 948 # endif
 949         BOOST_FUSION_GPU_ENABLED
 950         vector_data6(
 951             typename detail::call_param<T0 >::type arg0 , typename detail::call_param<T1 >::type arg1 , typename detail::call_param<T2 >::type arg2 , typename detail::call_param<T3 >::type arg3 , typename detail::call_param<T4 >::type arg4 , typename detail::call_param<T5 >::type arg5)
 952             : m0(arg0) , m1(arg1) , m2(arg2) , m3(arg3) , m4(arg4) , m5(arg5) {}
 953         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 954         vector_data6(
 955             vector_data6 const& other)
 956             : m0(other.m0) , m1(other.m1) , m2(other.m2) , m3(other.m3) , m4(other.m4) , m5(other.m5) {}
 957         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 958         vector_data6&
 959         operator=(vector_data6 const& vec)
 960         {
 961             this->m0 = vec.m0; this->m1 = vec.m1; this->m2 = vec.m2; this->m3 = vec.m3; this->m4 = vec.m4; this->m5 = vec.m5;
 962             return *this;
 963         }
 964         template <typename Sequence>
 965 # if !defined(BOOST_CLANG)
 966     BOOST_CXX14_CONSTEXPR
 967 # endif
 968         BOOST_FUSION_GPU_ENABLED
 969         static vector_data6
 970         init_from_sequence(Sequence const& seq)
 971         {
 972             typedef typename result_of::begin<Sequence const>::type I0;
 973             I0 i0 = fusion::begin(seq);
 974             typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0); typedef typename result_of::next< I1>::type I2; I2 i2 = fusion::next(i1); typedef typename result_of::next< I2>::type I3; I3 i3 = fusion::next(i2); typedef typename result_of::next< I3>::type I4; I4 i4 = fusion::next(i3); typedef typename result_of::next< I4>::type I5; I5 i5 = fusion::next(i4);
 975             return vector_data6(*i0 , *i1 , *i2 , *i3 , *i4 , *i5);
 976         }
 977         template <typename Sequence>
 978 # if !defined(BOOST_CLANG)
 979     BOOST_CXX14_CONSTEXPR
 980 # endif
 981         BOOST_FUSION_GPU_ENABLED
 982         static vector_data6
 983         init_from_sequence(Sequence& seq)
 984         {
 985             typedef typename result_of::begin<Sequence>::type I0;
 986             I0 i0 = fusion::begin(seq);
 987             typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0); typedef typename result_of::next< I1>::type I2; I2 i2 = fusion::next(i1); typedef typename result_of::next< I2>::type I3; I3 i3 = fusion::next(i2); typedef typename result_of::next< I3>::type I4; I4 i4 = fusion::next(i3); typedef typename result_of::next< I4>::type I5; I5 i5 = fusion::next(i4);
 988             return vector_data6(*i0 , *i1 , *i2 , *i3 , *i4 , *i5);
 989         }
 990         T0 m0; T1 m1; T2 m2; T3 m3; T4 m4; T5 m5;
 991     };
 992     template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
 993     struct vector6
 994       : vector_data6<T0 , T1 , T2 , T3 , T4 , T5>
 995       , sequence_base<vector6<T0 , T1 , T2 , T3 , T4 , T5> >
 996     {
 997         typedef vector6<T0 , T1 , T2 , T3 , T4 , T5> this_type;
 998         typedef vector_data6<T0 , T1 , T2 , T3 , T4 , T5> base_type;
 999         typedef mpl::vector6<T0 , T1 , T2 , T3 , T4 , T5> types;
1000         typedef vector_tag fusion_tag;
1001         typedef fusion_sequence_tag tag;
1002         typedef mpl::false_ is_view;
1003         typedef random_access_traversal_tag category;
1004         typedef mpl::int_<6> size;
1005         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1006         vector6() {}
1007 # if !defined(BOOST_CLANG)
1008     BOOST_CONSTEXPR
1009 # endif
1010         BOOST_FUSION_GPU_ENABLED
1011         vector6(
1012             typename detail::call_param<T0 >::type arg0 , typename detail::call_param<T1 >::type arg1 , typename detail::call_param<T2 >::type arg2 , typename detail::call_param<T3 >::type arg3 , typename detail::call_param<T4 >::type arg4 , typename detail::call_param<T5 >::type arg5)
1013             : base_type(arg0 , arg1 , arg2 , arg3 , arg4 , arg5) {}
1014 # if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
1015         template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5>
1016 # if !defined(BOOST_CLANG)
1017         BOOST_CXX14_CONSTEXPR
1018 # endif
1019         BOOST_FUSION_GPU_ENABLED
1020         vector6(U0 && arg0 , U1 && arg1 , U2 && arg2 , U3 && arg3 , U4 && arg4 , U5 && arg5)
1021             : base_type(std::forward<U0>( arg0) , std::forward<U1>( arg1) , std::forward<U2>( arg2) , std::forward<U3>( arg3) , std::forward<U4>( arg4) , std::forward<U5>( arg5)) {}
1022         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1023         vector6(vector6&& rhs)
1024             : base_type(std::forward<base_type>(rhs)) {}
1025         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1026         vector6(vector6 const& rhs)
1027             : base_type(static_cast<base_type const&>(rhs)) {}
1028         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1029         vector6&
1030         operator=(vector6 const& vec)
1031         {
1032             base_type::operator=(vec);
1033             return *this;
1034         }
1035         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1036         vector6&
1037         operator=(vector6&& vec)
1038         {
1039             this->m0 = std::forward< T0>(vec.m0); this->m1 = std::forward< T1>(vec.m1); this->m2 = std::forward< T2>(vec.m2); this->m3 = std::forward< T3>(vec.m3); this->m4 = std::forward< T4>(vec.m4); this->m5 = std::forward< T5>(vec.m5);
1040             return *this;
1041         }
1042 # endif
1043         template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5>
1044 # if !defined(BOOST_CLANG)
1045     BOOST_CXX14_CONSTEXPR
1046 # endif
1047         BOOST_FUSION_GPU_ENABLED
1048         vector6(
1049             vector6<U0 , U1 , U2 , U3 , U4 , U5> const& vec)
1050             : base_type(vec.m0 , vec.m1 , vec.m2 , vec.m3 , vec.m4 , vec.m5) {}
1051         template <typename Sequence>
1052 # if !defined(BOOST_CLANG)
1053         BOOST_CXX14_CONSTEXPR
1054 # endif
1055         BOOST_FUSION_GPU_ENABLED
1056         vector6(
1057             Sequence const& seq
1058           , typename boost::enable_if<traits::is_sequence<Sequence> >::type* = 0
1059             )
1060             : base_type(base_type::init_from_sequence(seq)) {}
1061         template <typename Sequence>
1062 # if !defined(BOOST_CLANG)
1063         BOOST_CXX14_CONSTEXPR
1064 # endif
1065         BOOST_FUSION_GPU_ENABLED
1066         vector6(
1067             Sequence& seq
1068           , typename boost::enable_if<traits::is_sequence<Sequence> >::type* = 0
1069             )
1070             : base_type(base_type::init_from_sequence(seq)) {}
1071         template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5>
1072         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1073         vector6&
1074         operator=(vector6<U0 , U1 , U2 , U3 , U4 , U5> const& vec)
1075         {
1076             this->m0 = vec.m0; this->m1 = vec.m1; this->m2 = vec.m2; this->m3 = vec.m3; this->m4 = vec.m4; this->m5 = vec.m5;
1077             return *this;
1078         }
1079         template <typename Sequence>
1080         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1081         typename boost::disable_if<is_convertible<Sequence, T0>, this_type&>::type
1082         operator=(Sequence const& seq)
1083         {
1084             typedef typename result_of::begin<Sequence const>::type I0;
1085             I0 i0 = fusion::begin(seq);
1086             typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0); typedef typename result_of::next< I1>::type I2; I2 i2 = fusion::next(i1); typedef typename result_of::next< I2>::type I3; I3 i3 = fusion::next(i2); typedef typename result_of::next< I3>::type I4; I4 i4 = fusion::next(i3); typedef typename result_of::next< I4>::type I5; I5 i5 = fusion::next(i4);
1087             this->m0 = *i0; this->m1 = *i1; this->m2 = *i2; this->m3 = *i3; this->m4 = *i4; this->m5 = *i5;
1088             return *this;
1089         }
1090         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T0>::type at_impl(mpl::int_<0>) { return this->m0; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T0>::type>::type at_impl(mpl::int_<0>) const { return this->m0; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T1>::type at_impl(mpl::int_<1>) { return this->m1; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T1>::type>::type at_impl(mpl::int_<1>) const { return this->m1; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T2>::type at_impl(mpl::int_<2>) { return this->m2; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T2>::type>::type at_impl(mpl::int_<2>) const { return this->m2; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T3>::type at_impl(mpl::int_<3>) { return this->m3; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T3>::type>::type at_impl(mpl::int_<3>) const { return this->m3; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T4>::type at_impl(mpl::int_<4>) { return this->m4; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T4>::type>::type at_impl(mpl::int_<4>) const { return this->m4; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T5>::type at_impl(mpl::int_<5>) { return this->m5; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T5>::type>::type at_impl(mpl::int_<5>) const { return this->m5; }
1091         template<typename I>
1092         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1093         typename add_reference<typename mpl::at<types, I>::type>::type
1094         at_impl(I)
1095         {
1096             return this->at_impl(mpl::int_<I::value>());
1097         }
1098         template<typename I>
1099         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1100         typename add_reference<typename add_const<typename mpl::at<types, I>::type>::type>::type
1101         at_impl(I) const
1102         {
1103             return this->at_impl(mpl::int_<I::value>());
1104         }
1105     };
1106     template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
1107     struct vector_data7
1108     {
1109         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1110         vector_data7()
1111             : m0() , m1() , m2() , m3() , m4() , m5() , m6() {}
1112 # if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
1113         template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6>
1114 # if !defined(BOOST_CLANG)
1115         BOOST_CXX14_CONSTEXPR
1116 # endif
1117         BOOST_FUSION_GPU_ENABLED
1118         vector_data7(U0 && arg0 , U1 && arg1 , U2 && arg2 , U3 && arg3 , U4 && arg4 , U5 && arg5 , U6 && arg6
1119           , typename boost::enable_if<is_convertible<U0, T0> >::type* = 0
1120         )
1121             : m0(std::forward<U0>( arg0)) , m1(std::forward<U1>( arg1)) , m2(std::forward<U2>( arg2)) , m3(std::forward<U3>( arg3)) , m4(std::forward<U4>( arg4)) , m5(std::forward<U5>( arg5)) , m6(std::forward<U6>( arg6)) {}
1122         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1123         vector_data7(
1124             vector_data7&& other)
1125             : m0(std::forward<T0>( other.m0)) , m1(std::forward<T1>( other.m1)) , m2(std::forward<T2>( other.m2)) , m3(std::forward<T3>( other.m3)) , m4(std::forward<T4>( other.m4)) , m5(std::forward<T5>( other.m5)) , m6(std::forward<T6>( other.m6)) {}
1126 # endif
1127 # if !defined(BOOST_CLANG)
1128     BOOST_CONSTEXPR
1129 # endif
1130         BOOST_FUSION_GPU_ENABLED
1131         vector_data7(
1132             typename detail::call_param<T0 >::type arg0 , typename detail::call_param<T1 >::type arg1 , typename detail::call_param<T2 >::type arg2 , typename detail::call_param<T3 >::type arg3 , typename detail::call_param<T4 >::type arg4 , typename detail::call_param<T5 >::type arg5 , typename detail::call_param<T6 >::type arg6)
1133             : m0(arg0) , m1(arg1) , m2(arg2) , m3(arg3) , m4(arg4) , m5(arg5) , m6(arg6) {}
1134         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1135         vector_data7(
1136             vector_data7 const& other)
1137             : m0(other.m0) , m1(other.m1) , m2(other.m2) , m3(other.m3) , m4(other.m4) , m5(other.m5) , m6(other.m6) {}
1138         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1139         vector_data7&
1140         operator=(vector_data7 const& vec)
1141         {
1142             this->m0 = vec.m0; this->m1 = vec.m1; this->m2 = vec.m2; this->m3 = vec.m3; this->m4 = vec.m4; this->m5 = vec.m5; this->m6 = vec.m6;
1143             return *this;
1144         }
1145         template <typename Sequence>
1146 # if !defined(BOOST_CLANG)
1147     BOOST_CXX14_CONSTEXPR
1148 # endif
1149         BOOST_FUSION_GPU_ENABLED
1150         static vector_data7
1151         init_from_sequence(Sequence const& seq)
1152         {
1153             typedef typename result_of::begin<Sequence const>::type I0;
1154             I0 i0 = fusion::begin(seq);
1155             typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0); typedef typename result_of::next< I1>::type I2; I2 i2 = fusion::next(i1); typedef typename result_of::next< I2>::type I3; I3 i3 = fusion::next(i2); typedef typename result_of::next< I3>::type I4; I4 i4 = fusion::next(i3); typedef typename result_of::next< I4>::type I5; I5 i5 = fusion::next(i4); typedef typename result_of::next< I5>::type I6; I6 i6 = fusion::next(i5);
1156             return vector_data7(*i0 , *i1 , *i2 , *i3 , *i4 , *i5 , *i6);
1157         }
1158         template <typename Sequence>
1159 # if !defined(BOOST_CLANG)
1160     BOOST_CXX14_CONSTEXPR
1161 # endif
1162         BOOST_FUSION_GPU_ENABLED
1163         static vector_data7
1164         init_from_sequence(Sequence& seq)
1165         {
1166             typedef typename result_of::begin<Sequence>::type I0;
1167             I0 i0 = fusion::begin(seq);
1168             typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0); typedef typename result_of::next< I1>::type I2; I2 i2 = fusion::next(i1); typedef typename result_of::next< I2>::type I3; I3 i3 = fusion::next(i2); typedef typename result_of::next< I3>::type I4; I4 i4 = fusion::next(i3); typedef typename result_of::next< I4>::type I5; I5 i5 = fusion::next(i4); typedef typename result_of::next< I5>::type I6; I6 i6 = fusion::next(i5);
1169             return vector_data7(*i0 , *i1 , *i2 , *i3 , *i4 , *i5 , *i6);
1170         }
1171         T0 m0; T1 m1; T2 m2; T3 m3; T4 m4; T5 m5; T6 m6;
1172     };
1173     template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
1174     struct vector7
1175       : vector_data7<T0 , T1 , T2 , T3 , T4 , T5 , T6>
1176       , sequence_base<vector7<T0 , T1 , T2 , T3 , T4 , T5 , T6> >
1177     {
1178         typedef vector7<T0 , T1 , T2 , T3 , T4 , T5 , T6> this_type;
1179         typedef vector_data7<T0 , T1 , T2 , T3 , T4 , T5 , T6> base_type;
1180         typedef mpl::vector7<T0 , T1 , T2 , T3 , T4 , T5 , T6> types;
1181         typedef vector_tag fusion_tag;
1182         typedef fusion_sequence_tag tag;
1183         typedef mpl::false_ is_view;
1184         typedef random_access_traversal_tag category;
1185         typedef mpl::int_<7> size;
1186         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1187         vector7() {}
1188 # if !defined(BOOST_CLANG)
1189     BOOST_CONSTEXPR
1190 # endif
1191         BOOST_FUSION_GPU_ENABLED
1192         vector7(
1193             typename detail::call_param<T0 >::type arg0 , typename detail::call_param<T1 >::type arg1 , typename detail::call_param<T2 >::type arg2 , typename detail::call_param<T3 >::type arg3 , typename detail::call_param<T4 >::type arg4 , typename detail::call_param<T5 >::type arg5 , typename detail::call_param<T6 >::type arg6)
1194             : base_type(arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6) {}
1195 # if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
1196         template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6>
1197 # if !defined(BOOST_CLANG)
1198         BOOST_CXX14_CONSTEXPR
1199 # endif
1200         BOOST_FUSION_GPU_ENABLED
1201         vector7(U0 && arg0 , U1 && arg1 , U2 && arg2 , U3 && arg3 , U4 && arg4 , U5 && arg5 , U6 && arg6)
1202             : base_type(std::forward<U0>( arg0) , std::forward<U1>( arg1) , std::forward<U2>( arg2) , std::forward<U3>( arg3) , std::forward<U4>( arg4) , std::forward<U5>( arg5) , std::forward<U6>( arg6)) {}
1203         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1204         vector7(vector7&& rhs)
1205             : base_type(std::forward<base_type>(rhs)) {}
1206         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1207         vector7(vector7 const& rhs)
1208             : base_type(static_cast<base_type const&>(rhs)) {}
1209         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1210         vector7&
1211         operator=(vector7 const& vec)
1212         {
1213             base_type::operator=(vec);
1214             return *this;
1215         }
1216         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1217         vector7&
1218         operator=(vector7&& vec)
1219         {
1220             this->m0 = std::forward< T0>(vec.m0); this->m1 = std::forward< T1>(vec.m1); this->m2 = std::forward< T2>(vec.m2); this->m3 = std::forward< T3>(vec.m3); this->m4 = std::forward< T4>(vec.m4); this->m5 = std::forward< T5>(vec.m5); this->m6 = std::forward< T6>(vec.m6);
1221             return *this;
1222         }
1223 # endif
1224         template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6>
1225 # if !defined(BOOST_CLANG)
1226     BOOST_CXX14_CONSTEXPR
1227 # endif
1228         BOOST_FUSION_GPU_ENABLED
1229         vector7(
1230             vector7<U0 , U1 , U2 , U3 , U4 , U5 , U6> const& vec)
1231             : base_type(vec.m0 , vec.m1 , vec.m2 , vec.m3 , vec.m4 , vec.m5 , vec.m6) {}
1232         template <typename Sequence>
1233 # if !defined(BOOST_CLANG)
1234         BOOST_CXX14_CONSTEXPR
1235 # endif
1236         BOOST_FUSION_GPU_ENABLED
1237         vector7(
1238             Sequence const& seq
1239           , typename boost::enable_if<traits::is_sequence<Sequence> >::type* = 0
1240             )
1241             : base_type(base_type::init_from_sequence(seq)) {}
1242         template <typename Sequence>
1243 # if !defined(BOOST_CLANG)
1244         BOOST_CXX14_CONSTEXPR
1245 # endif
1246         BOOST_FUSION_GPU_ENABLED
1247         vector7(
1248             Sequence& seq
1249           , typename boost::enable_if<traits::is_sequence<Sequence> >::type* = 0
1250             )
1251             : base_type(base_type::init_from_sequence(seq)) {}
1252         template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6>
1253         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1254         vector7&
1255         operator=(vector7<U0 , U1 , U2 , U3 , U4 , U5 , U6> const& vec)
1256         {
1257             this->m0 = vec.m0; this->m1 = vec.m1; this->m2 = vec.m2; this->m3 = vec.m3; this->m4 = vec.m4; this->m5 = vec.m5; this->m6 = vec.m6;
1258             return *this;
1259         }
1260         template <typename Sequence>
1261         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1262         typename boost::disable_if<is_convertible<Sequence, T0>, this_type&>::type
1263         operator=(Sequence const& seq)
1264         {
1265             typedef typename result_of::begin<Sequence const>::type I0;
1266             I0 i0 = fusion::begin(seq);
1267             typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0); typedef typename result_of::next< I1>::type I2; I2 i2 = fusion::next(i1); typedef typename result_of::next< I2>::type I3; I3 i3 = fusion::next(i2); typedef typename result_of::next< I3>::type I4; I4 i4 = fusion::next(i3); typedef typename result_of::next< I4>::type I5; I5 i5 = fusion::next(i4); typedef typename result_of::next< I5>::type I6; I6 i6 = fusion::next(i5);
1268             this->m0 = *i0; this->m1 = *i1; this->m2 = *i2; this->m3 = *i3; this->m4 = *i4; this->m5 = *i5; this->m6 = *i6;
1269             return *this;
1270         }
1271         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T0>::type at_impl(mpl::int_<0>) { return this->m0; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T0>::type>::type at_impl(mpl::int_<0>) const { return this->m0; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T1>::type at_impl(mpl::int_<1>) { return this->m1; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T1>::type>::type at_impl(mpl::int_<1>) const { return this->m1; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T2>::type at_impl(mpl::int_<2>) { return this->m2; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T2>::type>::type at_impl(mpl::int_<2>) const { return this->m2; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T3>::type at_impl(mpl::int_<3>) { return this->m3; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T3>::type>::type at_impl(mpl::int_<3>) const { return this->m3; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T4>::type at_impl(mpl::int_<4>) { return this->m4; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T4>::type>::type at_impl(mpl::int_<4>) const { return this->m4; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T5>::type at_impl(mpl::int_<5>) { return this->m5; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T5>::type>::type at_impl(mpl::int_<5>) const { return this->m5; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T6>::type at_impl(mpl::int_<6>) { return this->m6; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T6>::type>::type at_impl(mpl::int_<6>) const { return this->m6; }
1272         template<typename I>
1273         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1274         typename add_reference<typename mpl::at<types, I>::type>::type
1275         at_impl(I)
1276         {
1277             return this->at_impl(mpl::int_<I::value>());
1278         }
1279         template<typename I>
1280         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1281         typename add_reference<typename add_const<typename mpl::at<types, I>::type>::type>::type
1282         at_impl(I) const
1283         {
1284             return this->at_impl(mpl::int_<I::value>());
1285         }
1286     };
1287     template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
1288     struct vector_data8
1289     {
1290         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1291         vector_data8()
1292             : m0() , m1() , m2() , m3() , m4() , m5() , m6() , m7() {}
1293 # if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
1294         template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7>
1295 # if !defined(BOOST_CLANG)
1296         BOOST_CXX14_CONSTEXPR
1297 # endif
1298         BOOST_FUSION_GPU_ENABLED
1299         vector_data8(U0 && arg0 , U1 && arg1 , U2 && arg2 , U3 && arg3 , U4 && arg4 , U5 && arg5 , U6 && arg6 , U7 && arg7
1300           , typename boost::enable_if<is_convertible<U0, T0> >::type* = 0
1301         )
1302             : m0(std::forward<U0>( arg0)) , m1(std::forward<U1>( arg1)) , m2(std::forward<U2>( arg2)) , m3(std::forward<U3>( arg3)) , m4(std::forward<U4>( arg4)) , m5(std::forward<U5>( arg5)) , m6(std::forward<U6>( arg6)) , m7(std::forward<U7>( arg7)) {}
1303         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1304         vector_data8(
1305             vector_data8&& other)
1306             : m0(std::forward<T0>( other.m0)) , m1(std::forward<T1>( other.m1)) , m2(std::forward<T2>( other.m2)) , m3(std::forward<T3>( other.m3)) , m4(std::forward<T4>( other.m4)) , m5(std::forward<T5>( other.m5)) , m6(std::forward<T6>( other.m6)) , m7(std::forward<T7>( other.m7)) {}
1307 # endif
1308 # if !defined(BOOST_CLANG)
1309     BOOST_CONSTEXPR
1310 # endif
1311         BOOST_FUSION_GPU_ENABLED
1312         vector_data8(
1313             typename detail::call_param<T0 >::type arg0 , typename detail::call_param<T1 >::type arg1 , typename detail::call_param<T2 >::type arg2 , typename detail::call_param<T3 >::type arg3 , typename detail::call_param<T4 >::type arg4 , typename detail::call_param<T5 >::type arg5 , typename detail::call_param<T6 >::type arg6 , typename detail::call_param<T7 >::type arg7)
1314             : m0(arg0) , m1(arg1) , m2(arg2) , m3(arg3) , m4(arg4) , m5(arg5) , m6(arg6) , m7(arg7) {}
1315         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1316         vector_data8(
1317             vector_data8 const& other)
1318             : m0(other.m0) , m1(other.m1) , m2(other.m2) , m3(other.m3) , m4(other.m4) , m5(other.m5) , m6(other.m6) , m7(other.m7) {}
1319         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1320         vector_data8&
1321         operator=(vector_data8 const& vec)
1322         {
1323             this->m0 = vec.m0; this->m1 = vec.m1; this->m2 = vec.m2; this->m3 = vec.m3; this->m4 = vec.m4; this->m5 = vec.m5; this->m6 = vec.m6; this->m7 = vec.m7;
1324             return *this;
1325         }
1326         template <typename Sequence>
1327 # if !defined(BOOST_CLANG)
1328     BOOST_CXX14_CONSTEXPR
1329 # endif
1330         BOOST_FUSION_GPU_ENABLED
1331         static vector_data8
1332         init_from_sequence(Sequence const& seq)
1333         {
1334             typedef typename result_of::begin<Sequence const>::type I0;
1335             I0 i0 = fusion::begin(seq);
1336             typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0); typedef typename result_of::next< I1>::type I2; I2 i2 = fusion::next(i1); typedef typename result_of::next< I2>::type I3; I3 i3 = fusion::next(i2); typedef typename result_of::next< I3>::type I4; I4 i4 = fusion::next(i3); typedef typename result_of::next< I4>::type I5; I5 i5 = fusion::next(i4); typedef typename result_of::next< I5>::type I6; I6 i6 = fusion::next(i5); typedef typename result_of::next< I6>::type I7; I7 i7 = fusion::next(i6);
1337             return vector_data8(*i0 , *i1 , *i2 , *i3 , *i4 , *i5 , *i6 , *i7);
1338         }
1339         template <typename Sequence>
1340 # if !defined(BOOST_CLANG)
1341     BOOST_CXX14_CONSTEXPR
1342 # endif
1343         BOOST_FUSION_GPU_ENABLED
1344         static vector_data8
1345         init_from_sequence(Sequence& seq)
1346         {
1347             typedef typename result_of::begin<Sequence>::type I0;
1348             I0 i0 = fusion::begin(seq);
1349             typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0); typedef typename result_of::next< I1>::type I2; I2 i2 = fusion::next(i1); typedef typename result_of::next< I2>::type I3; I3 i3 = fusion::next(i2); typedef typename result_of::next< I3>::type I4; I4 i4 = fusion::next(i3); typedef typename result_of::next< I4>::type I5; I5 i5 = fusion::next(i4); typedef typename result_of::next< I5>::type I6; I6 i6 = fusion::next(i5); typedef typename result_of::next< I6>::type I7; I7 i7 = fusion::next(i6);
1350             return vector_data8(*i0 , *i1 , *i2 , *i3 , *i4 , *i5 , *i6 , *i7);
1351         }
1352         T0 m0; T1 m1; T2 m2; T3 m3; T4 m4; T5 m5; T6 m6; T7 m7;
1353     };
1354     template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
1355     struct vector8
1356       : vector_data8<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>
1357       , sequence_base<vector8<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7> >
1358     {
1359         typedef vector8<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7> this_type;
1360         typedef vector_data8<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7> base_type;
1361         typedef mpl::vector8<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7> types;
1362         typedef vector_tag fusion_tag;
1363         typedef fusion_sequence_tag tag;
1364         typedef mpl::false_ is_view;
1365         typedef random_access_traversal_tag category;
1366         typedef mpl::int_<8> size;
1367         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1368         vector8() {}
1369 # if !defined(BOOST_CLANG)
1370     BOOST_CONSTEXPR
1371 # endif
1372         BOOST_FUSION_GPU_ENABLED
1373         vector8(
1374             typename detail::call_param<T0 >::type arg0 , typename detail::call_param<T1 >::type arg1 , typename detail::call_param<T2 >::type arg2 , typename detail::call_param<T3 >::type arg3 , typename detail::call_param<T4 >::type arg4 , typename detail::call_param<T5 >::type arg5 , typename detail::call_param<T6 >::type arg6 , typename detail::call_param<T7 >::type arg7)
1375             : base_type(arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7) {}
1376 # if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
1377         template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7>
1378 # if !defined(BOOST_CLANG)
1379         BOOST_CXX14_CONSTEXPR
1380 # endif
1381         BOOST_FUSION_GPU_ENABLED
1382         vector8(U0 && arg0 , U1 && arg1 , U2 && arg2 , U3 && arg3 , U4 && arg4 , U5 && arg5 , U6 && arg6 , U7 && arg7)
1383             : base_type(std::forward<U0>( arg0) , std::forward<U1>( arg1) , std::forward<U2>( arg2) , std::forward<U3>( arg3) , std::forward<U4>( arg4) , std::forward<U5>( arg5) , std::forward<U6>( arg6) , std::forward<U7>( arg7)) {}
1384         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1385         vector8(vector8&& rhs)
1386             : base_type(std::forward<base_type>(rhs)) {}
1387         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1388         vector8(vector8 const& rhs)
1389             : base_type(static_cast<base_type const&>(rhs)) {}
1390         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1391         vector8&
1392         operator=(vector8 const& vec)
1393         {
1394             base_type::operator=(vec);
1395             return *this;
1396         }
1397         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1398         vector8&
1399         operator=(vector8&& vec)
1400         {
1401             this->m0 = std::forward< T0>(vec.m0); this->m1 = std::forward< T1>(vec.m1); this->m2 = std::forward< T2>(vec.m2); this->m3 = std::forward< T3>(vec.m3); this->m4 = std::forward< T4>(vec.m4); this->m5 = std::forward< T5>(vec.m5); this->m6 = std::forward< T6>(vec.m6); this->m7 = std::forward< T7>(vec.m7);
1402             return *this;
1403         }
1404 # endif
1405         template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7>
1406 # if !defined(BOOST_CLANG)
1407     BOOST_CXX14_CONSTEXPR
1408 # endif
1409         BOOST_FUSION_GPU_ENABLED
1410         vector8(
1411             vector8<U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7> const& vec)
1412             : base_type(vec.m0 , vec.m1 , vec.m2 , vec.m3 , vec.m4 , vec.m5 , vec.m6 , vec.m7) {}
1413         template <typename Sequence>
1414 # if !defined(BOOST_CLANG)
1415         BOOST_CXX14_CONSTEXPR
1416 # endif
1417         BOOST_FUSION_GPU_ENABLED
1418         vector8(
1419             Sequence const& seq
1420           , typename boost::enable_if<traits::is_sequence<Sequence> >::type* = 0
1421             )
1422             : base_type(base_type::init_from_sequence(seq)) {}
1423         template <typename Sequence>
1424 # if !defined(BOOST_CLANG)
1425         BOOST_CXX14_CONSTEXPR
1426 # endif
1427         BOOST_FUSION_GPU_ENABLED
1428         vector8(
1429             Sequence& seq
1430           , typename boost::enable_if<traits::is_sequence<Sequence> >::type* = 0
1431             )
1432             : base_type(base_type::init_from_sequence(seq)) {}
1433         template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7>
1434         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1435         vector8&
1436         operator=(vector8<U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7> const& vec)
1437         {
1438             this->m0 = vec.m0; this->m1 = vec.m1; this->m2 = vec.m2; this->m3 = vec.m3; this->m4 = vec.m4; this->m5 = vec.m5; this->m6 = vec.m6; this->m7 = vec.m7;
1439             return *this;
1440         }
1441         template <typename Sequence>
1442         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1443         typename boost::disable_if<is_convertible<Sequence, T0>, this_type&>::type
1444         operator=(Sequence const& seq)
1445         {
1446             typedef typename result_of::begin<Sequence const>::type I0;
1447             I0 i0 = fusion::begin(seq);
1448             typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0); typedef typename result_of::next< I1>::type I2; I2 i2 = fusion::next(i1); typedef typename result_of::next< I2>::type I3; I3 i3 = fusion::next(i2); typedef typename result_of::next< I3>::type I4; I4 i4 = fusion::next(i3); typedef typename result_of::next< I4>::type I5; I5 i5 = fusion::next(i4); typedef typename result_of::next< I5>::type I6; I6 i6 = fusion::next(i5); typedef typename result_of::next< I6>::type I7; I7 i7 = fusion::next(i6);
1449             this->m0 = *i0; this->m1 = *i1; this->m2 = *i2; this->m3 = *i3; this->m4 = *i4; this->m5 = *i5; this->m6 = *i6; this->m7 = *i7;
1450             return *this;
1451         }
1452         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T0>::type at_impl(mpl::int_<0>) { return this->m0; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T0>::type>::type at_impl(mpl::int_<0>) const { return this->m0; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T1>::type at_impl(mpl::int_<1>) { return this->m1; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T1>::type>::type at_impl(mpl::int_<1>) const { return this->m1; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T2>::type at_impl(mpl::int_<2>) { return this->m2; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T2>::type>::type at_impl(mpl::int_<2>) const { return this->m2; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T3>::type at_impl(mpl::int_<3>) { return this->m3; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T3>::type>::type at_impl(mpl::int_<3>) const { return this->m3; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T4>::type at_impl(mpl::int_<4>) { return this->m4; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T4>::type>::type at_impl(mpl::int_<4>) const { return this->m4; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T5>::type at_impl(mpl::int_<5>) { return this->m5; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T5>::type>::type at_impl(mpl::int_<5>) const { return this->m5; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T6>::type at_impl(mpl::int_<6>) { return this->m6; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T6>::type>::type at_impl(mpl::int_<6>) const { return this->m6; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T7>::type at_impl(mpl::int_<7>) { return this->m7; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T7>::type>::type at_impl(mpl::int_<7>) const { return this->m7; }
1453         template<typename I>
1454         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1455         typename add_reference<typename mpl::at<types, I>::type>::type
1456         at_impl(I)
1457         {
1458             return this->at_impl(mpl::int_<I::value>());
1459         }
1460         template<typename I>
1461         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1462         typename add_reference<typename add_const<typename mpl::at<types, I>::type>::type>::type
1463         at_impl(I) const
1464         {
1465             return this->at_impl(mpl::int_<I::value>());
1466         }
1467     };
1468     template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
1469     struct vector_data9
1470     {
1471         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1472         vector_data9()
1473             : m0() , m1() , m2() , m3() , m4() , m5() , m6() , m7() , m8() {}
1474 # if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
1475         template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8>
1476 # if !defined(BOOST_CLANG)
1477         BOOST_CXX14_CONSTEXPR
1478 # endif
1479         BOOST_FUSION_GPU_ENABLED
1480         vector_data9(U0 && arg0 , U1 && arg1 , U2 && arg2 , U3 && arg3 , U4 && arg4 , U5 && arg5 , U6 && arg6 , U7 && arg7 , U8 && arg8
1481           , typename boost::enable_if<is_convertible<U0, T0> >::type* = 0
1482         )
1483             : m0(std::forward<U0>( arg0)) , m1(std::forward<U1>( arg1)) , m2(std::forward<U2>( arg2)) , m3(std::forward<U3>( arg3)) , m4(std::forward<U4>( arg4)) , m5(std::forward<U5>( arg5)) , m6(std::forward<U6>( arg6)) , m7(std::forward<U7>( arg7)) , m8(std::forward<U8>( arg8)) {}
1484         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1485         vector_data9(
1486             vector_data9&& other)
1487             : m0(std::forward<T0>( other.m0)) , m1(std::forward<T1>( other.m1)) , m2(std::forward<T2>( other.m2)) , m3(std::forward<T3>( other.m3)) , m4(std::forward<T4>( other.m4)) , m5(std::forward<T5>( other.m5)) , m6(std::forward<T6>( other.m6)) , m7(std::forward<T7>( other.m7)) , m8(std::forward<T8>( other.m8)) {}
1488 # endif
1489 # if !defined(BOOST_CLANG)
1490     BOOST_CONSTEXPR
1491 # endif
1492         BOOST_FUSION_GPU_ENABLED
1493         vector_data9(
1494             typename detail::call_param<T0 >::type arg0 , typename detail::call_param<T1 >::type arg1 , typename detail::call_param<T2 >::type arg2 , typename detail::call_param<T3 >::type arg3 , typename detail::call_param<T4 >::type arg4 , typename detail::call_param<T5 >::type arg5 , typename detail::call_param<T6 >::type arg6 , typename detail::call_param<T7 >::type arg7 , typename detail::call_param<T8 >::type arg8)
1495             : m0(arg0) , m1(arg1) , m2(arg2) , m3(arg3) , m4(arg4) , m5(arg5) , m6(arg6) , m7(arg7) , m8(arg8) {}
1496         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1497         vector_data9(
1498             vector_data9 const& other)
1499             : m0(other.m0) , m1(other.m1) , m2(other.m2) , m3(other.m3) , m4(other.m4) , m5(other.m5) , m6(other.m6) , m7(other.m7) , m8(other.m8) {}
1500         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1501         vector_data9&
1502         operator=(vector_data9 const& vec)
1503         {
1504             this->m0 = vec.m0; this->m1 = vec.m1; this->m2 = vec.m2; this->m3 = vec.m3; this->m4 = vec.m4; this->m5 = vec.m5; this->m6 = vec.m6; this->m7 = vec.m7; this->m8 = vec.m8;
1505             return *this;
1506         }
1507         template <typename Sequence>
1508 # if !defined(BOOST_CLANG)
1509     BOOST_CXX14_CONSTEXPR
1510 # endif
1511         BOOST_FUSION_GPU_ENABLED
1512         static vector_data9
1513         init_from_sequence(Sequence const& seq)
1514         {
1515             typedef typename result_of::begin<Sequence const>::type I0;
1516             I0 i0 = fusion::begin(seq);
1517             typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0); typedef typename result_of::next< I1>::type I2; I2 i2 = fusion::next(i1); typedef typename result_of::next< I2>::type I3; I3 i3 = fusion::next(i2); typedef typename result_of::next< I3>::type I4; I4 i4 = fusion::next(i3); typedef typename result_of::next< I4>::type I5; I5 i5 = fusion::next(i4); typedef typename result_of::next< I5>::type I6; I6 i6 = fusion::next(i5); typedef typename result_of::next< I6>::type I7; I7 i7 = fusion::next(i6); typedef typename result_of::next< I7>::type I8; I8 i8 = fusion::next(i7);
1518             return vector_data9(*i0 , *i1 , *i2 , *i3 , *i4 , *i5 , *i6 , *i7 , *i8);
1519         }
1520         template <typename Sequence>
1521 # if !defined(BOOST_CLANG)
1522     BOOST_CXX14_CONSTEXPR
1523 # endif
1524         BOOST_FUSION_GPU_ENABLED
1525         static vector_data9
1526         init_from_sequence(Sequence& seq)
1527         {
1528             typedef typename result_of::begin<Sequence>::type I0;
1529             I0 i0 = fusion::begin(seq);
1530             typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0); typedef typename result_of::next< I1>::type I2; I2 i2 = fusion::next(i1); typedef typename result_of::next< I2>::type I3; I3 i3 = fusion::next(i2); typedef typename result_of::next< I3>::type I4; I4 i4 = fusion::next(i3); typedef typename result_of::next< I4>::type I5; I5 i5 = fusion::next(i4); typedef typename result_of::next< I5>::type I6; I6 i6 = fusion::next(i5); typedef typename result_of::next< I6>::type I7; I7 i7 = fusion::next(i6); typedef typename result_of::next< I7>::type I8; I8 i8 = fusion::next(i7);
1531             return vector_data9(*i0 , *i1 , *i2 , *i3 , *i4 , *i5 , *i6 , *i7 , *i8);
1532         }
1533         T0 m0; T1 m1; T2 m2; T3 m3; T4 m4; T5 m5; T6 m6; T7 m7; T8 m8;
1534     };
1535     template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
1536     struct vector9
1537       : vector_data9<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>
1538       , sequence_base<vector9<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8> >
1539     {
1540         typedef vector9<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8> this_type;
1541         typedef vector_data9<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8> base_type;
1542         typedef mpl::vector9<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8> types;
1543         typedef vector_tag fusion_tag;
1544         typedef fusion_sequence_tag tag;
1545         typedef mpl::false_ is_view;
1546         typedef random_access_traversal_tag category;
1547         typedef mpl::int_<9> size;
1548         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1549         vector9() {}
1550 # if !defined(BOOST_CLANG)
1551     BOOST_CONSTEXPR
1552 # endif
1553         BOOST_FUSION_GPU_ENABLED
1554         vector9(
1555             typename detail::call_param<T0 >::type arg0 , typename detail::call_param<T1 >::type arg1 , typename detail::call_param<T2 >::type arg2 , typename detail::call_param<T3 >::type arg3 , typename detail::call_param<T4 >::type arg4 , typename detail::call_param<T5 >::type arg5 , typename detail::call_param<T6 >::type arg6 , typename detail::call_param<T7 >::type arg7 , typename detail::call_param<T8 >::type arg8)
1556             : base_type(arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8) {}
1557 # if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
1558         template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8>
1559 # if !defined(BOOST_CLANG)
1560         BOOST_CXX14_CONSTEXPR
1561 # endif
1562         BOOST_FUSION_GPU_ENABLED
1563         vector9(U0 && arg0 , U1 && arg1 , U2 && arg2 , U3 && arg3 , U4 && arg4 , U5 && arg5 , U6 && arg6 , U7 && arg7 , U8 && arg8)
1564             : base_type(std::forward<U0>( arg0) , std::forward<U1>( arg1) , std::forward<U2>( arg2) , std::forward<U3>( arg3) , std::forward<U4>( arg4) , std::forward<U5>( arg5) , std::forward<U6>( arg6) , std::forward<U7>( arg7) , std::forward<U8>( arg8)) {}
1565         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1566         vector9(vector9&& rhs)
1567             : base_type(std::forward<base_type>(rhs)) {}
1568         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1569         vector9(vector9 const& rhs)
1570             : base_type(static_cast<base_type const&>(rhs)) {}
1571         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1572         vector9&
1573         operator=(vector9 const& vec)
1574         {
1575             base_type::operator=(vec);
1576             return *this;
1577         }
1578         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1579         vector9&
1580         operator=(vector9&& vec)
1581         {
1582             this->m0 = std::forward< T0>(vec.m0); this->m1 = std::forward< T1>(vec.m1); this->m2 = std::forward< T2>(vec.m2); this->m3 = std::forward< T3>(vec.m3); this->m4 = std::forward< T4>(vec.m4); this->m5 = std::forward< T5>(vec.m5); this->m6 = std::forward< T6>(vec.m6); this->m7 = std::forward< T7>(vec.m7); this->m8 = std::forward< T8>(vec.m8);
1583             return *this;
1584         }
1585 # endif
1586         template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8>
1587 # if !defined(BOOST_CLANG)
1588     BOOST_CXX14_CONSTEXPR
1589 # endif
1590         BOOST_FUSION_GPU_ENABLED
1591         vector9(
1592             vector9<U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7 , U8> const& vec)
1593             : base_type(vec.m0 , vec.m1 , vec.m2 , vec.m3 , vec.m4 , vec.m5 , vec.m6 , vec.m7 , vec.m8) {}
1594         template <typename Sequence>
1595 # if !defined(BOOST_CLANG)
1596         BOOST_CXX14_CONSTEXPR
1597 # endif
1598         BOOST_FUSION_GPU_ENABLED
1599         vector9(
1600             Sequence const& seq
1601           , typename boost::enable_if<traits::is_sequence<Sequence> >::type* = 0
1602             )
1603             : base_type(base_type::init_from_sequence(seq)) {}
1604         template <typename Sequence>
1605 # if !defined(BOOST_CLANG)
1606         BOOST_CXX14_CONSTEXPR
1607 # endif
1608         BOOST_FUSION_GPU_ENABLED
1609         vector9(
1610             Sequence& seq
1611           , typename boost::enable_if<traits::is_sequence<Sequence> >::type* = 0
1612             )
1613             : base_type(base_type::init_from_sequence(seq)) {}
1614         template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8>
1615         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1616         vector9&
1617         operator=(vector9<U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7 , U8> const& vec)
1618         {
1619             this->m0 = vec.m0; this->m1 = vec.m1; this->m2 = vec.m2; this->m3 = vec.m3; this->m4 = vec.m4; this->m5 = vec.m5; this->m6 = vec.m6; this->m7 = vec.m7; this->m8 = vec.m8;
1620             return *this;
1621         }
1622         template <typename Sequence>
1623         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1624         typename boost::disable_if<is_convertible<Sequence, T0>, this_type&>::type
1625         operator=(Sequence const& seq)
1626         {
1627             typedef typename result_of::begin<Sequence const>::type I0;
1628             I0 i0 = fusion::begin(seq);
1629             typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0); typedef typename result_of::next< I1>::type I2; I2 i2 = fusion::next(i1); typedef typename result_of::next< I2>::type I3; I3 i3 = fusion::next(i2); typedef typename result_of::next< I3>::type I4; I4 i4 = fusion::next(i3); typedef typename result_of::next< I4>::type I5; I5 i5 = fusion::next(i4); typedef typename result_of::next< I5>::type I6; I6 i6 = fusion::next(i5); typedef typename result_of::next< I6>::type I7; I7 i7 = fusion::next(i6); typedef typename result_of::next< I7>::type I8; I8 i8 = fusion::next(i7);
1630             this->m0 = *i0; this->m1 = *i1; this->m2 = *i2; this->m3 = *i3; this->m4 = *i4; this->m5 = *i5; this->m6 = *i6; this->m7 = *i7; this->m8 = *i8;
1631             return *this;
1632         }
1633         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T0>::type at_impl(mpl::int_<0>) { return this->m0; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T0>::type>::type at_impl(mpl::int_<0>) const { return this->m0; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T1>::type at_impl(mpl::int_<1>) { return this->m1; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T1>::type>::type at_impl(mpl::int_<1>) const { return this->m1; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T2>::type at_impl(mpl::int_<2>) { return this->m2; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T2>::type>::type at_impl(mpl::int_<2>) const { return this->m2; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T3>::type at_impl(mpl::int_<3>) { return this->m3; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T3>::type>::type at_impl(mpl::int_<3>) const { return this->m3; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T4>::type at_impl(mpl::int_<4>) { return this->m4; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T4>::type>::type at_impl(mpl::int_<4>) const { return this->m4; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T5>::type at_impl(mpl::int_<5>) { return this->m5; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T5>::type>::type at_impl(mpl::int_<5>) const { return this->m5; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T6>::type at_impl(mpl::int_<6>) { return this->m6; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T6>::type>::type at_impl(mpl::int_<6>) const { return this->m6; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T7>::type at_impl(mpl::int_<7>) { return this->m7; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T7>::type>::type at_impl(mpl::int_<7>) const { return this->m7; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T8>::type at_impl(mpl::int_<8>) { return this->m8; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T8>::type>::type at_impl(mpl::int_<8>) const { return this->m8; }
1634         template<typename I>
1635         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1636         typename add_reference<typename mpl::at<types, I>::type>::type
1637         at_impl(I)
1638         {
1639             return this->at_impl(mpl::int_<I::value>());
1640         }
1641         template<typename I>
1642         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1643         typename add_reference<typename add_const<typename mpl::at<types, I>::type>::type>::type
1644         at_impl(I) const
1645         {
1646             return this->at_impl(mpl::int_<I::value>());
1647         }
1648     };
1649     template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
1650     struct vector_data10
1651     {
1652         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1653         vector_data10()
1654             : m0() , m1() , m2() , m3() , m4() , m5() , m6() , m7() , m8() , m9() {}
1655 # if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
1656         template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8 , typename U9>
1657 # if !defined(BOOST_CLANG)
1658         BOOST_CXX14_CONSTEXPR
1659 # endif
1660         BOOST_FUSION_GPU_ENABLED
1661         vector_data10(U0 && arg0 , U1 && arg1 , U2 && arg2 , U3 && arg3 , U4 && arg4 , U5 && arg5 , U6 && arg6 , U7 && arg7 , U8 && arg8 , U9 && arg9
1662           , typename boost::enable_if<is_convertible<U0, T0> >::type* = 0
1663         )
1664             : m0(std::forward<U0>( arg0)) , m1(std::forward<U1>( arg1)) , m2(std::forward<U2>( arg2)) , m3(std::forward<U3>( arg3)) , m4(std::forward<U4>( arg4)) , m5(std::forward<U5>( arg5)) , m6(std::forward<U6>( arg6)) , m7(std::forward<U7>( arg7)) , m8(std::forward<U8>( arg8)) , m9(std::forward<U9>( arg9)) {}
1665         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1666         vector_data10(
1667             vector_data10&& other)
1668             : m0(std::forward<T0>( other.m0)) , m1(std::forward<T1>( other.m1)) , m2(std::forward<T2>( other.m2)) , m3(std::forward<T3>( other.m3)) , m4(std::forward<T4>( other.m4)) , m5(std::forward<T5>( other.m5)) , m6(std::forward<T6>( other.m6)) , m7(std::forward<T7>( other.m7)) , m8(std::forward<T8>( other.m8)) , m9(std::forward<T9>( other.m9)) {}
1669 # endif
1670 # if !defined(BOOST_CLANG)
1671     BOOST_CONSTEXPR
1672 # endif
1673         BOOST_FUSION_GPU_ENABLED
1674         vector_data10(
1675             typename detail::call_param<T0 >::type arg0 , typename detail::call_param<T1 >::type arg1 , typename detail::call_param<T2 >::type arg2 , typename detail::call_param<T3 >::type arg3 , typename detail::call_param<T4 >::type arg4 , typename detail::call_param<T5 >::type arg5 , typename detail::call_param<T6 >::type arg6 , typename detail::call_param<T7 >::type arg7 , typename detail::call_param<T8 >::type arg8 , typename detail::call_param<T9 >::type arg9)
1676             : m0(arg0) , m1(arg1) , m2(arg2) , m3(arg3) , m4(arg4) , m5(arg5) , m6(arg6) , m7(arg7) , m8(arg8) , m9(arg9) {}
1677         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1678         vector_data10(
1679             vector_data10 const& other)
1680             : m0(other.m0) , m1(other.m1) , m2(other.m2) , m3(other.m3) , m4(other.m4) , m5(other.m5) , m6(other.m6) , m7(other.m7) , m8(other.m8) , m9(other.m9) {}
1681         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1682         vector_data10&
1683         operator=(vector_data10 const& vec)
1684         {
1685             this->m0 = vec.m0; this->m1 = vec.m1; this->m2 = vec.m2; this->m3 = vec.m3; this->m4 = vec.m4; this->m5 = vec.m5; this->m6 = vec.m6; this->m7 = vec.m7; this->m8 = vec.m8; this->m9 = vec.m9;
1686             return *this;
1687         }
1688         template <typename Sequence>
1689 # if !defined(BOOST_CLANG)
1690     BOOST_CXX14_CONSTEXPR
1691 # endif
1692         BOOST_FUSION_GPU_ENABLED
1693         static vector_data10
1694         init_from_sequence(Sequence const& seq)
1695         {
1696             typedef typename result_of::begin<Sequence const>::type I0;
1697             I0 i0 = fusion::begin(seq);
1698             typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0); typedef typename result_of::next< I1>::type I2; I2 i2 = fusion::next(i1); typedef typename result_of::next< I2>::type I3; I3 i3 = fusion::next(i2); typedef typename result_of::next< I3>::type I4; I4 i4 = fusion::next(i3); typedef typename result_of::next< I4>::type I5; I5 i5 = fusion::next(i4); typedef typename result_of::next< I5>::type I6; I6 i6 = fusion::next(i5); typedef typename result_of::next< I6>::type I7; I7 i7 = fusion::next(i6); typedef typename result_of::next< I7>::type I8; I8 i8 = fusion::next(i7); typedef typename result_of::next< I8>::type I9; I9 i9 = fusion::next(i8);
1699             return vector_data10(*i0 , *i1 , *i2 , *i3 , *i4 , *i5 , *i6 , *i7 , *i8 , *i9);
1700         }
1701         template <typename Sequence>
1702 # if !defined(BOOST_CLANG)
1703     BOOST_CXX14_CONSTEXPR
1704 # endif
1705         BOOST_FUSION_GPU_ENABLED
1706         static vector_data10
1707         init_from_sequence(Sequence& seq)
1708         {
1709             typedef typename result_of::begin<Sequence>::type I0;
1710             I0 i0 = fusion::begin(seq);
1711             typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0); typedef typename result_of::next< I1>::type I2; I2 i2 = fusion::next(i1); typedef typename result_of::next< I2>::type I3; I3 i3 = fusion::next(i2); typedef typename result_of::next< I3>::type I4; I4 i4 = fusion::next(i3); typedef typename result_of::next< I4>::type I5; I5 i5 = fusion::next(i4); typedef typename result_of::next< I5>::type I6; I6 i6 = fusion::next(i5); typedef typename result_of::next< I6>::type I7; I7 i7 = fusion::next(i6); typedef typename result_of::next< I7>::type I8; I8 i8 = fusion::next(i7); typedef typename result_of::next< I8>::type I9; I9 i9 = fusion::next(i8);
1712             return vector_data10(*i0 , *i1 , *i2 , *i3 , *i4 , *i5 , *i6 , *i7 , *i8 , *i9);
1713         }
1714         T0 m0; T1 m1; T2 m2; T3 m3; T4 m4; T5 m5; T6 m6; T7 m7; T8 m8; T9 m9;
1715     };
1716     template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
1717     struct vector10
1718       : vector_data10<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>
1719       , sequence_base<vector10<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9> >
1720     {
1721         typedef vector10<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9> this_type;
1722         typedef vector_data10<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9> base_type;
1723         typedef mpl::vector10<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9> types;
1724         typedef vector_tag fusion_tag;
1725         typedef fusion_sequence_tag tag;
1726         typedef mpl::false_ is_view;
1727         typedef random_access_traversal_tag category;
1728         typedef mpl::int_<10> size;
1729         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1730         vector10() {}
1731 # if !defined(BOOST_CLANG)
1732     BOOST_CONSTEXPR
1733 # endif
1734         BOOST_FUSION_GPU_ENABLED
1735         vector10(
1736             typename detail::call_param<T0 >::type arg0 , typename detail::call_param<T1 >::type arg1 , typename detail::call_param<T2 >::type arg2 , typename detail::call_param<T3 >::type arg3 , typename detail::call_param<T4 >::type arg4 , typename detail::call_param<T5 >::type arg5 , typename detail::call_param<T6 >::type arg6 , typename detail::call_param<T7 >::type arg7 , typename detail::call_param<T8 >::type arg8 , typename detail::call_param<T9 >::type arg9)
1737             : base_type(arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9) {}
1738 # if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
1739         template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8 , typename U9>
1740 # if !defined(BOOST_CLANG)
1741         BOOST_CXX14_CONSTEXPR
1742 # endif
1743         BOOST_FUSION_GPU_ENABLED
1744         vector10(U0 && arg0 , U1 && arg1 , U2 && arg2 , U3 && arg3 , U4 && arg4 , U5 && arg5 , U6 && arg6 , U7 && arg7 , U8 && arg8 , U9 && arg9)
1745             : base_type(std::forward<U0>( arg0) , std::forward<U1>( arg1) , std::forward<U2>( arg2) , std::forward<U3>( arg3) , std::forward<U4>( arg4) , std::forward<U5>( arg5) , std::forward<U6>( arg6) , std::forward<U7>( arg7) , std::forward<U8>( arg8) , std::forward<U9>( arg9)) {}
1746         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1747         vector10(vector10&& rhs)
1748             : base_type(std::forward<base_type>(rhs)) {}
1749         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1750         vector10(vector10 const& rhs)
1751             : base_type(static_cast<base_type const&>(rhs)) {}
1752         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1753         vector10&
1754         operator=(vector10 const& vec)
1755         {
1756             base_type::operator=(vec);
1757             return *this;
1758         }
1759         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1760         vector10&
1761         operator=(vector10&& vec)
1762         {
1763             this->m0 = std::forward< T0>(vec.m0); this->m1 = std::forward< T1>(vec.m1); this->m2 = std::forward< T2>(vec.m2); this->m3 = std::forward< T3>(vec.m3); this->m4 = std::forward< T4>(vec.m4); this->m5 = std::forward< T5>(vec.m5); this->m6 = std::forward< T6>(vec.m6); this->m7 = std::forward< T7>(vec.m7); this->m8 = std::forward< T8>(vec.m8); this->m9 = std::forward< T9>(vec.m9);
1764             return *this;
1765         }
1766 # endif
1767         template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8 , typename U9>
1768 # if !defined(BOOST_CLANG)
1769     BOOST_CXX14_CONSTEXPR
1770 # endif
1771         BOOST_FUSION_GPU_ENABLED
1772         vector10(
1773             vector10<U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7 , U8 , U9> const& vec)
1774             : base_type(vec.m0 , vec.m1 , vec.m2 , vec.m3 , vec.m4 , vec.m5 , vec.m6 , vec.m7 , vec.m8 , vec.m9) {}
1775         template <typename Sequence>
1776 # if !defined(BOOST_CLANG)
1777         BOOST_CXX14_CONSTEXPR
1778 # endif
1779         BOOST_FUSION_GPU_ENABLED
1780         vector10(
1781             Sequence const& seq
1782           , typename boost::enable_if<traits::is_sequence<Sequence> >::type* = 0
1783             )
1784             : base_type(base_type::init_from_sequence(seq)) {}
1785         template <typename Sequence>
1786 # if !defined(BOOST_CLANG)
1787         BOOST_CXX14_CONSTEXPR
1788 # endif
1789         BOOST_FUSION_GPU_ENABLED
1790         vector10(
1791             Sequence& seq
1792           , typename boost::enable_if<traits::is_sequence<Sequence> >::type* = 0
1793             )
1794             : base_type(base_type::init_from_sequence(seq)) {}
1795         template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8 , typename U9>
1796         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1797         vector10&
1798         operator=(vector10<U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7 , U8 , U9> const& vec)
1799         {
1800             this->m0 = vec.m0; this->m1 = vec.m1; this->m2 = vec.m2; this->m3 = vec.m3; this->m4 = vec.m4; this->m5 = vec.m5; this->m6 = vec.m6; this->m7 = vec.m7; this->m8 = vec.m8; this->m9 = vec.m9;
1801             return *this;
1802         }
1803         template <typename Sequence>
1804         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1805         typename boost::disable_if<is_convertible<Sequence, T0>, this_type&>::type
1806         operator=(Sequence const& seq)
1807         {
1808             typedef typename result_of::begin<Sequence const>::type I0;
1809             I0 i0 = fusion::begin(seq);
1810             typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0); typedef typename result_of::next< I1>::type I2; I2 i2 = fusion::next(i1); typedef typename result_of::next< I2>::type I3; I3 i3 = fusion::next(i2); typedef typename result_of::next< I3>::type I4; I4 i4 = fusion::next(i3); typedef typename result_of::next< I4>::type I5; I5 i5 = fusion::next(i4); typedef typename result_of::next< I5>::type I6; I6 i6 = fusion::next(i5); typedef typename result_of::next< I6>::type I7; I7 i7 = fusion::next(i6); typedef typename result_of::next< I7>::type I8; I8 i8 = fusion::next(i7); typedef typename result_of::next< I8>::type I9; I9 i9 = fusion::next(i8);
1811             this->m0 = *i0; this->m1 = *i1; this->m2 = *i2; this->m3 = *i3; this->m4 = *i4; this->m5 = *i5; this->m6 = *i6; this->m7 = *i7; this->m8 = *i8; this->m9 = *i9;
1812             return *this;
1813         }
1814         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T0>::type at_impl(mpl::int_<0>) { return this->m0; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T0>::type>::type at_impl(mpl::int_<0>) const { return this->m0; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T1>::type at_impl(mpl::int_<1>) { return this->m1; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T1>::type>::type at_impl(mpl::int_<1>) const { return this->m1; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T2>::type at_impl(mpl::int_<2>) { return this->m2; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T2>::type>::type at_impl(mpl::int_<2>) const { return this->m2; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T3>::type at_impl(mpl::int_<3>) { return this->m3; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T3>::type>::type at_impl(mpl::int_<3>) const { return this->m3; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T4>::type at_impl(mpl::int_<4>) { return this->m4; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T4>::type>::type at_impl(mpl::int_<4>) const { return this->m4; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T5>::type at_impl(mpl::int_<5>) { return this->m5; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T5>::type>::type at_impl(mpl::int_<5>) const { return this->m5; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T6>::type at_impl(mpl::int_<6>) { return this->m6; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T6>::type>::type at_impl(mpl::int_<6>) const { return this->m6; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T7>::type at_impl(mpl::int_<7>) { return this->m7; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T7>::type>::type at_impl(mpl::int_<7>) const { return this->m7; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T8>::type at_impl(mpl::int_<8>) { return this->m8; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T8>::type>::type at_impl(mpl::int_<8>) const { return this->m8; } BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<T9>::type at_impl(mpl::int_<9>) { return this->m9; } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED typename add_reference<typename add_const<T9>::type>::type at_impl(mpl::int_<9>) const { return this->m9; }
1815         template<typename I>
1816         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1817         typename add_reference<typename mpl::at<types, I>::type>::type
1818         at_impl(I)
1819         {
1820             return this->at_impl(mpl::int_<I::value>());
1821         }
1822         template<typename I>
1823         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
1824         typename add_reference<typename add_const<typename mpl::at<types, I>::type>::type>::type
1825         at_impl(I) const
1826         {
1827             return this->at_impl(mpl::int_<I::value>());
1828         }
1829     };
1830 }}