namespace boost_concept{
     template <  typename Iterator    > struct ReadableIterator; template <  typename Iterator    > struct ReadableIteratorConcept : ReadableIterator< Iterator > { }; template <  typename Iterator    > struct ReadableIterato    : boost::Assignable<Iterator    , boost::CopyConstructible<Iterator
  {
      typedef typename boost::detail::iterator_traits<Iterator>::value_type value_type;
      typedef typename boost::detail::iterator_traits<Iterator>::reference reference;

      enum { boost_concept_check50 = sizeof(::boost::concept::require_((void(*)(boost::concept::usage_requirements<ReadableIterator>))0)) }; ~ReadableIterator()
      {

          value_type v = *i;
          boost::ignore_unused_variable_warning(v);
      }
  private      Iterator i;
  };
   template       typename Iterato    , typename ValueType = typename boost::detail::iterator_traits<Iterator>::value_type
    struct WritableIterato    : boost::CopyConstructible<Iterator  {
      enum { boost_concept_check67 = sizeof(::boost::concept::require_((void(*)(boost::concept::usage_requirements<WritableIterator>))0)) }; ~WritableIterator()
      {
          *i = v;
      }
  private      ValueType v;
      Iterator i;
  };

  template       typename Iterato    , typename ValueType = typename boost::detail::iterator_traits<Iterator>::value_type
    struct WritableIteratorConcept : WritableIterator<Iterator,ValueType> {};
   template <  typename Iterator    > struct SwappableIterator; template <  typename Iterator    > struct SwappableIteratorConcept : SwappableIterator< Iterator > { }; template <  typename Iterator    > struct SwappableIterato  {
      enum { boost_concept_check84 = sizeof(::boost::concept::require_((void(*)(boost::concept::usage_requirements<SwappableIterator>))0)) }; ~SwappableIterator()
      {
          std::iter_swap(i1, i2);
      }
  private      Iterator i1;
      Iterator i2;
  };

  template <  typename Iterator    > struct LvalueIterator; template <  typename Iterator    > struct LvalueIteratorConcept : LvalueIterator< Iterator > { }; template <  typename Iterator    > struct LvalueIterato  {
      typedef typename boost::detail::iterator_traits<Iterator>::value_type value_type;
           enum { boost_concept_check97 = sizeof(::boost::concept::require_((void(*)(boost::concept::usage_requirements<LvalueIterator>))0)) }; ~LvalueIterator()
      {
        value_type& r = const_cast<value_type&>(*i);
        boost::ignore_unused_variable_warning(r);
      }
  private      Iterator i;
  };

    template <  typename Iterator    > struct IncrementableIterator; template <  typename Iterator    > struct IncrementableIteratorConcept : IncrementableIterator< Iterator > { }; template <  typename Iterator    > struct IncrementableIterato    : boost::Assignable<Iterator    , boost::CopyConstructible<Iterator  {
      typedef typename boost::iterator_traversal<Iterator>::type traversal_category;

      enum { boost_concept_check120 = sizeof(::boost::concept::require_((void(*)( boost::Convertible< traversal_category , boost::incrementable_traversal_tag >))0)) };


      enum { boost_concept_check122 = sizeof(::boost::concept::require_((void(*)(boost::concept::usage_requirements<IncrementableIterator>))0)) }; ~IncrementableIterator()
      {
          ++i;
          (void)i++;
      }
  private      Iterator i;
  };

  template <  typename Iterator    > struct SinglePassIterator; template <  typename Iterator    > struct SinglePassIteratorConcept : SinglePassIterator< Iterator > { }; template <  typename Iterator    > struct SinglePassIterato    : IncrementableIterator<Iterator    , boost::EqualityComparable<Iterator
  {
      enum { boost_concept_check140 = sizeof(::boost::concept::require_((void(*)( boost::Convertible< typename SinglePassIterator::traversal_category , boost::single_pass_traversal_tag > ))0)) };

  };

  template <  typename Iterator    > struct ForwardTraversal; template <  typename Iterator    > struct ForwardTraversalConcept : ForwardTraversal< Iterator > { }; template <  typename Iterator    > struct ForwardTraversa    : SinglePassIterator<Iterator    , boost::DefaultConstructible<Iterator  {
      typedef typename boost::detail::iterator_traits<Iterator>::difference_type difference_type;
           static const std::size_t mpl_assertion_in_line_14 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_arg( (void (*) (boost::is_integral<difference_type>))0, 1 ) ) );
      static const std::size_t mpl_assertion_in_line_15 = sizeof( boost::mpl::assertion_failed<(std::numeric_limits<difference_type>::is_signed == true)>( (boost::mpl::failed ************ ( boost::mpl::assert_relation<std::numeric_limits<difference_type>::is_signed,true,(&boost::mpl::operator ==)>::************))0 ) );

      enum { boost_concept_check156 = sizeof(::boost::concept::require_((void(*)( boost::Convertible< typename ForwardTraversal::traversal_category , boost::forward_traversal_tag > ))0)) };

  };
   template <  typename Iterator    > struct BidirectionalTraversal; template <  typename Iterator    > struct BidirectionalTraversalConcept : BidirectionalTraversal< Iterator > { }; template <  typename Iterator    > struct BidirectionalTraversa    : ForwardTraversal<Iterator  {
      enum { boost_concept_check166 = sizeof(::boost::concept::require_((void(*)( boost::Convertible< typename BidirectionalTraversal::traversal_category , boost::bidirectional_traversal_tag > ))0)) };


      enum { boost_concept_check168 = sizeof(::boost::concept::require_((void(*)(boost::concept::usage_requirements<BidirectionalTraversal>))0)) }; ~BidirectionalTraversal()
      {
          --i;
          (void)i--;
      }
   private      Iterator i;
  };

  template <  typename Iterator    > struct RandomAccessTraversal; template <  typename Iterator    > struct RandomAccessTraversalConcept : RandomAccessTraversal< Iterator > { }; template <  typename Iterator    > struct RandomAccessTraversa    : BidirectionalTraversal<Iterator  {
      enum { boost_concept_check184 = sizeof(::boost::concept::require_((void(*)( boost::Convertible< typename RandomAccessTraversal::traversal_category , boost::random_access_traversal_tag > ))0)) };


      enum { boost_concept_check186 = sizeof(::boost::concept::require_((void(*)(boost::concept::usage_requirements<RandomAccessTraversal>))0)) }; ~RandomAccessTraversal()
      {
          i += n;
          i = i + n;
          i = n + i;
          i -= n;
          i = i - n;
          n = i - j;
      }
        private      typename BidirectionalTraversal<Iterator>::difference_type n;
      Iterator i, j;
  };

   namespace detai  {
    template <typename Iterator1, typename Iterator2    void interop_single_pass_constraints(Iterator1 const& i1, Iterator2 const& i2)
    {
        bool b;
        b = i1 == i2;
        b = i1 != i2;

        b = i2 == i1;
        b = i2 != i1;
        boost::ignore_unused_variable_warning(b);
    }

    template <typename Iterator1, typename Iterator2    void interop_rand_access_constraints(
        Iterator1 const& i1, Iterator2 const& i2        boost::random_access_traversal_tag, boost::random_access_traversal_tag)
    {
        bool b;
        typename boost::detail::iterator_traits<Iterator2>::difference_type n;
        b = i1 <  i2;
        b = i1 <= i2;
        b = i1 >  i2;
        b = i1 >= i2;
        n = i1 -  i2;

        b = i2 <  i1;
        b = i2 <= i1;
        b = i2 >  i1;
        b = i2 >= i1;
        n = i2 -  i1;
        boost::ignore_unused_variable_warning(b);
        boost::ignore_unused_variable_warning(n);
    }

    template <typename Iterator1, typename Iterator2    void interop_rand_access_constraints(
        Iterator1 const&, Iterator2 const&        boost::single_pass_traversal_tag, boost::single_pass_traversal_tag)
    { }

  }
  template <  typename Iterator  , typename ConstIterator    > struct InteroperableIterator; template <  typename Iterator  , typename ConstIterator    > struct InteroperableIteratorConcept : InteroperableIterator< Iterator, ConstIterator > { }; template <  typename Iterator  , typename ConstIterator    > struct InteroperableIterato  {
   private      typedef typename boost::detail::pure_traversal_tag          typename boost::iterator_traversal              Iterato          >::type
      >::type traversal_category;

      typedef typename boost::detail::pure_traversal_tag          typename boost::iterator_traversal              ConstIterato          >::type
      >::type const_traversal_category;
       public      enum { boost_concept_check264 = sizeof(::boost::concept::require_((void(*)(SinglePassIterator<Iterator>))0)) };
      enum { boost_concept_check265 = sizeof(::boost::concept::require_((void(*)(SinglePassIterator<ConstIterator>))0)) };

      enum { boost_concept_check267 = sizeof(::boost::concept::require_((void(*)(boost::concept::usage_requirements<InteroperableIterator>))0)) }; ~InteroperableIterator()
      {
          detail::interop_single_pass_constraints(i, ci);
          detail::interop_rand_access_constraints(i, ci, traversal_category(), const_traversal_category());

          ci = i;
      }
        private      Iterator      i;
      ConstIterator ci;
  };

}

namespace boost {
namespace detail {
namespace multi_array {

           template <std::size_t N  struct idgen_helper {

    template <typename Array, typename IdxGen, typename Call_Type    static void call(Array& a, const IdxGen& idgen, Call_Type c) {
      typedef typename Array::index_range index_range;
      typedef typename Array::index index;
      idgen_helper<N-1>::call(a,idgen[c],c);
    }
  };

  template <  struct idgen_helper<0> {

    template <typename Array, typename IdxGen, typename Call_Type    static void call(Array& a, const IdxGen& idgen, Call_Type) {
      typedef typename Array::index_range index_range;
      typedef typename Array::index index;
      a[ idgen ];
    }
  };


  template <typename Array, std::size_t NumDims   struct ConstMultiArrayConcep  {
    void constraints() {
       function_requires< boost_concepts::ForwardTraversalConcept<iterator> >();
    function_requires< boost_concepts::ReadableIteratorConcept<iterator> >();
    function_requires< boost_concepts::ForwardTraversalConcept<const_iterator> >();
    function_requires< boost_concepts::ReadableIteratorConcept<const_iterator> >();

           a[ id ];
           idgen_helper<NumDims-1>::call(a,idgen[range],id);

           idgen_helper<NumDims-1>::call(a,idgen[range],range);

      st = a.size();
      st = a.num_dimensions();
      st = Array::dimensionality;
      st = a.num_elements();
      stp = a.shape();
      idp = a.strides();
      idp = a.index_bases();
      cit = a.begin();
      cit = a.end();
      crit = a.rbegin();
      crit = a.rend();
      eltp = a.origin();
    }

    typedef typename Array::value_type value_type;
    typedef typename Array::reference reference;
    typedef typename Array::const_reference const_reference;
    typedef typename Array::size_type size_type;
    typedef typename Array::difference_type difference_type;
    typedef typename Array::iterator iterator;
    typedef typename Array::const_iterator const_iterator;
    typedef typename Array::reverse_iterator reverse_iterator;
    typedef typename Array::const_reverse_iterator const_reverse_iterator;
    typedef typename Array::element element;
    typedef typename Array::index index;
    typedef typename Array::index_gen index_gen;
    typedef typename Array::index_range index_range;
    typedef typename Array::extent_gen extent_gen;
    typedef typename Array::extent_range extent_range;

    Array a;
    size_type st;
    const size_type* stp;
    index id;
    const index* idp;
    const_iterator cit;
    const_reverse_iterator crit;
    const element* eltp;
    index_gen idgen;
    index_range range;
  };


  template <typename Array, std::size_t NumDims   struct MutableMultiArrayConcep  {
    void constraints() {
          function_requires< boost_concepts::ForwardTraversalConcept<iterator> >();
      function_requires< boost_concepts::ReadableIteratorConcept<iterator> >();
      function_requires< boost_concepts::WritableIteratorConcept<iterator> >();
      function_requires< boost_concepts::ForwardTraversalConcept<const_iterator> >();
      function_requires< boost_concepts::ReadableIteratorConcept<const_iterator> >();
                value_type vt = a[ id ];

           idgen_helper<NumDims-1>::call(a,idgen[range],id);

           idgen_helper<NumDims-1>::call(a,idgen[range],range);

      st = a.size();
      st = a.num_dimensions();
      st = a.num_elements();
      stp = a.shape();
      idp = a.strides();
      idp = a.index_bases();
      it = a.begin();
      it = a.end();
      rit = a.rbegin();
      rit = a.rend();
      eltp = a.origin();
      const_constraints(a);
    }

    void const_constraints(const Array& a) {

               idgen_helper<NumDims-1>::call(a,idgen[range],id);

           idgen_helper<NumDims-1>::call(a,idgen[range],range);

      st = a.size();
      st = a.num_dimensions();
      st = a.num_elements();
      stp = a.shape();
      idp = a.strides();
      idp = a.index_bases();
      cit = a.begin();
      cit = a.end();
      crit = a.rbegin();
      crit = a.rend();
      eltp = a.origin();
    }

    typedef typename Array::value_type value_type;
    typedef typename Array::reference reference;
    typedef typename Array::const_reference const_reference;
    typedef typename Array::size_type size_type;
    typedef typename Array::difference_type difference_type;
    typedef typename Array::iterator iterator;
    typedef typename Array::const_iterator const_iterator;
    typedef typename Array::reverse_iterator reverse_iterator;
    typedef typename Array::const_reverse_iterator const_reverse_iterator;
    typedef typename Array::element element;
    typedef typename Array::index index;
    typedef typename Array::index_gen index_gen;
    typedef typename Array::index_range index_range;
    typedef typename Array::extent_gen extent_gen;
    typedef typename Array::extent_range extent_range;

    Array a;
    size_type st;
    const size_type* stp;
    index id;
    const index* idp;
    iterator it;
    const_iterator cit;
    reverse_iterator rit;
    const_reverse_iterator crit;
    const element* eltp;
    index_gen idgen;
    index_range range;
  };


}}}