namespace boost {
  namespace compute {
    template<typename InputIterator, typename T, typename BinaryFunction> 
      T accumulate(InputIterator, InputIterator, T, BinaryFunction, 
                   command_queue & = system::default_queue());
    template<typename InputIterator, typename T> 
      T accumulate(InputIterator, InputIterator, T, 
                   command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator, typename OutputIterator, 
             typename BinaryFunction> 
      OutputIterator 
      adjacent_difference(InputIterator, InputIterator, OutputIterator, 
                          BinaryFunction, 
                          command_queue & = system::default_queue());
    template<typename InputIterator, typename OutputIterator> 
      OutputIterator 
      adjacent_difference(InputIterator, InputIterator, OutputIterator, 
                          command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator, typename Compare> 
      InputIterator 
      adjacent_find(InputIterator, InputIterator, Compare, 
                    command_queue & = system::default_queue());
    template<typename InputIterator> 
      InputIterator 
      adjacent_find(InputIterator, InputIterator, 
                    command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator, typename UnaryPredicate> 
      bool all_of(InputIterator, InputIterator, UnaryPredicate, 
                  command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator, typename UnaryPredicate> 
      bool any_of(InputIterator, InputIterator, UnaryPredicate, 
                  command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator, typename T> 
      bool binary_search(InputIterator, InputIterator, const T &, 
                         command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator, typename OutputIterator> 
      OutputIterator 
      copy(InputIterator, InputIterator, OutputIterator, 
           command_queue & = system::default_queue(), 
           const wait_list & = wait_list());
    template<typename InputIterator, typename OutputIterator> 
      future< OutputIterator > 
      copy_async(InputIterator, InputIterator, OutputIterator, 
                 command_queue & = system::default_queue(), 
                 const wait_list & = wait_list());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator, typename OutputIterator, 
             typename Predicate> 
      OutputIterator 
      copy_if(InputIterator, InputIterator, OutputIterator, Predicate, 
              command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator, typename Size, typename OutputIterator> 
      OutputIterator 
      copy_n(InputIterator, Size, OutputIterator, 
             command_queue & = system::default_queue(), 
             const wait_list & = wait_list());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator, typename T> 
      size_t count(InputIterator, InputIterator, const T &, 
                   command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator, typename Predicate> 
      size_t count_if(InputIterator, InputIterator, Predicate, 
                      command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator1, typename InputIterator2> 
      bool equal(InputIterator1, InputIterator1, InputIterator2, 
                 command_queue & = system::default_queue());
    template<typename InputIterator1, typename InputIterator2> 
      bool equal(InputIterator1, InputIterator1, InputIterator2, 
                 InputIterator2, command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator, typename T> 
      std::pair< InputIterator, InputIterator > 
      equal_range(InputIterator, InputIterator, const T &, 
                  command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator, typename OutputIterator, typename T, 
             typename BinaryOperator> 
      OutputIterator 
      exclusive_scan(InputIterator, InputIterator, OutputIterator, T, 
                     BinaryOperator, 
                     command_queue & = system::default_queue());
    template<typename InputIterator, typename OutputIterator, typename T> 
      OutputIterator 
      exclusive_scan(InputIterator, InputIterator, OutputIterator, T, 
                     command_queue & = system::default_queue());
    template<typename InputIterator, typename OutputIterator> 
      OutputIterator 
      exclusive_scan(InputIterator, InputIterator, OutputIterator, 
                     command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename BufferIterator, typename T> 
      void fill(BufferIterator, BufferIterator, const T &, 
                command_queue & = system::default_queue());
    template<typename BufferIterator, typename T> 
      future< void > 
      fill_async(BufferIterator first, BufferIterator last, const T & value, 
                 command_queue & queue = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename BufferIterator, typename Size, typename T> 
      void fill_n(BufferIterator, Size, const T &, 
                  command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator, typename T> 
      InputIterator 
      find(InputIterator, InputIterator, const T &, 
           command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename TextIterator, typename PatternIterator> 
      TextIterator 
      find_end(TextIterator, TextIterator, PatternIterator, PatternIterator, 
               command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator, typename UnaryPredicate> 
      InputIterator 
      find_if(InputIterator, InputIterator, UnaryPredicate, 
              command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator, typename UnaryPredicate> 
      InputIterator 
      find_if_not(InputIterator, InputIterator, UnaryPredicate, 
                  command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator, typename UnaryFunction> 
      UnaryFunction 
      for_each(InputIterator, InputIterator, UnaryFunction, 
               command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator, typename Size, typename UnaryFunction> 
      UnaryFunction 
      for_each_n(InputIterator, Size, UnaryFunction, 
                 command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator, typename MapIterator, 
             typename OutputIterator> 
      void gather(MapIterator, MapIterator, InputIterator, OutputIterator, 
                  command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename OutputIterator, typename Generator> 
      void generate(OutputIterator, OutputIterator, Generator, 
                    command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename OutputIterator, typename Size, typename Generator> 
      void generate_n(OutputIterator, Size, Generator, 
                      command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator1, typename InputIterator2> 
      bool includes(InputIterator1, InputIterator1, InputIterator2, 
                    InputIterator2, 
                    command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator, typename OutputIterator, 
             typename BinaryOperator> 
      OutputIterator 
      inclusive_scan(InputIterator, InputIterator, OutputIterator, 
                     BinaryOperator, 
                     command_queue & = system::default_queue());
    template<typename InputIterator, typename OutputIterator> 
      OutputIterator 
      inclusive_scan(InputIterator, InputIterator, OutputIterator, 
                     command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator1, typename InputIterator2, typename T> 
      T inner_product(InputIterator1, InputIterator1, InputIterator2, T, 
                      command_queue & = system::default_queue());
    template<typename InputIterator1, typename InputIterator2, typename T, 
             typename BinaryAccumulateFunction, 
             typename BinaryTransformFunction> 
      T inner_product(InputIterator1, InputIterator1, InputIterator2, T, 
                      BinaryAccumulateFunction, BinaryTransformFunction, 
                      command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename Iterator> 
      void inplace_merge(Iterator, Iterator, Iterator, 
                         command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename BufferIterator, typename T> 
      void iota(BufferIterator, BufferIterator, const T &, 
                command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator, typename UnaryPredicate> 
      bool is_partitioned(InputIterator, InputIterator, UnaryPredicate, 
                          command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator1, typename InputIterator2> 
      bool is_permutation(InputIterator1, InputIterator1, InputIterator2, 
                          InputIterator2, 
                          command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator, typename Compare> 
      bool is_sorted(InputIterator, InputIterator, Compare, 
                     command_queue & = system::default_queue());
    template<typename InputIterator> 
      bool is_sorted(InputIterator, InputIterator, 
                     command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator1, typename InputIterator2> 
      bool lexicographical_compare(InputIterator1, InputIterator1, 
                                   InputIterator2, InputIterator2, 
                                   command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator, typename T> 
      InputIterator 
      lower_bound(InputIterator, InputIterator, const T &, 
                  command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator, typename Compare> 
      InputIterator 
      max_element(InputIterator, InputIterator, Compare, 
                  command_queue & = system::default_queue());
    template<typename InputIterator> 
      InputIterator 
      max_element(InputIterator, InputIterator, 
                  command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator1, typename InputIterator2, 
             typename OutputIterator, typename Compare> 
      OutputIterator 
      merge(InputIterator1, InputIterator1, InputIterator2, InputIterator2, 
            OutputIterator, Compare, 
            command_queue & = system::default_queue());
    template<typename InputIterator1, typename InputIterator2, 
             typename OutputIterator> 
      OutputIterator 
      merge(InputIterator1, InputIterator1, InputIterator2, InputIterator2, 
            OutputIterator, command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator, typename Compare> 
      InputIterator 
      min_element(InputIterator, InputIterator, Compare, 
                  command_queue & = system::default_queue());
    template<typename InputIterator> 
      InputIterator 
      min_element(InputIterator, InputIterator, 
                  command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator, typename Compare> 
      std::pair< InputIterator, InputIterator > 
      minmax_element(InputIterator, InputIterator, Compare, 
                     command_queue & = system::default_queue());
    template<typename InputIterator> 
      std::pair< InputIterator, InputIterator > 
      minmax_element(InputIterator, InputIterator, 
                     command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator1, typename InputIterator2> 
      std::pair< InputIterator1, InputIterator2 > 
      mismatch(InputIterator1, InputIterator1, InputIterator2, 
               command_queue & = system::default_queue());
    template<typename InputIterator1, typename InputIterator2> 
      std::pair< InputIterator1, InputIterator2 > 
      mismatch(InputIterator1, InputIterator1, InputIterator2, InputIterator2, 
               command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator> 
      bool next_permutation(InputIterator, InputIterator, 
                            command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator, typename UnaryPredicate> 
      bool none_of(InputIterator, InputIterator, UnaryPredicate, 
                   command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename Iterator, typename Compare> 
      void nth_element(Iterator, Iterator, Iterator, Compare, 
                       command_queue & = system::default_queue());
    template<typename Iterator> 
      void nth_element(Iterator, Iterator, Iterator, 
                       command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator, typename OutputIterator> 
      OutputIterator 
      partial_sum(InputIterator, InputIterator, OutputIterator, 
                  command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename Iterator, typename UnaryPredicate> 
      Iterator partition(Iterator, Iterator, UnaryPredicate, 
                         command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator, typename OutputIterator1, 
             typename OutputIterator2, typename UnaryPredicate> 
      std::pair< OutputIterator1, OutputIterator2 > 
      partition_copy(InputIterator, InputIterator, OutputIterator1, 
                     OutputIterator2, UnaryPredicate, 
                     command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator, typename UnaryPredicate> 
      InputIterator 
      partition_point(InputIterator, InputIterator, UnaryPredicate, 
                      command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator> 
      bool prev_permutation(InputIterator, InputIterator, 
                            command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename Iterator> 
      void random_shuffle(Iterator, Iterator, 
                          command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator, typename OutputIterator, 
             typename BinaryFunction> 
      void reduce(InputIterator, InputIterator, OutputIterator, 
                  BinaryFunction, command_queue & = system::default_queue());
    template<typename InputIterator, typename OutputIterator> 
      void reduce(InputIterator, InputIterator, OutputIterator, 
                  command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename InputKeyIterator, typename InputValueIterator, 
             typename OutputKeyIterator, typename OutputValueIterator, 
             typename BinaryFunction, typename BinaryPredicate> 
      std::pair< OutputKeyIterator, OutputValueIterator > 
      reduce_by_key(InputKeyIterator, InputKeyIterator, InputValueIterator, 
                    OutputKeyIterator, OutputValueIterator, BinaryFunction, 
                    BinaryPredicate, 
                    command_queue & = system::default_queue());
    template<typename InputKeyIterator, typename InputValueIterator, 
             typename OutputKeyIterator, typename OutputValueIterator, 
             typename BinaryFunction> 
      std::pair< OutputKeyIterator, OutputValueIterator > 
      reduce_by_key(InputKeyIterator, InputKeyIterator, InputValueIterator, 
                    OutputKeyIterator, OutputValueIterator, BinaryFunction, 
                    command_queue & = system::default_queue());
    template<typename InputKeyIterator, typename InputValueIterator, 
             typename OutputKeyIterator, typename OutputValueIterator> 
      std::pair< OutputKeyIterator, OutputValueIterator > 
      reduce_by_key(InputKeyIterator, InputKeyIterator, InputValueIterator, 
                    OutputKeyIterator, OutputValueIterator, 
                    command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename Iterator, typename T> 
      Iterator remove(Iterator, Iterator, const T &, 
                      command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename Iterator, typename Predicate> 
      Iterator remove_if(Iterator, Iterator, Predicate, 
                         command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename Iterator, typename T> 
      void replace(Iterator, Iterator, const T &, const T &, 
                   command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator, typename OutputIterator, typename T> 
      OutputIterator 
      replace_copy(InputIterator, InputIterator, OutputIterator, const T &, 
                   const T &, command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename Iterator> 
      void reverse(Iterator, Iterator, 
                   command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator, typename OutputIterator> 
      OutputIterator 
      reverse_copy(InputIterator, InputIterator, OutputIterator, 
                   command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator> 
      void rotate(InputIterator, InputIterator, InputIterator, 
                  command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator, typename OutputIterator> 
      void rotate_copy(InputIterator, InputIterator, InputIterator, 
                       OutputIterator, 
                       command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator, typename MapIterator, 
             typename OutputIterator> 
      void scatter(InputIterator, InputIterator, MapIterator, OutputIterator, 
                   command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator, typename MapIterator, 
             typename StencilIterator, typename OutputIterator, 
             typename Predicate> 
      void scatter_if(InputIterator, InputIterator, MapIterator, 
                      StencilIterator, OutputIterator, Predicate, 
                      command_queue & = system::default_queue());
    template<typename InputIterator, typename MapIterator, 
             typename StencilIterator, typename OutputIterator> 
      void scatter_if(InputIterator first, InputIterator last, 
                      MapIterator map, StencilIterator stencil, 
                      OutputIterator result, 
                      command_queue & queue = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename TextIterator, typename PatternIterator> 
      TextIterator 
      search(TextIterator, TextIterator, PatternIterator, PatternIterator, 
             command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename TextIterator, typename ValueType> 
      TextIterator 
      search_n(TextIterator, TextIterator, size_t, ValueType, 
               command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator1, typename InputIterator2, 
             typename OutputIterator> 
      OutputIterator 
      set_difference(InputIterator1, InputIterator1, InputIterator2, 
                     InputIterator2, OutputIterator, 
                     command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator1, typename InputIterator2, 
             typename OutputIterator> 
      OutputIterator 
      set_intersection(InputIterator1, InputIterator1, InputIterator2, 
                       InputIterator2, OutputIterator, 
                       command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator1, typename InputIterator2, 
             typename OutputIterator> 
      OutputIterator 
      set_symmetric_difference(InputIterator1, InputIterator1, InputIterator2, 
                               InputIterator2, OutputIterator, 
                               command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator1, typename InputIterator2, 
             typename OutputIterator> 
      OutputIterator 
      set_union(InputIterator1, InputIterator1, InputIterator2, 
                InputIterator2, OutputIterator, 
                command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename Iterator, typename Compare> 
      void sort(Iterator, Iterator, Compare, 
                command_queue & = system::default_queue());
    template<typename Iterator> 
      void sort(Iterator, Iterator, command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename KeyIterator, typename ValueIterator, typename Compare> 
      void sort_by_key(KeyIterator, KeyIterator, ValueIterator, Compare, 
                       command_queue & = system::default_queue());
    template<typename KeyIterator, typename ValueIterator> 
      void sort_by_key(KeyIterator, KeyIterator, ValueIterator, 
                       command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename Iterator, typename UnaryPredicate> 
      Iterator stable_partition(Iterator, Iterator, UnaryPredicate, 
                                command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename Iterator, typename Compare> 
      void stable_sort(Iterator, Iterator, Compare, 
                       command_queue & = system::default_queue());
    template<typename Iterator> 
      void stable_sort(Iterator, Iterator, 
                       command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename KeyIterator, typename ValueIterator, typename Compare> 
      void stable_sort_by_key(KeyIterator, KeyIterator, ValueIterator, 
                              Compare, 
                              command_queue & = system::default_queue());
    template<typename KeyIterator, typename ValueIterator> 
      void stable_sort_by_key(KeyIterator, KeyIterator, ValueIterator, 
                              command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename Iterator1, typename Iterator2> 
      Iterator2 swap_ranges(Iterator1, Iterator1, Iterator2, 
                            command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator, typename OutputIterator, 
             typename UnaryOperator> 
      OutputIterator 
      transform(InputIterator, InputIterator, OutputIterator, UnaryOperator, 
                command_queue & = system::default_queue());
    template<typename InputIterator1, typename InputIterator2, 
             typename OutputIterator, typename BinaryOperator> 
      OutputIterator 
      transform(InputIterator1, InputIterator1, InputIterator2, 
                OutputIterator, BinaryOperator, 
                command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator, typename OutputIterator, 
             typename UnaryFunction, typename Predicate> 
      OutputIterator 
      transform_if(InputIterator, InputIterator, OutputIterator, 
                   UnaryFunction, Predicate, 
                   command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator, typename OutputIterator, 
             typename UnaryTransformFunction, typename BinaryReduceFunction> 
      void transform_reduce(InputIterator, InputIterator, OutputIterator, 
                            UnaryTransformFunction, BinaryReduceFunction, 
                            command_queue & = system::default_queue());
    template<typename InputIterator1, typename InputIterator2, 
             typename OutputIterator, typename BinaryTransformFunction, 
             typename BinaryReduceFunction> 
      void transform_reduce(InputIterator1, InputIterator1, InputIterator2, 
                            OutputIterator, BinaryTransformFunction, 
                            BinaryReduceFunction, 
                            command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator, typename BinaryPredicate> 
      InputIterator 
      unique(InputIterator, InputIterator, BinaryPredicate, 
             command_queue & = system::default_queue());
    template<typename InputIterator> 
      InputIterator 
      unique(InputIterator, InputIterator, 
             command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator, typename OutputIterator, 
             typename BinaryPredicate> 
      OutputIterator 
      unique_copy(InputIterator, InputIterator, OutputIterator, 
                  BinaryPredicate, command_queue & = system::default_queue());
    template<typename InputIterator, typename OutputIterator> 
      OutputIterator 
      unique_copy(InputIterator, InputIterator, OutputIterator, 
                  command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator, typename T> 
      InputIterator 
      upper_bound(InputIterator, InputIterator, const T &, 
                  command_queue & = system::default_queue());
  }
}

namespace boost {
  namespace compute {
    template<typename T> class buffer_allocator;
  }
}

namespace boost {
  namespace compute {
    template<typename T> class pinned_allocator;
  }
}

namespace boost {
  namespace compute {
    template<typename T> class future;
  }
}

namespace boost {
  namespace compute {
    template<class... Events> void wait_for_all(Events &&...);
  }
}

namespace boost {
  namespace compute {
    template<typename Waitable> class wait_guard;
  }
}

namespace boost {
  namespace compute {
    template<typename T, std::size_t N> class array;
  }
}

namespace boost {
  namespace compute {
    template<typename CharT, typename Traits = std::char_traits<CharT> > 
      class basic_string;
    template<typename CharT, typename Traits> 
      std::ostream & 
      operator<<(std::ostream & stream, 
                 boost::compute::basic_string< CharT, Traits >const & outStr);
  }
}

namespace boost {
  namespace compute {
    template<typename Block = ulong_, 
             typename Alloc = buffer_allocator<Block> > 
      class dynamic_bitset;
  }
}

namespace boost {
  namespace compute {
    template<typename Key, typename T> class flat_map;
  }
}

namespace boost {
  namespace compute {
    template<typename T> class flat_set;
  }
}

namespace boost {
  namespace compute {
    template<typename T> class mapped_view;
  }
}

namespace boost {
  namespace compute {
    template<typename T> class stack;
  }
}

namespace boost {
  namespace compute {
    typedef basic_string< char_ > string;
  }
}

BOOST_COMPUTE_DEFINE_VALARRAY_BINARY_OPERATOR(op, op_name, assert)
BOOST_COMPUTE_DEFINE_VALARRAY_BINARY_OPERATOR_ANY(op, op_name)
BOOST_COMPUTE_DEFINE_VALARRAY_BINARY_OPERATOR_NO_FP(op, op_name)
BOOST_COMPUTE_DEFINE_VALARRAY_COMPARISON_OPERATOR(op, op_name)
BOOST_COMPUTE_DEFINE_VALARRAY_LOGICAL_OPERATOR(op, op_name)

namespace boost {
  namespace compute {
    template<typename T> class valarray;
  }
}

namespace boost {
  namespace compute {
    template<typename T, typename Alloc = buffer_allocator<T> > class vector;
  }
}

namespace boost {
  namespace compute {
    class context_error;
  }
}

namespace boost {
  namespace compute {
    class no_device_found;
  }
}

namespace boost {
  namespace compute {
    class opencl_error;
  }
}

namespace boost {
  namespace compute {
    class program_build_failure;
  }
}

namespace boost {
  namespace compute {
    class unsupported_extension_error;
  }
}

namespace boost {
  namespace compute {
    template<typename T> struct as;
  }
}

namespace boost {
  namespace compute {
    template<typename T> class atomic_add;
    template<typename T> class atomic_and;
    template<typename T> class atomic_cmpxchg;
    template<typename T> class atomic_dec;
    template<typename T> class atomic_inc;
    template<typename T> class atomic_max;
    template<typename T> class atomic_min;
    template<typename T> class atomic_or;
    template<typename T> class atomic_sub;
    template<typename T> class atomic_xchg;
    template<typename T> class atomic_xor;
  }
}

namespace boost {
  namespace compute {
    template<typename T> struct is_placeholder;
    template<typename F, class... Args> unspecified bind(F, Args...);
    namespace placeholders {
      placeholder< 0 > const _1;
      placeholder< 1 > const _2;
    }
  }
}

namespace boost {
  namespace compute {
    template<typename T> struct convert;
  }
}

namespace boost {
  namespace compute {
    template<typename T> class field;
  }
}

namespace boost {
  namespace compute {
    template<size_t N> struct get;
  }
}

namespace boost {
  namespace compute {
    template<typename Key> struct hash;
  }
}

namespace boost {
  namespace compute {
    template<typename T> class identity;
  }
}

namespace boost {
  namespace compute {
    template<typename Predicate> class binary_negate;

    template<typename T> struct logical_not;

    template<typename Predicate> class unary_negate;
    template<typename Predicate> 
      unary_negate< Predicate > not1(const Predicate &);
    template<typename Predicate> 
      binary_negate< Predicate > not2(const Predicate &);
  }
}

namespace boost {
  namespace compute {
    template<typename T> class popcount;
  }
}

namespace boost {
  namespace compute {
    class image1d;
  }
}

namespace boost {
  namespace compute {
    class image2d;
  }
}

namespace boost {
  namespace compute {
    class image3d;
  }
}

namespace boost {
  namespace compute {
    class image_format;
  }
}

namespace boost {
  namespace compute {
    class image_object;
  }
}

namespace boost {
  namespace compute {
    class image_sampler;
  }
}

namespace boost {
  namespace compute {
    event opengl_enqueue_acquire_gl_objects(const uint_, const cl_mem *, 
                                            command_queue &, 
                                            const wait_list & = wait_list());
    event opengl_enqueue_release_gl_objects(const uint_, const cl_mem *, 
                                            command_queue &, 
                                            const wait_list & = wait_list());
    event opengl_enqueue_acquire_buffer(const opengl_buffer &, 
                                        command_queue &, 
                                        const wait_list & = wait_list());
    event opengl_enqueue_release_buffer(const opengl_buffer &, 
                                        command_queue &, 
                                        const wait_list & = wait_list());
  }
}

namespace boost {
  namespace compute {
    context opengl_create_shared_context();
  }
}

namespace boost {
  namespace compute {
    class opengl_buffer;
  }
}

namespace boost {
  namespace compute {
    class opengl_renderbuffer;
  }
}

namespace boost {
  namespace compute {
    class opengl_texture;
  }
}

namespace boost {
  namespace compute {
    template<typename T> class buffer_iterator;
    template<typename T> 
      buffer_iterator< T > make_buffer_iterator(const buffer &, size_t = 0);
  }
}

namespace boost {
  namespace compute {
    template<typename T> class constant_buffer_iterator;
    template<typename T> 
      constant_buffer_iterator< T > 
      make_constant_buffer_iterator(const buffer &, size_t = 0);
  }
}

namespace boost {
  namespace compute {
    template<typename T> class constant_iterator;
    template<typename T> 
      constant_iterator< T > make_constant_iterator(const T &, size_t = 0);
  }
}

namespace boost {
  namespace compute {
    template<typename T> class counting_iterator;
    template<typename T> 
      counting_iterator< T > make_counting_iterator(const T &);
  }
}

namespace boost {
  namespace compute {
    class discard_iterator;

    template<> struct is_device_iterator<discard_iterator>;
    discard_iterator make_discard_iterator(size_t = 0);
  }
}

namespace boost {
  namespace compute {
    template<typename Function> class function_input_iterator;
    template<typename Function> 
      function_input_iterator< Function > 
      make_function_input_iterator(const Function &, size_t = 0);
  }
}

namespace boost {
  namespace compute {
    template<typename ElementIterator, typename IndexIterator> 
      class permutation_iterator;
    template<typename ElementIterator, typename IndexIterator> 
      permutation_iterator< ElementIterator, IndexIterator > 
      make_permutation_iterator(ElementIterator, IndexIterator);
  }
}

namespace boost {
  namespace compute {
    template<typename Iterator> class strided_iterator;
    template<typename Iterator> 
      strided_iterator< Iterator > 
      make_strided_iterator(Iterator, 
                            typename std::iterator_traits< Iterator >::difference_type);
    template<typename Iterator> 
      strided_iterator< Iterator > 
      make_strided_iterator_end(Iterator, Iterator, 
                                typename std::iterator_traits< Iterator >::difference_type);
  }
}

namespace boost {
  namespace compute {
    template<typename InputIterator, typename UnaryFunction> 
      class transform_iterator;
    template<typename InputIterator, typename UnaryFunction> 
      transform_iterator< InputIterator, UnaryFunction > 
      make_transform_iterator(InputIterator, UnaryFunction);
  }
}

namespace boost {
  namespace compute {
    template<typename IteratorTuple> class zip_iterator;
    template<typename IteratorTuple> 
      zip_iterator< IteratorTuple > make_zip_iterator(IteratorTuple);
  }
}

namespace boost {
  namespace compute {
    template<typename T> class local_buffer;
  }
}

namespace boost {
  namespace compute {
    template<typename T> class svm_ptr;
  }
}

namespace boost {
  namespace compute {
    template<typename RealType = float> class bernoulli_distribution;
  }
}

namespace boost {
  namespace compute {
    typedef mt19937 default_random_engine;
  }
}

namespace boost {
  namespace compute {
    template<typename IntType = uint_> class discrete_distribution;
  }
}

namespace boost {
  namespace compute {
    template<typename T = uint_> class linear_congruential_engine;
  }
}

namespace boost {
  namespace compute {
    template<typename T> class mersenne_twister_engine;

    typedef mersenne_twister_engine< uint_ > mt19937;
  }
}

namespace boost {
  namespace compute {
    template<typename RealType = float> class normal_distribution;
  }
}

namespace boost {
  namespace compute {
    template<typename T = uint_> class threefry_engine;
  }
}

namespace boost {
  namespace compute {
    template<typename IntType = uint_> class uniform_int_distribution;
  }
}

namespace boost {
  namespace compute {
    template<typename RealType = float> class uniform_real_distribution;
  }
}

namespace boost {
  namespace compute {
    template<typename Iterator> struct is_device_iterator;
  }
}

namespace boost {
  namespace compute {
    template<typename T> struct is_fundamental;
  }
}

namespace boost {
  namespace compute {
    template<typename T> struct is_vector_type;
  }
}

namespace boost {
  namespace compute {
    template<typename Scalar, size_t Size> struct make_vector_type;
  }
}

namespace boost {
  namespace compute {
    template<typename Signature> struct result_of;
  }
}

namespace boost {
  namespace compute {
    template<typename Vector> struct scalar_type;
  }
}

namespace boost {
  namespace compute {
    template<typename T> std::string type_definition();
  }
}

BOOST_COMPUTE_TYPE_NAME(type, name)

namespace boost {
  namespace compute {
    template<typename T> const char * type_name();
  }
}

namespace boost {
  namespace compute {
    template<typename T> struct vector_size;
  }
}

namespace boost {
  namespace compute {
    template<class... Args> extents< sizeof...(Args)> dim(Args...);
  }
}

namespace boost {
  namespace compute {
    template<size_t N> class extents;
  }
}

BOOST_COMPUTE_DETAIL_INVOKE_ARG(z, n, unused)
BOOST_COMPUTE_DETAIL_INVOKE_ADD_ARG(z, n, unused)
BOOST_COMPUTE_DETAIL_DEFINE_INVOKE(z, n, unused)

namespace boost {
  namespace compute {
    template<typename Function, class... Args> 
      result_of< Function(Args...)>::type 
      invoke(const Function &, command_queue &, const Args &...);
  }
}

namespace boost {
  namespace compute {
    class program_cache;
  }
}

BOOST_COMPUTE_STRINGIZE_SOURCE(source)

namespace boost {
  namespace compute {
    class wait_list;
  }
}