template<class Xpr, class T, class Reducer>
T fold(Xpr expr, T init, Reducer reducer)
 {
   #pragma omp parallel
   {

 int factorial(int number)
 {
   int fac = 1;
   #pragma omp parallel
   {

#include <complex>  
void Mandelbrot(float x1, float y1, float x2, float y2,   
                   int width, int height, int maxIters, unsigned short * image)  
{  
    float dx = (x2-x1)/width, dy = (y2-y1)/height;  

int main()
{
   boost::tuple< std::vector<float>                 
               , std::vector<int>                   
               >                              data;

#include <iostream>

template<class F, int I, int N, int Step = 1, bool Stop = (Step>0) ? (I < N) : (N < I)>
struct for_
{

#include <iostream>
using namespace std;

struct fundamental_ {};
struct arithmetic_  : fundamental_{};

struct number;

struct power_number
{
  power_number(number const& n_) : n(n_){}

#include <stdio.h>
#include <time.h>
#include <math.h>
#include <stdlib.h>
#include <vector>

windows<dialog> w;

w = frame("Choose a File to Open")
    [
      listbox<columns,no_icons>(pos_x,pos_y)

#include <iostream>

struct X
{
    X() : id(instances++)

struct coord
{
  float x,y;
};

#include <iostream>

template<int I, int N,class F>
struct for_
{

#include <boost/mpl/bool.hpp>
#include <boost/function_types/result_type.hpp>
#include <boost/function_types/parameter_types.hpp>
#include <boost/function_types/member_function_pointer.hpp>

#include <cstddef>

template< class Type
        , std::size_t Size = 1024*1024
        , std::size_t ID = sizeof(Type)

#include <cstddef>

template< class Type
        , std::size_t Size = 1024*1024*sizeof(Type)
        , std::size_t ID = sizeof(Type)

struct some_exception {};

template<class T,size_t N> struct aligned_ptr
{
  public:

template<class T> struct aligned_ptr_reference        { typedef T& type;    };
template<>        struct aligned_ptr_reference<void>  { typedef void type;  };

template<class T,size_t N> struct alignement_traits
{

#include <iostream>
#include <boost/timer.hpp>

#include <boost/random/linear_congruential.hpp>
#include <boost/random/uniform_int.hpp>

#include <cstring>
#include <iostream>

using namespace std;

#include <string.h>
#include <stdio.h>

float** alloc_array( int h, int w )
{

#include<boost/mpl/vector.hpp>
#include<boost/mpl/at.hpp>
#include<boost/mpl/transform.hpp>

template<class Seq>

template<class T> static inline T** alloc( size_t h, size_t w )
{
  typedef T* ptr_type;
  ptr_type* m;
  m    = new ptr_type[h];

template<class T> static inline T** alloc( size_t h, size_t w )
{
  typedef T* ptr_type;
  ptr_type* m;
  m    = new ptr_type[h];

template<class T> static inline T** alloc( size_t h, size_t w )
{
  typedef T* ptr_type;
  ptr_type* m;
  m    = new ptr_type[h];

#include <boost/integer.hpp>
#include <boost/type_traits/aligned_storage.hpp>

  template<int N=0> struct aligned_chunk
  {

template<class T> static inline T** alloc( size_t h, size_t w )
{
  typedef T* ptr_type;
  ptr_type* m;
  m    = new ptr_type[h];

template<class T> static inline T** alloc( size_t h, size_t w )
{
  typedef T* ptr_type;
  ptr_type* m;
  m    = new ptr_type[h];

#include <iostream>


template<class T, int Padding>
struct padded

#include <iostream>
#include <boost/mpl/bool.hpp>
#include <boost/preprocessor/cat.hpp>

using namespace std;

#include <iostream>
#include <boost/utility/enable_if.hpp>
#include <boost/mpl/greater.hpp>
#include <boost/mpl/comparison.hpp>
#include <boost/mpl/size_t.hpp>

#include <iostream>
#include <boost/version.hpp>

using namespace std;
int main()

#include <iostream>
#include <boost/proto/proto.hpp>
#include <boost/lexical_cast.hpp>

using namespace std;

#include <boost/mpl/vector.hpp>
#include <boost/mpl/always.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/mpl/find.hpp>
#include <boost/mpl/switch.hpp>

#ifndef BOOST_MPL_SWITCH_HPP_INCLUDED
#define BOOST_MPL_SWITCH_HPP_INCLUDED

// Copyright Aleksey Gurtovoy 2003-2004
//

#include <iostream>
#include <boost/mpl/or.hpp>
#include <boost/mpl/has_xxx.hpp>
#include <boost/preprocessor/repetition/repeat_from_to.hpp>
#include <boost/preprocessor/repetition/enum.hpp>