			/* -- Mode: C++; c-basic-offset:4 ; -- */
			/*
			* (C) 2001 by Argonne National Laboratory.
			* See COPYRIGHT in top-level directory.
			*
			* This file is automatically generated by buildiface -nosep
			* DO NOT EDIT
			*/
			/* style: c++ header */

			#ifdef MPI
			#error "You cannot define MPI; that name is reserved for the MPI namespace"
			#endif

			// Check for incompatible GCC versions
			// GCC (specifically) g++ changed the calling convention
			// between 3.2.3 and 3.4.3 (!!) Normally such changes
			// should only occur at major releases (e.g., version 3 to 4)
			#ifdef __GNUC__
			# if __GNUC__ >= 0
			# if __GNUC_MINOR__ > 2 && 0 == 2
			# error 'Please use the same version of GCC and g++ for compiling MPICH2 and user MPI programs'
			# endif
			# endif
			#endif

			/*
			* Because the API is defined, some methods have parameters that are
			* not used. The following definition allows us to suppress warnings
			* about unused arguments in methods when -Wall -Wextra are specified.
			* this definition is removed at the end of this file.
			*/
			#ifdef MPIR_ARGUNUSED
			#error MPIR_ARGUNUSED defined
			#endif
			#if defined(__GNUC__) && __GNUC__ >= 4
			#define MPIR_ARGUNUSED __attribute__((unused))
			#else
			#define MPIR_ARGUNUSED
			#endif
			// There is a name conflict between stdio.h and iostream (or iostream.h)
			// and the MPI C++ binding with respect to the names SEEK_SET, SEEK_CUR,
			// and SEEK_END. MPI wants these in the MPI namespace, but stdio.h,
			// iostream, or iostream.h will #define these to integer values.
			// #undef'ing these can cause obscure problems.
			#ifndef MPICH_IGNORE_CXX_SEEK

			// MPICH_DONT_INCLUDE_STDIO_H is another escape hatch for us, just like
			// MPICH_IGNORE_CXX_SEEK. If we encounter a wacky environment or user in the
			// wild that does not want our workaround and/or the stdio.h header, then we can
			// offer them a way out.
			#ifndef MPICH_DONT_INCLUDE_STDIO_H
			// ensure that we have SEEK_* defined
			# include <stdio.h>
			#endif

			enum MPIR_Dummy_seek_type {
			MPIR_DUMMY_SEEK_COMMA_VAL = -1 // permits cleaner comma logic
			#ifdef SEEK_SET
			, MPIR_SEEK_SET = SEEK_SET
			# undef SEEK_SET
			, SEEK_SET = MPIR_SEEK_SET
			#endif
			#ifdef SEEK_CUR
			, MPIR_SEEK_CUR = SEEK_CUR
			# undef SEEK_CUR
			, SEEK_CUR = MPIR_SEEK_CUR
			#endif
			#ifdef SEEK_END
			, MPIR_SEEK_END = SEEK_END
			# undef SEEK_END
			, SEEK_END = MPIR_SEEK_END
			#endif
			#ifdef LOCK_SHARED
			, MPIR_LOCK_SHARED = LOCK_SHARED
			# undef LOCK_SHARED
			, LOCK_SHARED = MPIR_LOCK_SHARED
			#endif
			};

			#endif // MPICH_IGNORE_CXX_SEEK
			namespace MPI {
			#if 1
			#define MPIX_CALLREF( _objptr, fnc ) \
			{ int err = fnc; if (err) { (_objptr)->Call_errhandler( err ); }}
			#define MPIX_CALLOBJ( _obj, fnc ) \
			{ int err = fnc; if (err) { (_obj).Call_errhandler( err ); }}
			#define MPIX_CALLWORLD( fnc ) \
			{ int err = fnc ; if (err) MPIR_Call_world_errhand( err ); }
			extern void MPIR_Call_world_errhand( int );
			#else
			#define MPIX_CALLREF( _objptr, fnc ) (void)fnc
			#define MPIX_CALLOBJ( _obj, fnc ) (void)fnc
			#define MPIX_CALLWORLD( fnc ) (void)fnc
			#endif

			// Typedefs for basic int types
			typedef MPI_Offset Offset;
			typedef MPI_Aint Aint;
			typedef MPI_Fint Fint;

			// Special internal routine
			void MPIR_CXX_InitDatatypeNames( void );

			// Forward class declarations
			class Comm;
			class Nullcomm;
			class Intercomm;
			class Intracomm;
			class Cartcomm;
			class Graphcomm;
			class File;

			// base (classless) routines
			extern int Detach_buffer( void *&v1 ) ;
			extern bool Is_initialized( void ) ;
			extern void Get_processor_name( char * v1, int &v2 ) ;
			extern void Get_error_string( int v1, char * v2, int &v3 ) ;
			extern void Compute_dims( int v1, int v2, int * v3 ) ;
			extern void Get_version( int &v1, int &v2 ) ;
			extern void Finalize( void ) ;
			extern void Pcontrol( const int v1, ... ) ;
			extern void Attach_buffer( void* v1, int v2 ) ;
			extern int Get_error_class( int v1 ) ;
			extern Intracomm COMM_WORLD;
			extern File FILE_NULL;

			class Exception {

			protected:
			int the_real_exception;

			public:
			// new/delete

			inline Exception(int obj) : the_real_exception(obj) {}
			inline Exception(void) : the_real_exception(0) {}

			virtual ~Exception() {}
			// copy/assignment

			Exception(const Exception &obj) : the_real_exception(obj.the_real_exception){}

			Exception& operator=(const Exception &obj) {
			the_real_exception = obj.the_real_exception; return *this; }

			// logical
			bool operator== (const Exception &obj) {
			return (the_real_exception == obj.the_real_exception); }
			bool operator!= (const Exception &obj) {
			return (the_real_exception != obj.the_real_exception); }
			// C/C++ cast and assignment
			inline operator int*() { return &the_real_exception; }
			inline operator int() const { return the_real_exception; }
			Exception& operator=(const int& obj) {
			the_real_exception = obj; return *this; }

			protected:
			char the_error_message[MPI_MAX_ERROR_STRING];
			public:
			int Get_error_code(void) { return the_real_exception; }
			int Get_error_class(void) { return MPI::Get_error_class(the_real_exception); }
			const char *Get_error_string(void)
			{
			int len;
			MPI_Error_string(the_real_exception, the_error_message, &len);
			return the_error_message;
			}
			};

			class Datatype {
			friend class Comm;
			friend class Status;
			friend class Intracomm;
			friend class Intercomm;
			friend class Win;
			friend class File;
			friend class Op;

			protected:
			MPI_Datatype the_real_datatype;

			public:
			// new/delete

			inline Datatype(MPI_Datatype obj) : the_real_datatype(obj) {}
			inline Datatype(void) : the_real_datatype(MPI_DATATYPE_NULL) {}

			virtual ~Datatype() {}
			// copy/assignment

			Datatype(const Datatype &obj) : the_real_datatype(obj.the_real_datatype){}

			Datatype& operator=(const Datatype &obj) {
			the_real_datatype = obj.the_real_datatype; return *this; }

			// logical
			bool operator== (const Datatype &obj) {
			return (the_real_datatype == obj.the_real_datatype); }
			bool operator!= (const Datatype &obj) {
			return (the_real_datatype != obj.the_real_datatype); }
			// C/C++ cast and assignment
			inline operator MPI_Datatype*() { return &the_real_datatype; }
			inline operator MPI_Datatype() const { return the_real_datatype; }
			Datatype& operator=(const MPI_Datatype& obj) {
			the_real_datatype = obj; return *this; }
			virtual void Commit( void )
			{
			MPIX_CALLWORLD( MPI_Type_commit( (MPI_Datatype *) &the_real_datatype ));
			}
			virtual void Free( void )
			{
			MPIX_CALLWORLD( MPI_Type_free( (MPI_Datatype *) &the_real_datatype ));
			}
			virtual Datatype Create_indexed( int v1, const int * v2, const int * v3 ) const
			{
			Datatype v5;
			MPIX_CALLWORLD( MPI_Type_indexed( v1, (int )v2, (int )v3, (MPI_Datatype) the_real_datatype, &(v5.the_real_datatype) ));
			return v5;
			}
			virtual Datatype Create_contiguous( int v1 ) const
			{
			Datatype v3;
			MPIX_CALLWORLD( MPI_Type_contiguous( v1, (MPI_Datatype) the_real_datatype, &(v3.the_real_datatype) ));
			return v3;
			}
			virtual Datatype Create_vector( int v1, int v2, int v3 ) const
			{
			Datatype v5;
			MPIX_CALLWORLD( MPI_Type_vector( v1, v2, v3, (MPI_Datatype) the_real_datatype, &(v5.the_real_datatype) ));
			return v5;
			}
			static Datatype Create_struct( int v1, int v2[], MPI_Aint v3[], const Datatype v4[] )
			{
			Datatype v5;
			MPI_Datatype *l4 = new MPI_Datatype[v1];
			{
			int i4;
			for (i4=0;i4<v1;i4++) {
			l4[i4] = v4[i4].the_real_datatype;
			}
			}
			MPIX_CALLWORLD( MPI_Type_create_struct( v1, (int )v2, (MPI_Aint )v3, l4, &(v5.the_real_datatype) ));
			delete[] l4;
			return v5;
			}
			virtual int Pack_size( int v1, const Comm &v3 ) const;
			virtual void Pack( const void* v1, int v2, void * v4, int v5, int &v6, const Comm &v7 ) const;
			virtual int Get_size( void ) const
			{
			int v2;
			MPIX_CALLWORLD( MPI_Type_size( (MPI_Datatype) the_real_datatype, &v2 ));
			return v2;
			}
			virtual void Get_envelope( int &v2, int &v3, int &v4, int &v5 ) const
			{
			MPIX_CALLWORLD( MPI_Type_get_envelope( (MPI_Datatype) the_real_datatype, &v2, &v3, &v4, &v5 ));
			}
			virtual Datatype Create_hvector( int v1, int v2, Aint v3 ) const
			{
			Datatype v5;
			MPIX_CALLWORLD( MPI_Type_create_hvector( v1, v2, v3, (MPI_Datatype) the_real_datatype, &(v5.the_real_datatype) ));
			return v5;
			}
			static Datatype Match_size( int v1, int v2 )
			{
			Datatype v3;
			MPIX_CALLWORLD( MPI_Type_match_size( v1, v2, &(v3.the_real_datatype) ));
			return v3;
			}
			virtual Datatype Create_resized( const Aint v2, const Aint v3 ) const
			{
			Datatype v4;
			MPIX_CALLWORLD( MPI_Type_create_resized( (MPI_Datatype) the_real_datatype, (MPI_Aint)v2, (MPI_Aint)v3, &(v4.the_real_datatype) ));
			return v4;
			}
			virtual Datatype Create_indexed_block( int v1, int v2, const int v3[] ) const
			{
			Datatype v5;
			MPIX_CALLWORLD( MPI_Type_create_indexed_block( v1, v2, (int *)v3, (MPI_Datatype) the_real_datatype, &(v5.the_real_datatype) ));
			return v5;
			}
			virtual Aint Pack_external_size( char * v1, const int v2 ) const
			{
			MPI_Aint v4;
			MPIX_CALLWORLD( MPI_Pack_external_size( v1, (int)v2, (MPI_Datatype) the_real_datatype, &v4 ));
			return v4;
			}
			Datatype Dup( void ) const
			{
			Datatype v2;
			MPIX_CALLWORLD( MPI_Type_dup( (MPI_Datatype) the_real_datatype, &(v2.the_real_datatype) ));
			return v2;
			}
			virtual Datatype Create_hindexed( int v1, const int v2[], const Aint v3[] ) const
			{
			Datatype v5;
			MPIX_CALLWORLD( MPI_Type_create_hindexed( v1, (int )v2, (MPI_Aint )v3, (MPI_Datatype) the_real_datatype, &(v5.the_real_datatype) ));
			return v5;
			}
			virtual bool Get_attr( int v2, void * v3 ) const
			{
			int v4;
			MPIX_CALLWORLD( MPI_Type_get_attr( (MPI_Datatype) the_real_datatype, v2, v3, &v4 ));
			return v4!= 0;
			}
			virtual void Get_true_extent( Aint & v2, Aint & v3 ) const
			{
			MPIX_CALLWORLD( MPI_Type_get_true_extent( (MPI_Datatype) the_real_datatype, &v2, &v3 ));
			}
			virtual Datatype Create_darray( int v1, int v2, int v3, const int v4[], const int v5[], const int v6[], const int v7[], int v8 ) const
			{
			Datatype v10;
			MPIX_CALLWORLD( MPI_Type_create_darray( v1, v2, v3, (int )v4, (int )v5, (int )v6, (int )v7, v8, (MPI_Datatype) the_real_datatype, &(v10.the_real_datatype) ));
			return v10;
			}
			static Datatype Create_f90_real( int v1, int v2 )
			{
			Datatype v3;
			MPIX_CALLWORLD( MPI_Type_create_f90_real( v1, v2, &(v3.the_real_datatype) ));
			return v3;
			}
			virtual void Get_contents( int v2, int v3, int v4, int v5[], MPI_Aint v6[], Datatype v7[] ) const
			{
			MPI_Datatype *l7 = new MPI_Datatype[v4];
			MPIX_CALLWORLD( MPI_Type_get_contents( (MPI_Datatype) the_real_datatype, v2, v3, v4, v5, v6, l7 ));
			{
			int i7;
			for (i7=0;i7<v4;i7++) {
			v7[i7].the_real_datatype = l7[i7];
			}
			delete[] l7;
			}
			}
			virtual void Set_attr( int v2, const void * v3 )
			{
			MPIX_CALLWORLD( MPI_Type_set_attr( (MPI_Datatype) the_real_datatype, v2, (void *)v3 ));
			}
			virtual void Set_name( const char * v2 )
			{
			MPIX_CALLWORLD( MPI_Type_set_name( (MPI_Datatype) the_real_datatype, (char *)v2 ));
			}
			static Datatype Create_f90_complex( int v1, int v2 )
			{
			Datatype v3;
			MPIX_CALLWORLD( MPI_Type_create_f90_complex( v1, v2, &(v3.the_real_datatype) ));
			return v3;
			}
			virtual Datatype Create_subarray( int v1, int v2[], const int v3[], const int v4[], const int v5 ) const
			{
			Datatype v7;
			MPIX_CALLWORLD( MPI_Type_create_subarray( v1, v2, (int )v3, (int )v4, (int)v5, (MPI_Datatype) the_real_datatype, &(v7.the_real_datatype) ));
			return v7;
			}
			virtual void Unpack_external( char * v1, const void * v2, const Aint v3, Aint & v4, void * v5, int v6 ) const
			{
			MPIX_CALLWORLD( MPI_Unpack_external( v1, (void *)v2, (MPI_Aint)v3, &v4, v5, v6, (MPI_Datatype) the_real_datatype ));
			}
			static void Free_keyval( int &v1 )
			{
			MPIX_CALLWORLD( MPI_Type_free_keyval( &v1 ));
			}
			static Datatype Create_struct( int v1, const int v2[], const Aint v3[], const Datatype v4[] )
			{
			Datatype v5;
			MPI_Datatype *l4 = new MPI_Datatype[v1];
			{
			int i4;
			for (i4=0;i4<v1;i4++) {
			l4[i4] = v4[i4].the_real_datatype;
			}
			}
			MPIX_CALLWORLD( MPI_Type_create_struct( v1, (int )v2, (MPI_Aint )v3, l4, &(v5.the_real_datatype) ));
			delete[] l4;
			return v5;
			}
			static Datatype Create_f90_integer( int v1 )
			{
			Datatype v2;
			MPIX_CALLWORLD( MPI_Type_create_f90_integer( v1, &(v2.the_real_datatype) ));
			return v2;
			}
			virtual void Pack_external( char * v1, const void * v2, const int v3, void * v5, Aint v6, Aint & v7 ) const
			{
			MPIX_CALLWORLD( MPI_Pack_external( v1, (void *)v2, (int)v3, (MPI_Datatype) the_real_datatype, v5, v6, &v7 ));
			}
			virtual void Get_extent( Aint & v2, Aint & v3 ) const
			{
			MPIX_CALLWORLD( MPI_Type_get_extent( (MPI_Datatype) the_real_datatype, &v2, &v3 ));
			}
			virtual void Delete_attr( int v2 )
			{
			MPIX_CALLWORLD( MPI_Type_delete_attr( (MPI_Datatype) the_real_datatype, v2 ));
			}
			virtual void Get_name( char * v2, int &v3 ) const
			{
			MPIR_CXX_InitDatatypeNames();
			MPIX_CALLWORLD( MPI_Type_get_name( (MPI_Datatype) the_real_datatype, v2, &v3 ));
			}

			void Unpack( const void , int, void , int, int &, const Comm & ) const;
			typedef int Copy_attr_function(const Datatype& oldtype, int type_keyval, void* extra_state, void* attribute_val_in, void* attribute_val_out, bool& flag);
			typedef int Delete_attr_function(Datatype& type, int type_keyval, void* attribute_val, void* extra_state);

			static int Create_keyval( Copy_attr_function , Delete_attr_function ,
			void * );
			// These functions are not part of MPI-2 but are provided
			// because they should have been included
			static int NULL_COPY_FN( const Datatype &oldtype, int keyval, void ex, void attr_in, void *attr_out, bool &flag ) { oldtype; keyval; ex; attr_in; attr_out; flag = 1; return 0; }
			static int NULL_DELETE_FN( Datatype &type, int keyval, void * attr, void *ex ) { type; keyval; attr; ex; return 0; }
			static int DUP_FN( const Datatype &oldtype, int keyval, void ex, void attr_in, void attr_out, bool &flag ) { oldtype; keyval; ex; flag = 1; (void **)attr_out = attr_in; return 0; }

			};

			typedef void User_function(const void , void, int, const Datatype&);

			class Info {
			friend class File;
			friend class Win;
			friend class Comm;
			friend class Intracomm;

			protected:
			MPI_Info the_real_info;

			public:
			// new/delete

			inline Info(MPI_Info obj) : the_real_info(obj) {}
			inline Info(void) : the_real_info(MPI_INFO_NULL) {}

			virtual ~Info() {}
			// copy/assignment

			Info(const Info &obj) : the_real_info(obj.the_real_info){}

			Info& operator=(const Info &obj) {
			the_real_info = obj.the_real_info; return *this; }

			// logical
			bool operator== (const Info &obj) {
			return (the_real_info == obj.the_real_info); }
			bool operator!= (const Info &obj) {
			return (the_real_info != obj.the_real_info); }
			// C/C++ cast and assignment
			inline operator MPI_Info*() { return &the_real_info; }
			inline operator MPI_Info() const { return the_real_info; }
			Info& operator=(const MPI_Info& obj) {
			the_real_info = obj; return *this; }
			virtual void Delete( const char * v2 )
			{
			MPIX_CALLWORLD( MPI_Info_delete( (MPI_Info) the_real_info, (char *)v2 ));
			}
			virtual void Get_nthkey( int v2, char * v3 ) const
			{
			MPIX_CALLWORLD( MPI_Info_get_nthkey( (MPI_Info) the_real_info, v2, v3 ));
			}
			virtual void Free( void )
			{
			MPIX_CALLWORLD( MPI_Info_free( (MPI_Info *) &the_real_info ));
			}
			static Info Create( void )
			{
			Info v1;
			MPIX_CALLWORLD( MPI_Info_create( &(v1.the_real_info) ));
			return v1;
			}
			virtual void Set( const char * v2, const char * v3 )
			{
			MPIX_CALLWORLD( MPI_Info_set( (MPI_Info) the_real_info, (char )v2, (char )v3 ));
			}
			Info Dup( void ) const
			{
			Info v2;
			MPIX_CALLWORLD( MPI_Info_dup( (MPI_Info) the_real_info, &(v2.the_real_info) ));
			return v2;
			}
			virtual bool Get_valuelen( const char * v2, int &v3 ) const
			{
			int v4;
			MPIX_CALLWORLD( MPI_Info_get_valuelen( (MPI_Info) the_real_info, (char *)v2, &v3, &v4 ));
			return v4!= 0;
			}
			virtual bool Get( const char * v2, int v3, char * v4 ) const
			{
			int v5;
			MPIX_CALLWORLD( MPI_Info_get( (MPI_Info) the_real_info, (char *)v2, v3, v4, &v5 ));
			return v5!= 0;
			}
			virtual int Get_nkeys( void ) const
			{
			int v2;
			MPIX_CALLWORLD( MPI_Info_get_nkeys( (MPI_Info) the_real_info, &v2 ));
			return v2;
			}
			};

			class Status {
			friend class Comm;
			friend class File;
			friend class Request;

			protected:
			MPI_Status the_real_status;

			public:
			// new/delete

			inline Status(MPI_Status obj) : the_real_status(obj) {}
			inline Status(void) : the_real_status() {}

			virtual ~Status() {}
			// copy/assignment

			Status(const Status &obj) : the_real_status(obj.the_real_status){}

			Status& operator=(const Status &obj) {
			the_real_status = obj.the_real_status; return *this; }

			// C/C++ cast and assignment
			inline operator MPI_Status*() { return &the_real_status; }
			inline operator MPI_Status() const { return the_real_status; }
			Status& operator=(const MPI_Status& obj) {
			the_real_status = obj; return *this; }
			virtual bool Is_cancelled( void ) const
			{
			int v2;
			MPIX_CALLWORLD( MPI_Test_cancelled( (MPI_Status *) &the_real_status, &v2 ));
			return v2!= 0;
			}
			virtual int Get_elements( const Datatype &v2 ) const
			{
			int v3;
			MPIX_CALLWORLD( MPI_Get_elements( (MPI_Status *) &the_real_status, (MPI_Datatype)(v2.the_real_datatype), &v3 ));
			return v3;
			}
			virtual int Get_count( const Datatype &v2 ) const
			{
			int v3;
			MPIX_CALLWORLD( MPI_Get_count( (MPI_Status *) &the_real_status, (MPI_Datatype)(v2.the_real_datatype), &v3 ));
			return v3;
			}
			virtual void Set_cancelled( bool v2 )
			{
			int l2;
			l2 = (v2 == true) ? 1 : 0;
			MPIX_CALLWORLD( MPI_Status_set_cancelled( (MPI_Status *) &the_real_status, l2 ));
			}
			virtual void Set_elements( const Datatype &v2, int v3 )
			{
			MPIX_CALLWORLD( MPI_Status_set_elements( (MPI_Status *) &the_real_status, (MPI_Datatype)(v2.the_real_datatype), v3 ));
			}

			int Get_source(void) const { return the_real_status.MPI_SOURCE; }
			int Get_tag(void) const { return the_real_status.MPI_TAG; }
			int Get_error(void) const { return the_real_status.MPI_ERROR; }
			void Set_source(int source) { the_real_status.MPI_SOURCE = source; }
			void Set_tag(int tag) { the_real_status.MPI_TAG = tag; }
			void Set_error(int error) { the_real_status.MPI_ERROR = error; }
			};

			class Group {
			friend class Comm;
			friend class Intracomm;
			friend class Intercomm;
			friend class Win;
			friend class File;

			protected:
			MPI_Group the_real_group;

			public:
			// new/delete

			inline Group(MPI_Group obj) : the_real_group(obj) {}
			inline Group(void) : the_real_group(MPI_GROUP_NULL) {}

			virtual ~Group() {}
			// copy/assignment

			Group(const Group &obj) : the_real_group(obj.the_real_group){}

			Group& operator=(const Group &obj) {
			the_real_group = obj.the_real_group; return *this; }

			// logical
			bool operator== (const Group &obj) {
			return (the_real_group == obj.the_real_group); }
			bool operator!= (const Group &obj) {
			return (the_real_group != obj.the_real_group); }
			// C/C++ cast and assignment
			inline operator MPI_Group*() { return &the_real_group; }
			inline operator MPI_Group() const { return the_real_group; }
			Group& operator=(const MPI_Group& obj) {
			the_real_group = obj; return *this; }
			virtual Group Excl( int v2, const int * v3 ) const
			{
			Group v4;
			MPIX_CALLWORLD( MPI_Group_excl( (MPI_Group) the_real_group, v2, (int *)v3, &(v4.the_real_group) ));
			return v4;
			}
			virtual int Get_rank( void ) const
			{
			int v2;
			MPIX_CALLWORLD( MPI_Group_rank( (MPI_Group) the_real_group, &v2 ));
			return v2;
			}
			virtual void Free( void )
			{
			MPIX_CALLWORLD( MPI_Group_free( (MPI_Group *) &the_real_group ));
			}
			static Group Union( const Group &v1, const Group &v2 )
			{
			Group v3;
			MPIX_CALLWORLD( MPI_Group_union( (MPI_Group)(v1.the_real_group), (MPI_Group)(v2.the_real_group), &(v3.the_real_group) ));
			return v3;
			}
			static Group Intersect( const Group &v1, const Group &v2 )
			{
			Group v3;
			MPIX_CALLWORLD( MPI_Group_intersection( (MPI_Group)(v1.the_real_group), (MPI_Group)(v2.the_real_group), &(v3.the_real_group) ));
			return v3;
			}
			virtual Group Range_excl( int v2, const int v3[][3] ) const
			{
			Group v4;
			MPIX_CALLWORLD( MPI_Group_range_excl( (MPI_Group) the_real_group, v2, (int (*)[3])v3, &(v4.the_real_group) ));
			return v4;
			}
			virtual Group Range_incl( int v2, const int v3[][3] ) const
			{
			Group v4;
			MPIX_CALLWORLD( MPI_Group_range_incl( (MPI_Group) the_real_group, v2, (int (*)[3])v3, &(v4.the_real_group) ));
			return v4;
			}
			static Group Difference( const Group &v1, const Group &v2 )
			{
			Group v3;
			MPIX_CALLWORLD( MPI_Group_difference( (MPI_Group)(v1.the_real_group), (MPI_Group)(v2.the_real_group), &(v3.the_real_group) ));
			return v3;
			}
			static void Translate_ranks( const Group &v1, int v2, const int * v3, const Group &v4, int * v5 )
			{
			MPIX_CALLWORLD( MPI_Group_translate_ranks( (MPI_Group)(v1.the_real_group), v2, (int *)v3, (MPI_Group)(v4.the_real_group), v5 ));
			}
			virtual Group Incl( int v2, const int * v3 ) const
			{
			Group v4;
			MPIX_CALLWORLD( MPI_Group_incl( (MPI_Group) the_real_group, v2, (int *)v3, &(v4.the_real_group) ));
			return v4;
			}
			virtual int Get_size( void ) const
			{
			int v2;
			MPIX_CALLWORLD( MPI_Group_size( (MPI_Group) the_real_group, &v2 ));
			return v2;
			}
			static int Compare( const Group &v1, const Group &v2 )
			{
			int v3;
			MPIX_CALLWORLD( MPI_Group_compare( (MPI_Group)(v1.the_real_group), (MPI_Group)(v2.the_real_group), &v3 ));
			return v3;
			}
			};

			class Op {
			friend class Intracomm;
			friend class Intercomm;
			friend class Win;
			friend class Comm;

			protected:
			MPI_Op the_real_op;

			public:
			// new/delete

			inline Op(MPI_Op obj) : the_real_op(obj) {}
			inline Op(void) : the_real_op(MPI_OP_NULL) {}

			virtual ~Op() {}
			// copy/assignment

			Op(const Op &obj) : the_real_op(obj.the_real_op){}

			Op& operator=(const Op &obj) {
			the_real_op = obj.the_real_op; return *this; }

			// logical
			bool operator== (const Op &obj) {
			return (the_real_op == obj.the_real_op); }
			bool operator!= (const Op &obj) {
			return (the_real_op != obj.the_real_op); }
			// C/C++ cast and assignment
			inline operator MPI_Op*() { return &the_real_op; }
			inline operator MPI_Op() const { return the_real_op; }
			Op& operator=(const MPI_Op& obj) {
			the_real_op = obj; return *this; }
			virtual void Free( void )
			{
			MPIX_CALLWORLD( MPI_Op_free( (MPI_Op *) &the_real_op ));
			}
			virtual bool Is_commutative( void )
			{
			int v2;
			MPIX_CALLWORLD( MPI_Op_commutative( (MPI_Op) the_real_op, &v2 ));
			return v2!= 0;
			}
			virtual void Reduce_local( void * v1, void * v2, int v3, Datatype v4 )
			{
			MPIX_CALLWORLD( MPI_Reduce_local( v1, v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPI_Op) the_real_op ));
			}

			void Init( User_function *, bool );
			};

			class Errhandler {
			friend class Comm;
			friend class File;
			friend class Win;

			protected:
			MPI_Errhandler the_real_errhandler;

			public:
			// new/delete

			inline Errhandler(MPI_Errhandler obj) : the_real_errhandler(obj) {}
			inline Errhandler(void) : the_real_errhandler(MPI_ERRHANDLER_NULL) {}

			virtual ~Errhandler() {}
			// copy/assignment

			Errhandler(const Errhandler &obj) : the_real_errhandler(obj.the_real_errhandler){}

			Errhandler& operator=(const Errhandler &obj) {
			the_real_errhandler = obj.the_real_errhandler; return *this; }

			// logical
			bool operator== (const Errhandler &obj) {
			return (the_real_errhandler == obj.the_real_errhandler); }
			bool operator!= (const Errhandler &obj) {
			return (the_real_errhandler != obj.the_real_errhandler); }
			// C/C++ cast and assignment
			inline operator MPI_Errhandler*() { return &the_real_errhandler; }
			inline operator MPI_Errhandler() const { return the_real_errhandler; }
			Errhandler& operator=(const MPI_Errhandler& obj) {
			the_real_errhandler = obj; return *this; }
			virtual void Free( void )
			{
			MPIX_CALLWORLD( MPI_Errhandler_free( (MPI_Errhandler *) &the_real_errhandler ));
			}
			};

			class Request {
			friend class Comm;
			friend class File;
			friend class Grequest;

			protected:
			MPI_Request the_real_request;

			public:
			// new/delete

			inline Request(MPI_Request obj) : the_real_request(obj) {}
			inline Request(void) : the_real_request(MPI_REQUEST_NULL) {}

			virtual ~Request() {}
			// copy/assignment

			Request(const Request &obj) : the_real_request(obj.the_real_request){}

			Request& operator=(const Request &obj) {
			the_real_request = obj.the_real_request; return *this; }

			// logical
			bool operator== (const Request &obj) {
			return (the_real_request == obj.the_real_request); }
			bool operator!= (const Request &obj) {
			return (the_real_request != obj.the_real_request); }
			// C/C++ cast and assignment
			inline operator MPI_Request*() { return &the_real_request; }
			inline operator MPI_Request() const { return the_real_request; }
			Request& operator=(const MPI_Request& obj) {
			the_real_request = obj; return *this; }
			static bool Testany( int v1, Request v2[], int &v3, Status & v5 )
			{
			int v4;
			MPI_Request *l2 = new MPI_Request[v1];
			{
			int i2;
			for (i2=0;i2<v1;i2++) {
			l2[i2] = v2[i2].the_real_request;
			}
			}
			MPIX_CALLWORLD( MPI_Testany( v1, l2, &v3, &v4, (MPI_Status *)&(v5.the_real_status ) ));
			{
			int i2;
			for (i2=0;i2<v1;i2++) {
			v2[i2].the_real_request = l2[i2];
			}
			delete[] l2;
			}
			return v4!= 0;
			}
			static bool Testany( int v1, Request v2[], int &v3 )
			{
			int v4;
			MPI_Request *l2 = new MPI_Request[v1];
			{
			int i2;
			for (i2=0;i2<v1;i2++) {
			l2[i2] = v2[i2].the_real_request;
			}
			}
			MPIX_CALLWORLD( MPI_Testany( v1, l2, &v3, &v4, MPI_STATUS_IGNORE ));
			{
			int i2;
			for (i2=0;i2<v1;i2++) {
			v2[i2].the_real_request = l2[i2];
			}
			delete[] l2;
			}
			return v4!= 0;
			}
			static int Waitsome( int v1, Request v2[], int * v4, Status v5[] )
			{
			int v3;
			MPI_Request *l2 = new MPI_Request[v1];
			MPI_Status *l5 = new MPI_Status[v1];
			{
			int i2;
			for (i2=0;i2<v1;i2++) {
			l2[i2] = v2[i2].the_real_request;
			}
			}
			MPIX_CALLWORLD( MPI_Waitsome( v1, l2, &v3, v4, l5 ));
			{
			int i2;
			for (i2=0;i2<v1;i2++) {
			v2[i2].the_real_request = l2[i2];
			}
			delete[] l2;
			}
			{
			int i5;
			for (i5=0;i5<v1;i5++) {
			v5[i5].the_real_status = l5[i5];
			}
			delete[] l5;
			}
			return v3;
			}
			static int Waitsome( int v1, Request v2[], int * v4 )
			{
			int v3;
			MPI_Request *l2 = new MPI_Request[v1];
			{
			int i2;
			for (i2=0;i2<v1;i2++) {
			l2[i2] = v2[i2].the_real_request;
			}
			}
			MPIX_CALLWORLD( MPI_Waitsome( v1, l2, &v3, v4, MPI_STATUSES_IGNORE ));
			{
			int i2;
			for (i2=0;i2<v1;i2++) {
			v2[i2].the_real_request = l2[i2];
			}
			delete[] l2;
			}
			return v3;
			}
			virtual void Free( void )
			{
			MPIX_CALLWORLD( MPI_Request_free( (MPI_Request *) &the_real_request ));
			}
			static bool Testall( int v1, Request v2[], Status v4[] )
			{
			int v3;
			MPI_Request *l2 = new MPI_Request[v1];
			MPI_Status *l4 = new MPI_Status[v1];
			{
			int i2;
			for (i2=0;i2<v1;i2++) {
			l2[i2] = v2[i2].the_real_request;
			}
			}
			MPIX_CALLWORLD( MPI_Testall( v1, l2, &v3, l4 ));
			{
			int i2;
			for (i2=0;i2<v1;i2++) {
			v2[i2].the_real_request = l2[i2];
			}
			delete[] l2;
			}
			{
			int i4;
			for (i4=0;i4<v1;i4++) {
			v4[i4].the_real_status = l4[i4];
			}
			delete[] l4;
			}
			return v3!= 0;
			}
			static bool Testall( int v1, Request v2[] )
			{
			int v3;
			MPI_Request *l2 = new MPI_Request[v1];
			{
			int i2;
			for (i2=0;i2<v1;i2++) {
			l2[i2] = v2[i2].the_real_request;
			}
			}
			MPIX_CALLWORLD( MPI_Testall( v1, l2, &v3, MPI_STATUSES_IGNORE ));
			{
			int i2;
			for (i2=0;i2<v1;i2++) {
			v2[i2].the_real_request = l2[i2];
			}
			delete[] l2;
			}
			return v3!= 0;
			}
			virtual void Wait( Status & v2 )
			{
			MPIX_CALLWORLD( MPI_Wait( (MPI_Request ) &the_real_request, (MPI_Status )&(v2.the_real_status ) ));
			}
			virtual void Wait( void )
			{
			MPIX_CALLWORLD( MPI_Wait( (MPI_Request *) &the_real_request, MPI_STATUS_IGNORE ));
			}
			static int Testsome( int v1, Request v2[], int * v4, Status v5[] )
			{
			int v3;
			MPI_Request *l2 = new MPI_Request[v1];
			MPI_Status *l5 = new MPI_Status[v1];
			{
			int i2;
			for (i2=0;i2<v1;i2++) {
			l2[i2] = v2[i2].the_real_request;
			}
			}
			MPIX_CALLWORLD( MPI_Testsome( v1, l2, &v3, v4, l5 ));
			{
			int i2;
			for (i2=0;i2<v1;i2++) {
			v2[i2].the_real_request = l2[i2];
			}
			delete[] l2;
			}
			{
			int i5;
			for (i5=0;i5<v1;i5++) {
			v5[i5].the_real_status = l5[i5];
			}
			delete[] l5;
			}
			return v3;
			}
			static int Testsome( int v1, Request v2[], int * v4 )
			{
			int v3;
			MPI_Request *l2 = new MPI_Request[v1];
			{
			int i2;
			for (i2=0;i2<v1;i2++) {
			l2[i2] = v2[i2].the_real_request;
			}
			}
			MPIX_CALLWORLD( MPI_Testsome( v1, l2, &v3, v4, MPI_STATUSES_IGNORE ));
			{
			int i2;
			for (i2=0;i2<v1;i2++) {
			v2[i2].the_real_request = l2[i2];
			}
			delete[] l2;
			}
			return v3;
			}
			static void Waitall( int v1, Request v2[], Status v3[] )
			{
			MPI_Request *l2 = new MPI_Request[v1];
			MPI_Status *l3 = new MPI_Status[v1];
			{
			int i2;
			for (i2=0;i2<v1;i2++) {
			l2[i2] = v2[i2].the_real_request;
			}
			}
			MPIX_CALLWORLD( MPI_Waitall( v1, l2, l3 ));
			{
			int i2;
			for (i2=0;i2<v1;i2++) {
			v2[i2].the_real_request = l2[i2];
			}
			delete[] l2;
			}
			{
			int i3;
			for (i3=0;i3<v1;i3++) {
			v3[i3].the_real_status = l3[i3];
			}
			delete[] l3;
			}
			}
			static void Waitall( int v1, Request v2[] )
			{
			MPI_Request *l2 = new MPI_Request[v1];
			{
			int i2;
			for (i2=0;i2<v1;i2++) {
			l2[i2] = v2[i2].the_real_request;
			}
			}
			MPIX_CALLWORLD( MPI_Waitall( v1, l2, MPI_STATUSES_IGNORE ));
			{
			int i2;
			for (i2=0;i2<v1;i2++) {
			v2[i2].the_real_request = l2[i2];
			}
			delete[] l2;
			}
			}
			static int Waitany( int v1, Request v2[], Status & v4 )
			{
			int v3;
			MPI_Request *l2 = new MPI_Request[v1];
			{
			int i2;
			for (i2=0;i2<v1;i2++) {
			l2[i2] = v2[i2].the_real_request;
			}
			}
			MPIX_CALLWORLD( MPI_Waitany( v1, l2, &v3, (MPI_Status *)&(v4.the_real_status ) ));
			{
			int i2;
			for (i2=0;i2<v1;i2++) {
			v2[i2].the_real_request = l2[i2];
			}
			delete[] l2;
			}
			return v3;
			}
			static int Waitany( int v1, Request v2[] )
			{
			int v3;
			MPI_Request *l2 = new MPI_Request[v1];
			{
			int i2;
			for (i2=0;i2<v1;i2++) {
			l2[i2] = v2[i2].the_real_request;
			}
			}
			MPIX_CALLWORLD( MPI_Waitany( v1, l2, &v3, MPI_STATUS_IGNORE ));
			{
			int i2;
			for (i2=0;i2<v1;i2++) {
			v2[i2].the_real_request = l2[i2];
			}
			delete[] l2;
			}
			return v3;
			}
			virtual bool Test( Status & v3 )
			{
			int v2;
			MPIX_CALLWORLD( MPI_Test( (MPI_Request ) &the_real_request, &v2, (MPI_Status )&(v3.the_real_status ) ));
			return v2!= 0;
			}
			virtual bool Test( void )
			{
			int v2;
			MPIX_CALLWORLD( MPI_Test( (MPI_Request *) &the_real_request, &v2, MPI_STATUS_IGNORE ));
			return v2!= 0;
			}
			virtual void Cancel( void ) const
			{
			MPIX_CALLWORLD( MPI_Cancel( (MPI_Request *) &the_real_request ));
			}
			virtual bool Get_status( Status & v3 ) const
			{
			int v2;
			MPIX_CALLWORLD( MPI_Request_get_status( (MPI_Request) the_real_request, &v2, (MPI_Status *)&(v3.the_real_status ) ));
			return v2!= 0;
			}
			virtual bool Get_status( void ) const
			{
			int v2;
			MPIX_CALLWORLD( MPI_Request_get_status( (MPI_Request) the_real_request, &v2, MPI_STATUS_IGNORE ));
			return v2!= 0;
			}
			};

			class Prequest : public Request {

			public:
			// new/delete

			inline Prequest(MPI_Request obj) : Request(obj) {}
			inline Prequest(void) : Request() {}

			virtual ~Prequest() {}
			// copy/assignment

			Prequest(const Prequest &obj) : Request(obj) {}

			Prequest& operator=(const Prequest &obj) {
			the_real_request = obj.the_real_request; return *this; }

			// C/C++ cast and assignment
			inline operator MPI_Request*() { return &the_real_request; }
			inline operator MPI_Request() const { return the_real_request; }
			Prequest& operator=(const MPI_Request& obj) {
			the_real_request = obj; return *this; }
			virtual void Start( void )
			{
			MPIX_CALLWORLD( MPI_Start( (MPI_Request *) &the_real_request ));
			}
			static void Startall( int v1, Prequest v2[] )
			{
			MPI_Request *l2 = new MPI_Request[v1];
			{
			int i2;
			for (i2=0;i2<v1;i2++) {
			l2[i2] = v2[i2].the_real_request;
			}
			}
			MPIX_CALLWORLD( MPI_Startall( v1, l2 ));
			{
			int i2;
			for (i2=0;i2<v1;i2++) {
			v2[i2].the_real_request = l2[i2];
			}
			delete[] l2;
			}
			}
			};

			class Comm {
			friend class Cartcomm;
			friend class Intercomm;
			friend class Intracomm;
			friend class Graphcomm;
			friend class Nullcomm;
			friend class Datatype;
			friend class Win;
			friend class File;

			protected:
			MPI_Comm the_real_comm;

			public:
			// new/delete

			inline Comm(MPI_Comm obj) : the_real_comm(obj) {}
			inline Comm(void) : the_real_comm(MPI_COMM_NULL) {}

			virtual ~Comm() {}
			// copy/assignment

			Comm(const Comm &obj) : the_real_comm(obj.the_real_comm){}

			Comm& operator=(const Comm &obj) {
			the_real_comm = obj.the_real_comm; return *this; }

			// logical
			bool operator== (const Comm &obj) {
			return (the_real_comm == obj.the_real_comm); }
			bool operator!= (const Comm &obj) {
			return (the_real_comm != obj.the_real_comm); }
			// C/C++ cast and assignment
			inline operator MPI_Comm*() { return &the_real_comm; }
			inline operator MPI_Comm() const { return the_real_comm; }
			Comm& operator=(const MPI_Comm& obj) {
			the_real_comm = obj; return *this; }
			virtual Group Get_group( void ) const
			{
			Group v2;
			MPIX_CALLREF( this, MPI_Comm_group( (MPI_Comm) the_real_comm, &(v2.the_real_group) ));
			return v2;
			}
			virtual int Get_rank( void ) const
			{
			int v2;
			MPIX_CALLREF( this, MPI_Comm_rank( (MPI_Comm) the_real_comm, &v2 ));
			return v2;
			}
			virtual Prequest Bsend_init( const void* v1, int v2, const Datatype &v3, int v4, int v5 ) const
			{
			Prequest v7;
			MPIX_CALLREF( this, MPI_Bsend_init( (void*)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Comm) the_real_comm, &(v7.the_real_request) ));
			return v7;
			}
			virtual Prequest Ssend_init( const void* v1, int v2, const Datatype &v3, int v4, int v5 ) const
			{
			Prequest v7;
			MPIX_CALLREF( this, MPI_Ssend_init( (void*)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Comm) the_real_comm, &(v7.the_real_request) ));
			return v7;
			}
			virtual bool Is_inter( void ) const
			{
			int v2;
			MPIX_CALLREF( this, MPI_Comm_test_inter( (MPI_Comm) the_real_comm, &v2 ));
			return v2!= 0;
			}
			virtual Prequest Rsend_init( const void* v1, int v2, const Datatype &v3, int v4, int v5 ) const
			{
			Prequest v7;
			MPIX_CALLREF( this, MPI_Rsend_init( (void*)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Comm) the_real_comm, &(v7.the_real_request) ));
			return v7;
			}
			virtual Request Ibsend( const void* v1, int v2, const Datatype &v3, int v4, int v5 ) const
			{
			Request v7;
			MPIX_CALLREF( this, MPI_Ibsend( (void*)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Comm) the_real_comm, &(v7.the_real_request) ));
			return v7;
			}
			virtual void Abort( int v2 ) const
			{
			MPIX_CALLREF( this, MPI_Abort( (MPI_Comm) the_real_comm, v2 ));
			}
			virtual void Free( void )
			{
			MPIX_CALLREF( this, MPI_Comm_free( (MPI_Comm *) &the_real_comm ));
			}
			virtual Prequest Send_init( const void* v1, int v2, const Datatype &v3, int v4, int v5 ) const
			{
			Prequest v7;
			MPIX_CALLREF( this, MPI_Send_init( (void*)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Comm) the_real_comm, &(v7.the_real_request) ));
			return v7;
			}
			virtual void Recv( void* v1, int v2, const Datatype &v3, int v4, int v5, Status & v7 ) const
			{
			MPIX_CALLREF( this, MPI_Recv( v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Comm) the_real_comm, (MPI_Status *)&(v7.the_real_status ) ));
			}
			virtual void Recv( void* v1, int v2, const Datatype &v3, int v4, int v5 ) const
			{
			MPIX_CALLREF( this, MPI_Recv( v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Comm) the_real_comm, MPI_STATUS_IGNORE ));
			}
			virtual void Sendrecv( const void * v1, int v2, const Datatype &v3, int v4, int v5, void * v6, int v7, const Datatype &v8, int v9, int v10, Status & v12 ) const
			{
			MPIX_CALLREF( this, MPI_Sendrecv( (void )v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, v6, v7, (MPI_Datatype)(v8.the_real_datatype), v9, v10, (MPI_Comm) the_real_comm, (MPI_Status )&(v12.the_real_status ) ));
			}
			virtual void Sendrecv( const void * v1, int v2, const Datatype &v3, int v4, int v5, void * v6, int v7, const Datatype &v8, int v9, int v10 ) const
			{
			MPIX_CALLREF( this, MPI_Sendrecv( (void *)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, v6, v7, (MPI_Datatype)(v8.the_real_datatype), v9, v10, (MPI_Comm) the_real_comm, MPI_STATUS_IGNORE ));
			}
			virtual void Sendrecv_replace( void* v1, int v2, const Datatype &v3, int v4, int v5, int v6, int v7, Status & v9 ) const
			{
			MPIX_CALLREF( this, MPI_Sendrecv_replace( v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, v6, v7, (MPI_Comm) the_real_comm, (MPI_Status *)&(v9.the_real_status ) ));
			}
			virtual void Sendrecv_replace( void* v1, int v2, const Datatype &v3, int v4, int v5, int v6, int v7 ) const
			{
			MPIX_CALLREF( this, MPI_Sendrecv_replace( v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, v6, v7, (MPI_Comm) the_real_comm, MPI_STATUS_IGNORE ));
			}
			virtual int Get_topology( void ) const
			{
			int v2;
			MPIX_CALLREF( this, MPI_Topo_test( (MPI_Comm) the_real_comm, &v2 ));
			return v2;
			}
			virtual Request Isend( const void* v1, int v2, const Datatype &v3, int v4, int v5 ) const
			{
			Request v7;
			MPIX_CALLREF( this, MPI_Isend( (void*)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Comm) the_real_comm, &(v7.the_real_request) ));
			return v7;
			}
			virtual void Probe( int v1, int v2, Status & v4 ) const
			{
			MPIX_CALLREF( this, MPI_Probe( v1, v2, (MPI_Comm) the_real_comm, (MPI_Status *)&(v4.the_real_status ) ));
			}
			virtual void Probe( int v1, int v2 ) const
			{
			MPIX_CALLREF( this, MPI_Probe( v1, v2, (MPI_Comm) the_real_comm, MPI_STATUS_IGNORE ));
			}
			static int Compare( const Comm &v1, const Comm &v2 )
			{
			int v3;
			MPIX_CALLWORLD( MPI_Comm_compare( (MPI_Comm)(v1.the_real_comm), (MPI_Comm)(v2.the_real_comm), &v3 ));
			return v3;
			}
			virtual int Get_size( void ) const
			{
			int v2;
			MPIX_CALLREF( this, MPI_Comm_size( (MPI_Comm) the_real_comm, &v2 ));
			return v2;
			}
			virtual Request Issend( const void* v1, int v2, const Datatype &v3, int v4, int v5 ) const
			{
			Request v7;
			MPIX_CALLREF( this, MPI_Issend( (void*)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Comm) the_real_comm, &(v7.the_real_request) ));
			return v7;
			}
			virtual void Set_errhandler( const Errhandler &v2 )
			{
			MPIX_CALLREF( this, MPI_Comm_set_errhandler( (MPI_Comm) the_real_comm, (MPI_Errhandler)(v2.the_real_errhandler) ));
			}
			virtual void Send( const void* v1, int v2, const Datatype &v3, int v4, int v5 ) const
			{
			MPIX_CALLREF( this, MPI_Send( (void*)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Comm) the_real_comm ));
			}
			virtual Request Irsend( const void* v1, int v2, const Datatype &v3, int v4, int v5 ) const
			{
			Request v7;
			MPIX_CALLREF( this, MPI_Irsend( (void*)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Comm) the_real_comm, &(v7.the_real_request) ));
			return v7;
			}
			virtual void Ssend( const void* v1, int v2, const Datatype &v3, int v4, int v5 ) const
			{
			MPIX_CALLREF( this, MPI_Ssend( (void*)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Comm) the_real_comm ));
			}
			virtual Prequest Recv_init( void* v1, int v2, const Datatype &v3, int v4, int v5 ) const
			{
			Prequest v7;
			MPIX_CALLREF( this, MPI_Recv_init( v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Comm) the_real_comm, &(v7.the_real_request) ));
			return v7;
			}
			virtual bool Iprobe( int v1, int v2, Status & v5 ) const
			{
			int v4;
			MPIX_CALLREF( this, MPI_Iprobe( v1, v2, (MPI_Comm) the_real_comm, &v4, (MPI_Status *)&(v5.the_real_status ) ));
			return v4!= 0;
			}
			virtual bool Iprobe( int v1, int v2 ) const
			{
			int v4;
			MPIX_CALLREF( this, MPI_Iprobe( v1, v2, (MPI_Comm) the_real_comm, &v4, MPI_STATUS_IGNORE ));
			return v4!= 0;
			}
			virtual void Bsend( const void* v1, int v2, const Datatype &v3, int v4, int v5 ) const
			{
			MPIX_CALLREF( this, MPI_Bsend( (void*)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Comm) the_real_comm ));
			}
			virtual Request Irecv( void* v1, int v2, const Datatype &v3, int v4, int v5 ) const
			{
			Request v7;
			MPIX_CALLREF( this, MPI_Irecv( v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Comm) the_real_comm, &(v7.the_real_request) ));
			return v7;
			}
			virtual Errhandler Get_errhandler( void ) const
			{
			Errhandler v2;
			MPIX_CALLREF( this, MPI_Comm_get_errhandler( (MPI_Comm) the_real_comm, &(v2.the_real_errhandler) ));
			return v2;
			}
			virtual void Rsend( const void* v1, int v2, const Datatype &v3, int v4, int v5 ) const
			{
			MPIX_CALLREF( this, MPI_Rsend( (void*)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Comm) the_real_comm ));
			}
			virtual void Reduce_scatter_block( const void * v1, void * v2, int v3, const Datatype &v4, const Op &v5 ) const
			{
			MPIX_CALLREF( this, MPI_Reduce_scatter_block( (void *)v1, v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPI_Op)(v5.the_real_op), (MPI_Comm) the_real_comm ));
			}
			virtual void Gatherv( const void* v1, int v2, const Datatype &v3, void* v4, const int * v5, const int * v6, const Datatype &v7, int v8 ) const
			{
			MPIX_CALLREF( this, MPI_Gatherv( (void)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, (int )v5, (int *)v6, (MPI_Datatype)(v7.the_real_datatype), v8, (MPI_Comm) the_real_comm ));
			}
			virtual void Disconnect( void )
			{
			MPIX_CALLREF( this, MPI_Comm_disconnect( (MPI_Comm *) &the_real_comm ));
			}
			virtual void Allreduce( const void* v1, void* v2, int v3, const Datatype &v4, const Op &v5 ) const
			{
			MPIX_CALLREF( this, MPI_Allreduce( (void*)v1, v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPI_Op)(v5.the_real_op), (MPI_Comm) the_real_comm ));
			}
			virtual void Alltoallw( const void * v1, const int v2[], const int v3[], const Datatype v4[], void * v5, const int v6[], const int v7[], const Datatype v8[] ) const
			{
			MPI_Datatype *l4 = new MPI_Datatype[Get_size()];
			MPI_Datatype *l8 = new MPI_Datatype[Get_size()];
			{
			int i4;
			for (i4=0;i4<Get_size();i4++) {
			l4[i4] = v4[i4].the_real_datatype;
			}
			}
			{
			int i8;
			for (i8=0;i8<Get_size();i8++) {
			l8[i8] = v8[i8].the_real_datatype;
			}
			}
			MPIX_CALLREF( this, MPI_Alltoallw( (void )v1, (int )v2, (int )v3, l4, v5, (int )v6, (int *)v7, l8, (MPI_Comm) the_real_comm ));
			delete[] l4;
			delete[] l8;
			}
			static Intercomm Join( const int v1 ) ;
			virtual void Alltoall( const void* v1, int v2, const Datatype &v3, void* v4, int v5, const Datatype &v6 ) const
			{
			MPIX_CALLREF( this, MPI_Alltoall( (void*)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Datatype)(v6.the_real_datatype), (MPI_Comm) the_real_comm ));
			}
			virtual bool Get_attr( int v2, void * v3 ) const
			{
			int v4;
			MPIX_CALLREF( this, MPI_Comm_get_attr( (MPI_Comm) the_real_comm, v2, v3, &v4 ));
			return v4!= 0;
			}
			virtual void Barrier( void ) const
			{
			MPIX_CALLREF( this, MPI_Barrier( (MPI_Comm) the_real_comm ));
			}
			virtual void Bcast( void* v1, int v2, const Datatype &v3, int v4 ) const
			{
			MPIX_CALLREF( this, MPI_Bcast( v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, (MPI_Comm) the_real_comm ));
			}
			virtual void Set_attr( int v2, const void * v3 )
			{
			MPIX_CALLREF( this, MPI_Comm_set_attr( (MPI_Comm) the_real_comm, v2, (void *)v3 ));
			}
			virtual void Set_name( const char * v2 )
			{
			MPIX_CALLREF( this, MPI_Comm_set_name( (MPI_Comm) the_real_comm, (char *)v2 ));
			}
			static Intercomm Get_parent( void ) ;
			virtual void Alltoallv( const void* v1, const int * v2, const int * v3, const Datatype &v4, void* v5, const int * v6, const int * v7, const Datatype &v8 ) const
			{
			MPIX_CALLREF( this, MPI_Alltoallv( (void)v1, (int )v2, (int )v3, (MPI_Datatype)(v4.the_real_datatype), v5, (int )v6, (int *)v7, (MPI_Datatype)(v8.the_real_datatype), (MPI_Comm) the_real_comm ));
			}
			virtual void Reduce_scatter( const void* v1, void* v2, int * v3, const Datatype &v4, const Op &v5 ) const
			{
			MPIX_CALLREF( this, MPI_Reduce_scatter( (void*)v1, v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPI_Op)(v5.the_real_op), (MPI_Comm) the_real_comm ));
			}
			virtual void Scatter( const void* v1, int v2, const Datatype &v3, void* v4, int v5, const Datatype &v6, int v7 ) const
			{
			MPIX_CALLREF( this, MPI_Scatter( (void*)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Datatype)(v6.the_real_datatype), v7, (MPI_Comm) the_real_comm ));
			}
			virtual void Call_errhandler( int v2 ) const;
			virtual void Gather( const void* v1, int v2, const Datatype &v3, void* v4, int v5, const Datatype &v6, int v7 ) const
			{
			MPIX_CALLREF( this, MPI_Gather( (void*)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Datatype)(v6.the_real_datatype), v7, (MPI_Comm) the_real_comm ));
			}
			static void Free_keyval( int &v1 )
			{
			MPIX_CALLWORLD( MPI_Comm_free_keyval( &v1 ));
			}
			virtual void Reduce( const void* v1, void* v2, int v3, const Datatype &v4, const Op &v5, int v6 ) const
			{
			MPIX_CALLREF( this, MPI_Reduce( (void*)v1, v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPI_Op)(v5.the_real_op), v6, (MPI_Comm) the_real_comm ));
			}
			virtual void Allgather( const void* v1, int v2, const Datatype &v3, void* v4, int v5, const Datatype &v6 ) const
			{
			MPIX_CALLREF( this, MPI_Allgather( (void*)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Datatype)(v6.the_real_datatype), (MPI_Comm) the_real_comm ));
			}
			virtual void Delete_attr( int v2 )
			{
			MPIX_CALLREF( this, MPI_Comm_delete_attr( (MPI_Comm) the_real_comm, v2 ));
			}
			virtual void Scatterv( const void* v1, const int * v2, const int * v3, const Datatype &v4, void* v5, int v6, const Datatype &v7, int v8 ) const
			{
			MPIX_CALLREF( this, MPI_Scatterv( (void)v1, (int )v2, (int *)v3, (MPI_Datatype)(v4.the_real_datatype), v5, v6, (MPI_Datatype)(v7.the_real_datatype), v8, (MPI_Comm) the_real_comm ));
			}
			virtual void Get_name( char * v2, int &v3 ) const
			{
			MPIX_CALLREF( this, MPI_Comm_get_name( (MPI_Comm) the_real_comm, v2, &v3 ));
			}
			virtual void Allgatherv( const void* v1, int v2, const Datatype &v3, void* v4, const int * v5, const int * v6, const Datatype &v7 ) const
			{
			MPIX_CALLREF( this, MPI_Allgatherv( (void)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, (int )v5, (int *)v6, (MPI_Datatype)(v7.the_real_datatype), (MPI_Comm) the_real_comm ));
			}
			virtual Comm &Clone(void) const = 0;
			typedef int Copy_attr_function(const Comm& oldcomm, int comm_keyval, void* extra_state, void* attribute_val_in, void* attribute_val_out, bool& flag);
			typedef int Delete_attr_function(Comm& comm, int comm_keyval, void* attribute_val, void* extra_state);
			typedef void Errhandler_function(Comm &, int *, ... );
			typedef Errhandler_function Errhandler_fn;

			static int Create_keyval( Copy_attr_function , Delete_attr_function ,
			void * );

			static int NULL_COPY_FN( const Comm &oldcomm, int keyval, void ex, void attr_in, void *attr_out, bool &flag ) { oldcomm; keyval; ex; attr_in; attr_out; flag = 1; return 0; }
			static int NULL_DELETE_FN( Comm &comm, int keyval, void * attr, void *ex ) { comm; keyval; attr; ex; return 0; }
			static int DUP_FN( const Comm &oldcomm, int keyval, void ex, void attr_in, void attr_out, bool &flag ) { oldcomm; keyval; ex; flag = 1; (void **)attr_out = attr_in; return 0; }
			static Errhandler Create_errhandler( Errhandler_function * );

			};

			class Nullcomm : public Comm {

			public:
			// new/delete

			inline Nullcomm(MPI_Comm obj) : Comm(obj) {}
			inline Nullcomm(void) : Comm() {}

			virtual ~Nullcomm() {}
			// copy/assignment

			Nullcomm(const Nullcomm &obj) : Comm(obj) {}

			Nullcomm& operator=(const Nullcomm &obj) {
			the_real_comm = obj.the_real_comm; return *this; }

			// C/C++ cast and assignment
			inline operator MPI_Comm*() { return &the_real_comm; }
			inline operator MPI_Comm() const { return the_real_comm; }
			Nullcomm& operator=(const MPI_Comm& obj) {
			the_real_comm = obj; return *this; }

			// If the compiler does not support variable return types, return a
			// reference to Comm. The user must then cast this to the correct type
			// (Standard-conforming C++ compilers support variable return types)
			#ifdef HAVE_NO_VARIABLE_RETURN_TYPE_SUPPORT
			virtual Comm & Clone(void) const {
			Comm *clone = new Nullcomm(MPI_COMM_NULL);
			return *clone;
			};
			#else
			virtual Nullcomm & Clone(void) const {
			Nullcomm *clone = new Nullcomm();
			return *clone;
			};
			#endif
			};

			class Intercomm : public Comm {
			friend class Intracomm;

			public:
			// new/delete

			inline Intercomm(MPI_Comm obj) : Comm(obj) {}
			inline Intercomm(void) : Comm() {}

			virtual ~Intercomm() {}
			// copy/assignment

			Intercomm(const Intercomm &obj) : Comm(obj) {}

			Intercomm& operator=(const Intercomm &obj) {
			the_real_comm = obj.the_real_comm; return *this; }

			// C/C++ cast and assignment
			inline operator MPI_Comm*() { return &the_real_comm; }
			inline operator MPI_Comm() const { return the_real_comm; }
			Intercomm& operator=(const MPI_Comm& obj) {
			the_real_comm = obj; return *this; }
			virtual Intracomm Merge( bool v2 ) const;
			virtual Group Get_remote_group( void ) const
			{
			Group v2;
			MPIX_CALLREF( this, MPI_Comm_remote_group( (MPI_Comm) the_real_comm, &(v2.the_real_group) ));
			return v2;
			}
			virtual int Get_remote_size( void ) const
			{
			int v2;
			MPIX_CALLREF( this, MPI_Comm_remote_size( (MPI_Comm) the_real_comm, &v2 ));
			return v2;
			}
			Intercomm Dup( void ) const
			{
			Intercomm v2;
			MPIX_CALLREF( this, MPI_Comm_dup( (MPI_Comm) the_real_comm, &(v2.the_real_comm) ));
			return v2;
			}
			virtual Intercomm Split( int v2, int v3 ) const
			{
			Intercomm v4;
			MPIX_CALLREF( this, MPI_Comm_split( (MPI_Comm) the_real_comm, v2, v3, &(v4.the_real_comm) ));
			return v4;
			}

			// If the compiler does not support variable return types, return a
			// reference to Comm. The user must then cast this to the correct type
			// (Standard-conforming C++ compilers support variable return types)
			#ifdef HAVE_NO_VARIABLE_RETURN_TYPE_SUPPORT
			virtual Comm & Clone(void) const {
			MPI_Comm ncomm;
			MPI_Comm_dup( (MPI_Comm)the_real_comm, &ncomm);
			Comm *clone = new Intercomm(ncomm);
			return *clone;
			};
			#else
			virtual Intercomm & Clone(void) const {
			MPI_Comm ncomm;
			MPI_Comm_dup( (MPI_Comm)the_real_comm, &ncomm);
			Intercomm *clone = new Intercomm(ncomm);
			return *clone;
			};
			#endif
			};

			class Intracomm : public Comm {
			friend class Cartcomm;
			friend class Graphcomm;
			friend class Datatype;

			public:
			// new/delete

			inline Intracomm(MPI_Comm obj) : Comm(obj) {}
			inline Intracomm(void) : Comm() {}

			virtual ~Intracomm() {}
			// copy/assignment

			Intracomm(const Intracomm &obj) : Comm(obj) {}

			Intracomm& operator=(const Intracomm &obj) {
			the_real_comm = obj.the_real_comm; return *this; }

			// C/C++ cast and assignment
			inline operator MPI_Comm*() { return &the_real_comm; }
			inline operator MPI_Comm() const { return the_real_comm; }
			Intracomm& operator=(const MPI_Comm& obj) {
			the_real_comm = obj; return *this; }
			virtual Intercomm Create_intercomm( int v2, const Comm &v3, int v4, int v5 ) const
			{
			Intercomm v6;
			MPIX_CALLREF( this, MPI_Intercomm_create( (MPI_Comm) the_real_comm, v2, (MPI_Comm)(v3.the_real_comm), v4, v5, &(v6.the_real_comm) ));
			return v6;
			}
			virtual Intracomm Split( int v2, int v3 ) const
			{
			Intracomm v4;
			MPIX_CALLREF( this, MPI_Comm_split( (MPI_Comm) the_real_comm, v2, v3, &(v4.the_real_comm) ));
			return v4;
			}
			virtual Graphcomm Create_graph( int v2, const int * v3, const int * v4, bool v5 ) const;
			virtual Cartcomm Create_cart( int v2, const int * v3, const bool v4[], bool v5 ) const;
			virtual Intracomm Create( const Group &v2 ) const
			{
			Intracomm v3;
			MPIX_CALLREF( this, MPI_Comm_create( (MPI_Comm) the_real_comm, (MPI_Group)(v2.the_real_group), &(v3.the_real_comm) ));
			return v3;
			}
			Intracomm Dup( void ) const
			{
			Intracomm v2;
			MPIX_CALLREF( this, MPI_Comm_dup( (MPI_Comm) the_real_comm, &(v2.the_real_comm) ));
			return v2;
			}
			virtual void Scan( const void* v1, void* v2, int v3, const Datatype &v4, const Op &v5 ) const
			{
			MPIX_CALLREF( this, MPI_Scan( (void*)v1, v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPI_Op)(v5.the_real_op), (MPI_Comm) the_real_comm ));
			}
			virtual void Exscan( const void * v1, void * v2, int v3, const Datatype &v4, const Op &v5 ) const
			{
			MPIX_CALLREF( this, MPI_Exscan( (void *)v1, v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPI_Op)(v5.the_real_op), (MPI_Comm) the_real_comm ));
			}
			virtual Intercomm Accept( const char * v1, const Info &v2, int v3 ) const
			{
			Intercomm v5;
			MPIX_CALLREF( this, MPI_Comm_accept( (char *)v1, (MPI_Info)(v2.the_real_info), v3, (MPI_Comm) the_real_comm, &(v5.the_real_comm) ));
			return v5;
			}
			virtual Intercomm Connect( const char * v1, const Info &v2, int v3 ) const
			{
			Intercomm v5;
			MPIX_CALLREF( this, MPI_Comm_connect( (char *)v1, (MPI_Info)(v2.the_real_info), v3, (MPI_Comm) the_real_comm, &(v5.the_real_comm) ));
			return v5;
			}

			// If the compiler does not support variable return types, return a
			// reference to Comm. The user must then cast this to the correct type
			// (Standard-conforming C++ compilers support variable return types)
			#ifdef HAVE_NO_VARIABLE_RETURN_TYPE_SUPPORT
			virtual Comm & Clone(void) const {
			MPI_Comm ncomm;
			MPI_Comm_dup( (MPI_Comm)the_real_comm, &ncomm);
			Comm *clone = new Intracomm(ncomm);
			return *clone;
			};
			#else
			virtual Intracomm & Clone(void) const {
			MPI_Comm ncomm;
			MPI_Comm_dup( (MPI_Comm)the_real_comm, &ncomm);
			Intracomm *clone = new Intracomm(ncomm);
			return *clone;
			};
			#endif

			Intercomm Spawn(const char* command, const char* argv[], int maxprocs, const MPI::Info& info, int root) const {
			Intercomm ic;
			MPIX_CALLREF( this, MPI_Comm_spawn( (char *)command,
			(char **)argv,
			maxprocs, info.the_real_info, root, the_real_comm,
			&(ic.the_real_comm), MPI_ERRCODES_IGNORE ) );
			return ic;
			}
			Intercomm Spawn(const char* command, const char* argv[], int maxprocs, const MPI::Info& info, int root, int array_of_errcodes[]) const {
			Intercomm ic;
			MPIX_CALLREF( this, MPI_Comm_spawn( (char *)command,
			(char **)argv,
			maxprocs, info.the_real_info, root, the_real_comm,
			&(ic.the_real_comm), array_of_errcodes ) );
			return ic;
			}
			Intercomm Spawn_multiple(int count, const char* array_of_commands[], const char** array_of_argv[], const int array_of_maxprocs[], const MPI::Info array_of_info[], int root) {
			Intercomm ic;
			MPI_Info *li = new MPI_Info [count];
			int i;
			for (i=0; i<count; i++) {
			li[i] = array_of_info[i].the_real_info;
			}
			MPIX_CALLREF( this, MPI_Comm_spawn_multiple( count,
			(char **)array_of_commands,
			(char **)array_of_argv, (int )array_of_maxprocs,
			li, root, the_real_comm, &(ic.the_real_comm),
			MPI_ERRCODES_IGNORE ) );
			delete [] li;
			return ic;
			}
			Intercomm Spawn_multiple(int count, const char* array_of_commands[], const char** array_of_argv[], const int array_of_maxprocs[], const MPI::Info array_of_info[], int root, int array_of_errcodes[]) {
			Intercomm ic;
			MPI_Info *li = new MPI_Info [count];
			int i;
			for (i=0; i<count; i++) {
			li[i] = array_of_info[i].the_real_info;
			}
			MPIX_CALLREF( this, MPI_Comm_spawn_multiple( count,
			(char **)array_of_commands,
			(char **)array_of_argv, (int )array_of_maxprocs,
			li, root, the_real_comm, &(ic.the_real_comm),
			array_of_errcodes ) );
			delete [] li;
			return ic;
			}

			};

			class Grequest : public Request {

			public:
			// new/delete

			inline Grequest(MPI_Request obj) : Request(obj) {}
			inline Grequest(void) : Request() {}

			virtual ~Grequest() {}
			// copy/assignment

			Grequest(const Grequest &obj) : Request(obj) {}

			Grequest& operator=(const Grequest &obj) {
			the_real_request = obj.the_real_request; return *this; }

			// logical
			bool operator== (const Grequest &obj) {
			return (the_real_request == obj.the_real_request); }
			bool operator!= (const Grequest &obj) {
			return (the_real_request != obj.the_real_request); }
			// C/C++ cast and assignment
			inline operator MPI_Request*() { return &the_real_request; }
			inline operator MPI_Request() const { return the_real_request; }
			Grequest& operator=(const MPI_Request& obj) {
			the_real_request = obj; return *this; }
			virtual void Complete( void )
			{
			MPIX_CALLWORLD( MPI_Grequest_complete( (MPI_Request) the_real_request ));
			}

			typedef int Query_function( void *, Status & );
			typedef int Free_function( void * );
			typedef int Cancel_function( void *, bool );

			Grequest Start( Query_function *query_fn,
			Free_function *free_fn,
			Cancel_function *cancel_fn,
			void *extra_state );
			};

			class Win {

			protected:
			MPI_Win the_real_win;

			public:
			// new/delete

			inline Win(MPI_Win obj) : the_real_win(obj) {}
			inline Win(void) : the_real_win(MPI_WIN_NULL) {}

			virtual ~Win() {}
			// copy/assignment

			Win(const Win &obj) : the_real_win(obj.the_real_win){}

			Win& operator=(const Win &obj) {
			the_real_win = obj.the_real_win; return *this; }

			// logical
			bool operator== (const Win &obj) {
			return (the_real_win == obj.the_real_win); }
			bool operator!= (const Win &obj) {
			return (the_real_win != obj.the_real_win); }
			// C/C++ cast and assignment
			inline operator MPI_Win*() { return &the_real_win; }
			inline operator MPI_Win() const { return the_real_win; }
			Win& operator=(const MPI_Win& obj) {
			the_real_win = obj; return *this; }
			virtual Group Get_group( void ) const
			{
			Group v2;
			MPIX_CALLREF( this, MPI_Win_get_group( (MPI_Win) the_real_win, &(v2.the_real_group) ));
			return v2;
			}
			virtual void Fence( int v1 ) const
			{
			MPIX_CALLREF( this, MPI_Win_fence( v1, (MPI_Win) the_real_win ));
			}
			virtual void Start( const Group &v1, int v2 ) const
			{
			MPIX_CALLREF( this, MPI_Win_start( (MPI_Group)(v1.the_real_group), v2, (MPI_Win) the_real_win ));
			}
			virtual void Free( void )
			{
			MPIX_CALLREF( this, MPI_Win_free( (MPI_Win *) &the_real_win ));
			}
			virtual void Put( const void * v1, int v2, const Datatype &v3, int v4, Aint v5, int v6, const Datatype &v7 ) const
			{
			MPIX_CALLREF( this, MPI_Put( (void *)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, v6, (MPI_Datatype)(v7.the_real_datatype), (MPI_Win) the_real_win ));
			}
			virtual void Wait( void ) const
			{
			MPIX_CALLREF( this, MPI_Win_wait( (MPI_Win) the_real_win ));
			}
			virtual bool Test( void ) const
			{
			int v2;
			MPIX_CALLREF( this, MPI_Win_test( (MPI_Win) the_real_win, &v2 ));
			return v2!= 0;
			}
			virtual void Get( void * v1, int v2, const Datatype &v3, int v4, Aint v5, int v6, const Datatype &v7 ) const
			{
			MPIX_CALLREF( this, MPI_Get( v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, v6, (MPI_Datatype)(v7.the_real_datatype), (MPI_Win) the_real_win ));
			}
			virtual bool Get_attr( int v2, void * v3 ) const
			{
			int v4;
			MPIX_CALLREF( this, MPI_Win_get_attr( (MPI_Win) the_real_win, v2, v3, &v4 ));
			return v4!= 0;
			}
			virtual void Set_attr( int v2, const void * v3 )
			{
			MPIX_CALLREF( this, MPI_Win_set_attr( (MPI_Win) the_real_win, v2, (void *)v3 ));
			}
			virtual void Complete( void ) const
			{
			MPIX_CALLREF( this, MPI_Win_complete( (MPI_Win) the_real_win ));
			}
			virtual void Set_errhandler( const Errhandler &v2 )
			{
			MPIX_CALLREF( this, MPI_Win_set_errhandler( (MPI_Win) the_real_win, (MPI_Errhandler)(v2.the_real_errhandler) ));
			}
			virtual void Set_name( const char * v2 )
			{
			MPIX_CALLREF( this, MPI_Win_set_name( (MPI_Win) the_real_win, (char *)v2 ));
			}
			virtual void Accumulate( const void * v1, int v2, const Datatype &v3, int v4, Aint v5, int v6, const Datatype &v7, const Op &v8 ) const
			{
			MPIX_CALLREF( this, MPI_Accumulate( (void *)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, v6, (MPI_Datatype)(v7.the_real_datatype), (MPI_Op)(v8.the_real_op), (MPI_Win) the_real_win ));
			}
			static Win Create( const void * v1, Aint v2, int v3, const Info &v4, const Intracomm &v5 )
			{
			Win v6;
			MPIX_CALLOBJ( v5, MPI_Win_create( (void *)v1, v2, v3, (MPI_Info)(v4.the_real_info), (MPI_Comm)(v5.the_real_comm), &(v6.the_real_win) ));
			return v6;
			}
			virtual void Call_errhandler( int v2 ) const;
			static void Free_keyval( int &v1 )
			{
			MPIX_CALLWORLD( MPI_Win_free_keyval( &v1 ));
			}
			virtual void Post( const Group &v1, int v2 ) const
			{
			MPIX_CALLREF( this, MPI_Win_post( (MPI_Group)(v1.the_real_group), v2, (MPI_Win) the_real_win ));
			}
			virtual void Unlock( int v1 ) const
			{
			MPIX_CALLREF( this, MPI_Win_unlock( v1, (MPI_Win) the_real_win ));
			}
			virtual void Delete_attr( int v2 )
			{
			MPIX_CALLREF( this, MPI_Win_delete_attr( (MPI_Win) the_real_win, v2 ));
			}
			virtual void Lock( int v1, int v2, int v3 ) const
			{
			MPIX_CALLREF( this, MPI_Win_lock( v1, v2, v3, (MPI_Win) the_real_win ));
			}
			virtual Errhandler Get_errhandler( void ) const
			{
			Errhandler v2;
			MPIX_CALLREF( this, MPI_Win_get_errhandler( (MPI_Win) the_real_win, &(v2.the_real_errhandler) ));
			return v2;
			}
			virtual void Get_name( char * v2, int &v3 ) const
			{
			MPIX_CALLREF( this, MPI_Win_get_name( (MPI_Win) the_real_win, v2, &v3 ));
			}
			typedef void Errhandler_function(Win &, int *, ... );
			typedef Errhandler_function Errhandler_fn;

			static Errhandler Create_errhandler( Errhandler_function * );

			typedef int Copy_attr_function(const Win& oldwin, int win_keyval, void* extra_state, void* attribute_val_in, void* attribute_val_out, bool& flag);
			typedef int Delete_attr_function(Win& win, int win_keyval, void* attribute_val, void* extra_state);

			static int Create_keyval( Copy_attr_function , Delete_attr_function ,
			void * );
			// These functions are not part of MPI-2 but are provided
			// because they should have been included
			static int NULL_COPY_FN( const Win &oldwin, int keyval, void ex, void attr_in, void *attr_out, bool &flag ) { oldwin; keyval; ex; attr_in; attr_out; flag = 1; return 0; }
			static int NULL_DELETE_FN( Win &win, int keyval, void * attr, void *ex ) { win; keyval; attr; ex; return 0; }
			static int DUP_FN( const Win &oldwin, int keyval, void ex, void attr_in, void attr_out, bool &flag ) { oldwin; keyval; ex; flag = 1; (void **)attr_out = attr_in; return 0; }

			};
			#ifndef MPI_FILE_NULL
			#define MPI_FILE_NULL 0
			typedef int MPI_File;
			#endif

			class File {

			protected:
			MPI_File the_real_file;

			public:
			// new/delete

			inline File(MPI_File obj) : the_real_file(obj) {}
			inline File(void) : the_real_file(MPI_FILE_NULL) {}

			virtual ~File() {}
			// copy/assignment

			File(const File &obj) : the_real_file(obj.the_real_file){}

			File& operator=(const File &obj) {
			the_real_file = obj.the_real_file; return *this; }

			// logical
			bool operator== (const File &obj) {
			return (the_real_file == obj.the_real_file); }
			bool operator!= (const File &obj) {
			return (the_real_file != obj.the_real_file); }
			// C/C++ cast and assignment
			inline operator MPI_File*() { return &the_real_file; }
			inline operator MPI_File() const { return the_real_file; }
			File& operator=(const MPI_File& obj) {
			the_real_file = obj; return *this; }
			#ifdef MPI_MODE_RDONLY
			virtual Aint Get_type_extent( const Datatype &v2 ) const
			{
			MPI_Aint v3;
			MPIX_CALLREF( this, MPI_File_get_type_extent( (MPI_File) the_real_file, (MPI_Datatype)(v2.the_real_datatype), &v3 ));
			return v3;
			}
			virtual void Read_ordered_end( void * v2, Status & v3 )
			{
			MPIX_CALLREF( this, MPI_File_read_ordered_end( (MPI_File) the_real_file, v2, (MPI_Status *)&(v3.the_real_status ) ));
			}
			virtual void Read_ordered_end( void * v2 )
			{
			MPIX_CALLREF( this, MPI_File_read_ordered_end( (MPI_File) the_real_file, v2, MPI_STATUS_IGNORE ));
			}
			virtual void Seek_shared( Offset v2, int v3 )
			{
			MPIX_CALLREF( this, MPI_File_seek_shared( (MPI_File) the_real_file, v2, v3 ));
			}
			virtual void Read_ordered( void * v2, int v3, const Datatype &v4, Status & v5 )
			{
			MPIX_CALLREF( this, MPI_File_read_ordered( (MPI_File) the_real_file, v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPI_Status *)&(v5.the_real_status ) ));
			}
			virtual void Read_ordered( void * v2, int v3, const Datatype &v4 )
			{
			MPIX_CALLREF( this, MPI_File_read_ordered( (MPI_File) the_real_file, v2, v3, (MPI_Datatype)(v4.the_real_datatype), MPI_STATUS_IGNORE ));
			}
			virtual Request Iread_shared( void * v2, int v3, const Datatype &v4 )
			{
			Request v5;
			MPIX_CALLREF( this, MPI_File_iread_shared( (MPI_File) the_real_file, v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPIO_Request *)&(v5.the_real_request) ));
			return v5;
			}
			virtual Info Get_info( void ) const
			{
			Info v2;
			MPIX_CALLREF( this, MPI_File_get_info( (MPI_File) the_real_file, &(v2.the_real_info) ));
			return v2;
			}
			virtual void Write_ordered_begin( const void * v2, int v3, const Datatype &v4 )
			{
			MPIX_CALLREF( this, MPI_File_write_ordered_begin( (MPI_File) the_real_file, (void *)v2, v3, (MPI_Datatype)(v4.the_real_datatype) ));
			}
			virtual void Set_info( const Info &v2 )
			{
			MPIX_CALLREF( this, MPI_File_set_info( (MPI_File) the_real_file, (MPI_Info)(v2.the_real_info) ));
			}
			virtual void Write_ordered( const void * v2, int v3, const Datatype &v4, Status & v5 )
			{
			MPIX_CALLREF( this, MPI_File_write_ordered( (MPI_File) the_real_file, (void )v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPI_Status )&(v5.the_real_status ) ));
			}
			virtual void Write_ordered( const void * v2, int v3, const Datatype &v4 )
			{
			MPIX_CALLREF( this, MPI_File_write_ordered( (MPI_File) the_real_file, (void *)v2, v3, (MPI_Datatype)(v4.the_real_datatype), MPI_STATUS_IGNORE ));
			}
			virtual void Sync( void )
			{
			MPIX_CALLREF( this, MPI_File_sync( (MPI_File) the_real_file ));
			}
			virtual void Read( void * v2, int v3, const Datatype &v4, Status & v5 )
			{
			MPIX_CALLREF( this, MPI_File_read( (MPI_File) the_real_file, v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPI_Status *)&(v5.the_real_status ) ));
			}
			virtual void Read( void * v2, int v3, const Datatype &v4 )
			{
			MPIX_CALLREF( this, MPI_File_read( (MPI_File) the_real_file, v2, v3, (MPI_Datatype)(v4.the_real_datatype), MPI_STATUS_IGNORE ));
			}
			virtual void Write_all( const void * v2, int v3, const Datatype &v4, Status & v5 )
			{
			MPIX_CALLREF( this, MPI_File_write_all( (MPI_File) the_real_file, (void )v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPI_Status )&(v5.the_real_status ) ));
			}
			virtual void Write_all( const void * v2, int v3, const Datatype &v4 )
			{
			MPIX_CALLREF( this, MPI_File_write_all( (MPI_File) the_real_file, (void *)v2, v3, (MPI_Datatype)(v4.the_real_datatype), MPI_STATUS_IGNORE ));
			}
			virtual Offset Get_size( void ) const
			{
			MPI_Offset v2;
			MPIX_CALLREF( this, MPI_File_get_size( (MPI_File) the_real_file, &v2 ));
			return v2;
			}
			virtual void Write_all_end( const void * v2, Status & v3 )
			{
			MPIX_CALLREF( this, MPI_File_write_all_end( (MPI_File) the_real_file, (void )v2, (MPI_Status )&(v3.the_real_status ) ));
			}
			virtual void Write_all_end( const void * v2 )
			{
			MPIX_CALLREF( this, MPI_File_write_all_end( (MPI_File) the_real_file, (void *)v2, MPI_STATUS_IGNORE ));
			}
			static void Delete( const char * v1, const Info &v2 )
			{
			MPIX_CALLOBJ( FILE_NULL, MPI_File_delete( (char *)v1, (MPI_Info)(v2.the_real_info) ));
			}
			virtual void Read_ordered_begin( void * v2, int v3, const Datatype &v4 )
			{
			MPIX_CALLREF( this, MPI_File_read_ordered_begin( (MPI_File) the_real_file, v2, v3, (MPI_Datatype)(v4.the_real_datatype) ));
			}
			virtual Request Iread_at( Offset v2, void * v3, int v4, const Datatype &v5 )
			{
			Request v6;
			MPIX_CALLREF( this, MPI_File_iread_at( (MPI_File) the_real_file, v2, v3, v4, (MPI_Datatype)(v5.the_real_datatype), (MPIO_Request *)&(v6.the_real_request) ));
			return v6;
			}
			virtual void Write_at_all_end( const void * v2, Status & v3 )
			{
			MPIX_CALLREF( this, MPI_File_write_at_all_end( (MPI_File) the_real_file, (void )v2, (MPI_Status )&(v3.the_real_status ) ));
			}
			virtual void Write_at_all_end( const void * v2 )
			{
			MPIX_CALLREF( this, MPI_File_write_at_all_end( (MPI_File) the_real_file, (void *)v2, MPI_STATUS_IGNORE ));
			}
			virtual Offset Get_position_shared( void ) const
			{
			MPI_Offset v2;
			MPIX_CALLREF( this, MPI_File_get_position_shared( (MPI_File) the_real_file, &v2 ));
			return v2;
			}
			virtual void Write_shared( const void * v2, int v3, const Datatype &v4, Status & v5 )
			{
			MPIX_CALLREF( this, MPI_File_write_shared( (MPI_File) the_real_file, (void )v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPI_Status )&(v5.the_real_status ) ));
			}
			virtual void Write_shared( const void * v2, int v3, const Datatype &v4 )
			{
			MPIX_CALLREF( this, MPI_File_write_shared( (MPI_File) the_real_file, (void *)v2, v3, (MPI_Datatype)(v4.the_real_datatype), MPI_STATUS_IGNORE ));
			}
			virtual Request Iwrite_at( Offset v2, const void * v3, int v4, const Datatype &v5 )
			{
			Request v6;
			MPIX_CALLREF( this, MPI_File_iwrite_at( (MPI_File) the_real_file, (MPI_Offset)v2, (void )v3, v4, (MPI_Datatype)(v5.the_real_datatype), (MPIO_Request )&(v6.the_real_request) ));
			return v6;
			}
			virtual void Get_view( Offset & v2, Datatype &v3, Datatype &v4, char * v5 ) const
			{
			MPIX_CALLREF( this, MPI_File_get_view( (MPI_File) the_real_file, &v2, (MPI_Datatype )&(v3.the_real_datatype), (MPI_Datatype )&(v4.the_real_datatype), v5 ));
			}
			virtual void Call_errhandler( int v2 ) const;
			virtual void Write_all_begin( const void * v2, int v3, const Datatype &v4 )
			{
			MPIX_CALLREF( this, MPI_File_write_all_begin( (MPI_File) the_real_file, (void *)v2, v3, (MPI_Datatype)(v4.the_real_datatype) ));
			}
			virtual void Read_all_end( void * v2, Status & v3 )
			{
			MPIX_CALLREF( this, MPI_File_read_all_end( (MPI_File) the_real_file, v2, (MPI_Status *)&(v3.the_real_status ) ));
			}
			virtual void Read_all_end( void * v2 )
			{
			MPIX_CALLREF( this, MPI_File_read_all_end( (MPI_File) the_real_file, v2, MPI_STATUS_IGNORE ));
			}
			virtual Offset Get_byte_offset( const Offset v2 ) const
			{
			MPI_Offset v3;
			MPIX_CALLREF( this, MPI_File_get_byte_offset( (MPI_File) the_real_file, (MPI_Offset)v2, &v3 ));
			return v3;
			}
			virtual Request Iread( void * v2, int v3, const Datatype &v4 )
			{
			Request v5;
			MPIX_CALLREF( this, MPI_File_iread( (MPI_File) the_real_file, v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPIO_Request *)&(v5.the_real_request) ));
			return v5;
			}
			virtual void Read_at_all_end( void * v2, Status & v3 )
			{
			MPIX_CALLREF( this, MPI_File_read_at_all_end( (MPI_File) the_real_file, v2, (MPI_Status *)&(v3.the_real_status ) ));
			}
			virtual void Read_at_all_end( void * v2 )
			{
			MPIX_CALLREF( this, MPI_File_read_at_all_end( (MPI_File) the_real_file, v2, MPI_STATUS_IGNORE ));
			}
			virtual void Write_at( Offset v2, const void * v3, int v4, const Datatype &v5, Status & v6 )
			{
			MPIX_CALLREF( this, MPI_File_write_at( (MPI_File) the_real_file, v2, (void )v3, v4, (MPI_Datatype)(v5.the_real_datatype), (MPI_Status )&(v6.the_real_status ) ));
			}
			virtual void Write_at( Offset v2, const void * v3, int v4, const Datatype &v5 )
			{
			MPIX_CALLREF( this, MPI_File_write_at( (MPI_File) the_real_file, v2, (void *)v3, v4, (MPI_Datatype)(v5.the_real_datatype), MPI_STATUS_IGNORE ));
			}
			virtual void Write_at_all_begin( Offset v2, const void * v3, int v4, const Datatype &v5 )
			{
			MPIX_CALLREF( this, MPI_File_write_at_all_begin( (MPI_File) the_real_file, v2, (void *)v3, v4, (MPI_Datatype)(v5.the_real_datatype) ));
			}
			virtual Errhandler Get_errhandler( void ) const
			{
			Errhandler v2;
			MPIX_CALLREF( this, MPI_File_get_errhandler( (MPI_File) the_real_file, &(v2.the_real_errhandler) ));
			return v2;
			}
			virtual int Get_amode( void ) const
			{
			int v2;
			MPIX_CALLREF( this, MPI_File_get_amode( (MPI_File) the_real_file, &v2 ));
			return v2;
			}
			virtual void Set_atomicity( bool v2 )
			{
			int l2;
			l2 = (v2 == true) ? 1 : 0;
			MPIX_CALLREF( this, MPI_File_set_atomicity( (MPI_File) the_real_file, l2 ));
			}
			virtual Group Get_group( void ) const
			{
			Group v2;
			MPIX_CALLREF( this, MPI_File_get_group( (MPI_File) the_real_file, &(v2.the_real_group) ));
			return v2;
			}
			virtual Offset Get_position( void ) const
			{
			MPI_Offset v2;
			MPIX_CALLREF( this, MPI_File_get_position( (MPI_File) the_real_file, &v2 ));
			return v2;
			}
			static File Open( const Intracomm &v1, const char * v2, int v3, const Info &v4 )
			{
			File v5;
			MPIX_CALLOBJ( FILE_NULL, MPI_File_open( (MPI_Comm)(v1.the_real_comm), (char *)v2, v3, (MPI_Info)(v4.the_real_info), &(v5.the_real_file) ));
			return v5;
			}
			virtual void Seek( Offset v2, int v3 )
			{
			MPIX_CALLREF( this, MPI_File_seek( (MPI_File) the_real_file, v2, v3 ));
			}
			virtual void Read_all_begin( void * v2, int v3, const Datatype &v4 )
			{
			MPIX_CALLREF( this, MPI_File_read_all_begin( (MPI_File) the_real_file, v2, v3, (MPI_Datatype)(v4.the_real_datatype) ));
			}
			virtual void Read_at_all_begin( Offset v2, void * v3, int v4, const Datatype &v5 )
			{
			MPIX_CALLREF( this, MPI_File_read_at_all_begin( (MPI_File) the_real_file, v2, v3, v4, (MPI_Datatype)(v5.the_real_datatype) ));
			}
			virtual void Read_all( void * v2, int v3, const Datatype &v4, Status & v5 )
			{
			MPIX_CALLREF( this, MPI_File_read_all( (MPI_File) the_real_file, v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPI_Status *)&(v5.the_real_status ) ));
			}
			virtual void Read_all( void * v2, int v3, const Datatype &v4 )
			{
			MPIX_CALLREF( this, MPI_File_read_all( (MPI_File) the_real_file, v2, v3, (MPI_Datatype)(v4.the_real_datatype), MPI_STATUS_IGNORE ));
			}
			virtual void Preallocate( Offset v2 )
			{
			MPIX_CALLREF( this, MPI_File_preallocate( (MPI_File) the_real_file, v2 ));
			}
			virtual void Read_at_all( Offset v2, void * v3, int v4, const Datatype &v5, Status & v6 )
			{
			MPIX_CALLREF( this, MPI_File_read_at_all( (MPI_File) the_real_file, v2, v3, v4, (MPI_Datatype)(v5.the_real_datatype), (MPI_Status *)&(v6.the_real_status ) ));
			}
			virtual void Read_at_all( Offset v2, void * v3, int v4, const Datatype &v5 )
			{
			MPIX_CALLREF( this, MPI_File_read_at_all( (MPI_File) the_real_file, v2, v3, v4, (MPI_Datatype)(v5.the_real_datatype), MPI_STATUS_IGNORE ));
			}
			virtual void Read_shared( void * v2, int v3, const Datatype &v4, Status & v5 )
			{
			MPIX_CALLREF( this, MPI_File_read_shared( (MPI_File) the_real_file, v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPI_Status *)&(v5.the_real_status ) ));
			}
			virtual void Read_shared( void * v2, int v3, const Datatype &v4 )
			{
			MPIX_CALLREF( this, MPI_File_read_shared( (MPI_File) the_real_file, v2, v3, (MPI_Datatype)(v4.the_real_datatype), MPI_STATUS_IGNORE ));
			}
			virtual Request Iwrite( const void * v2, int v3, const Datatype &v4 )
			{
			Request v5;
			MPIX_CALLREF( this, MPI_File_iwrite( (MPI_File) the_real_file, (void )v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPIO_Request )&(v5.the_real_request) ));
			return v5;
			}
			virtual Request Iwrite_shared( const void * v2, int v3, const Datatype &v4 )
			{
			Request v5;
			MPIX_CALLREF( this, MPI_File_iwrite_shared( (MPI_File) the_real_file, (void )v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPIO_Request )&(v5.the_real_request) ));
			return v5;
			}
			virtual void Set_errhandler( const Errhandler &v2 )
			{
			MPIX_CALLREF( this, MPI_File_set_errhandler( (MPI_File) the_real_file, (MPI_Errhandler)(v2.the_real_errhandler) ));
			}
			virtual void Write_at_all( Offset v2, const void * v3, int v4, const Datatype &v5, Status & v6 )
			{
			MPIX_CALLREF( this, MPI_File_write_at_all( (MPI_File) the_real_file, v2, (void )v3, v4, (MPI_Datatype)(v5.the_real_datatype), (MPI_Status )&(v6.the_real_status ) ));
			}
			virtual void Write_at_all( Offset v2, const void * v3, int v4, const Datatype &v5 )
			{
			MPIX_CALLREF( this, MPI_File_write_at_all( (MPI_File) the_real_file, v2, (void *)v3, v4, (MPI_Datatype)(v5.the_real_datatype), MPI_STATUS_IGNORE ));
			}
			virtual void Set_size( Offset v2 )
			{
			MPIX_CALLREF( this, MPI_File_set_size( (MPI_File) the_real_file, v2 ));
			}
			virtual void Set_view( Offset v2, const Datatype &v3, const Datatype v4, const char * v5, const Info &v6 )
			{
			MPIX_CALLREF( this, MPI_File_set_view( (MPI_File) the_real_file, v2, (MPI_Datatype)(v3.the_real_datatype), (MPI_Datatype)v4, (char *)v5, (MPI_Info)(v6.the_real_info) ));
			}
			virtual void Read_at( Offset v2, void * v3, int v4, const Datatype &v5, Status & v6 )
			{
			MPIX_CALLREF( this, MPI_File_read_at( (MPI_File) the_real_file, v2, v3, v4, (MPI_Datatype)(v5.the_real_datatype), (MPI_Status *)&(v6.the_real_status ) ));
			}
			virtual void Read_at( Offset v2, void * v3, int v4, const Datatype &v5 )
			{
			MPIX_CALLREF( this, MPI_File_read_at( (MPI_File) the_real_file, v2, v3, v4, (MPI_Datatype)(v5.the_real_datatype), MPI_STATUS_IGNORE ));
			}
			virtual void Close( void )
			{
			MPIX_CALLREF( this, MPI_File_close( (MPI_File *) &the_real_file ));
			}
			virtual void Write_ordered_end( const void * v2, Status & v3 )
			{
			MPIX_CALLREF( this, MPI_File_write_ordered_end( (MPI_File) the_real_file, (void )v2, (MPI_Status )&(v3.the_real_status ) ));
			}
			virtual void Write_ordered_end( const void * v2 )
			{
			MPIX_CALLREF( this, MPI_File_write_ordered_end( (MPI_File) the_real_file, (void *)v2, MPI_STATUS_IGNORE ));
			}
			virtual void Write( const void * v2, int v3, const Datatype &v4, Status & v5 )
			{
			MPIX_CALLREF( this, MPI_File_write( (MPI_File) the_real_file, (void )v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPI_Status )&(v5.the_real_status ) ));
			}
			virtual void Write( const void * v2, int v3, const Datatype &v4 )
			{
			MPIX_CALLREF( this, MPI_File_write( (MPI_File) the_real_file, (void *)v2, v3, (MPI_Datatype)(v4.the_real_datatype), MPI_STATUS_IGNORE ));
			}
			virtual bool Get_atomicity( void ) const
			{
			int v2;
			MPIX_CALLREF( this, MPI_File_get_atomicity( (MPI_File) the_real_file, &v2 ));
			return v2!= 0;
			}
			typedef void Errhandler_function(File &, int *, ... );
			typedef Errhandler_function Errhandler_fn;

			static Errhandler Create_errhandler( Errhandler_function * );

			#endif
			};

			class Graphcomm : public Intracomm {

			public:
			// new/delete

			inline Graphcomm(MPI_Comm obj) : Intracomm(obj) {}
			inline Graphcomm(void) : Intracomm() {}

			virtual ~Graphcomm() {}
			// copy/assignment

			Graphcomm(const Graphcomm &obj) : Intracomm(obj) {}

			Graphcomm& operator=(const Graphcomm &obj) {
			the_real_comm = obj.the_real_comm; return *this; }

			// C/C++ cast and assignment
			inline operator MPI_Comm*() { return &the_real_comm; }
			inline operator MPI_Comm() const { return the_real_comm; }
			Graphcomm& operator=(const MPI_Comm& obj) {
			the_real_comm = obj; return *this; }
			virtual void Get_dims( int * v2, int * v3 ) const
			{
			MPIX_CALLREF( this, MPI_Graphdims_get( (MPI_Comm) the_real_comm, v2, v3 ));
			}
			virtual void Get_topo( int v2, int v3, int * v4, int * v5 ) const
			{
			MPIX_CALLREF( this, MPI_Graph_get( (MPI_Comm) the_real_comm, v2, v3, v4, v5 ));
			}
			virtual int Map( int v2, const int * v3, const int * v4 ) const
			{
			int v5;
			MPIX_CALLREF( this, MPI_Graph_map( (MPI_Comm) the_real_comm, v2, (int )v3, (int )v4, &v5 ));
			return v5;
			}
			virtual void Get_neighbors( int v2, int v3, int * v4 ) const
			{
			MPIX_CALLREF( this, MPI_Graph_neighbors( (MPI_Comm) the_real_comm, v2, v3, v4 ));
			}
			virtual int Get_neighbors_count( int v2 ) const
			{
			int v3;
			MPIX_CALLREF( this, MPI_Graph_neighbors_count( (MPI_Comm) the_real_comm, v2, &v3 ));
			return v3;
			}
			Graphcomm Dup( void ) const
			{
			Graphcomm v2;
			MPIX_CALLREF( this, MPI_Comm_dup( (MPI_Comm) the_real_comm, &(v2.the_real_comm) ));
			return v2;
			}

			// If the compiler does not support variable return types, return a
			// reference to Comm. The user must then cast this to the correct type
			// (Standard-conforming C++ compilers support variable return types)
			#ifdef HAVE_NO_VARIABLE_RETURN_TYPE_SUPPORT
			virtual Comm & Clone(void) const {
			MPI_Comm ncomm;
			MPI_Comm_dup( (MPI_Comm)the_real_comm, &ncomm);
			Comm *clone = new Graphcomm(ncomm);
			return *clone;
			};
			#else
			virtual Graphcomm & Clone(void) const {
			MPI_Comm ncomm;
			MPI_Comm_dup( (MPI_Comm)the_real_comm, &ncomm);
			Graphcomm *clone = new Graphcomm(ncomm);
			return *clone;
			};
			#endif
			};

			class Cartcomm : public Intracomm {

			public:
			// new/delete

			inline Cartcomm(MPI_Comm obj) : Intracomm(obj) {}
			inline Cartcomm(void) : Intracomm() {}

			virtual ~Cartcomm() {}
			// copy/assignment

			Cartcomm(const Cartcomm &obj) : Intracomm(obj) {}

			Cartcomm& operator=(const Cartcomm &obj) {
			the_real_comm = obj.the_real_comm; return *this; }

			// C/C++ cast and assignment
			inline operator MPI_Comm*() { return &the_real_comm; }
			inline operator MPI_Comm() const { return the_real_comm; }
			Cartcomm& operator=(const MPI_Comm& obj) {
			the_real_comm = obj; return *this; }
			virtual void Get_coords( int v2, int v3, int * v4 ) const
			{
			MPIX_CALLREF( this, MPI_Cart_coords( (MPI_Comm) the_real_comm, v2, v3, v4 ));
			}
			virtual int Get_cart_rank( const int * v2 ) const
			{
			int v3;
			MPIX_CALLREF( this, MPI_Cart_rank( (MPI_Comm) the_real_comm, (int *)v2, &v3 ));
			return v3;
			}
			virtual int Get_dim( void ) const
			{
			int v2;
			MPIX_CALLREF( this, MPI_Cartdim_get( (MPI_Comm) the_real_comm, &v2 ));
			return v2;
			}
			virtual void Get_topo( int v2, int * v3, bool v4[], int * v5 ) const
			{
			int *l4 = new int[v2];
			MPIX_CALLREF( this, MPI_Cart_get( (MPI_Comm) the_real_comm, v2, v3, l4, v5 ));
			{
			int i4;
			for (i4=0;i4<v2;i4++) {
			// Unfortunately, at least one C++ compiler (Microsoft's)
			// generates warning messages when the type size changes
			// even when an explicit cast is used. To avoid these messages, we
			// cause the generated code to explicitly compute a
			// boolean value
			v4[i4] = l4[i4] != 0;
			}
			delete[] l4;
			}
			}
			virtual int Map( int v2, const int * v3, const bool v4[] ) const
			{
			int v5;
			int *l4 = new int[v2];
			{
			int i4;
			for (i4=0;i4<v2;i4++) {
			l4[i4] = v4[i4] == true ? 1 : 0;
			}
			}
			MPIX_CALLREF( this, MPI_Cart_map( (MPI_Comm) the_real_comm, v2, (int *)v3, l4, &v5 ));

			delete[] l4;
			return v5;
			}
			virtual Cartcomm Sub( const bool v2[] ) const
			{
			Cartcomm v3;
			int *l2 = new int[10];
			{
			int i2;
			for (i2=0;i2<10;i2++) {
			l2[i2] = v2[i2] == true ? 1 : 0;
			}
			}
			MPIX_CALLREF( this, MPI_Cart_sub( (MPI_Comm) the_real_comm, l2, &(v3.the_real_comm) ));

			delete[] l2;
			return v3;
			}
			virtual void Shift( int v2, int v3, int &v4, int &v5 ) const
			{
			MPIX_CALLREF( this, MPI_Cart_shift( (MPI_Comm) the_real_comm, v2, v3, &v4, &v5 ));
			}
			Cartcomm Dup( void ) const
			{
			Cartcomm v2;
			MPIX_CALLREF( this, MPI_Comm_dup( (MPI_Comm) the_real_comm, &(v2.the_real_comm) ));
			return v2;
			}

			// If the compiler does not support variable return types, return a
			// reference to Comm. The user must then cast this to the correct type
			// (Standard-conforming C++ compilers support variable return types)
			#ifdef HAVE_NO_VARIABLE_RETURN_TYPE_SUPPORT
			virtual Comm & Clone(void) const {
			MPI_Comm ncomm;
			MPI_Comm_dup( (MPI_Comm)the_real_comm, &ncomm);
			Comm *clone = new Cartcomm(ncomm);
			return *clone;
			};
			#else
			virtual Cartcomm & Clone(void) const {
			MPI_Comm ncomm;
			MPI_Comm_dup( (MPI_Comm)the_real_comm, &ncomm);
			Cartcomm *clone = new Cartcomm(ncomm);
			return *clone;
			};
			#endif
			};
			extern int Add_error_class( void ) ;
			extern void* Alloc_mem( Aint v1, const Info &v2 ) ;
			extern void Lookup_name( const char * v1, const Info &v2, char * v3 ) ;
			extern void Publish_name( const char * v1, const Info &v2, const char * v3 ) ;
			extern void Unpublish_name( const char * v1, const Info &v2, const char * v3 ) ;
			extern Aint Get_address( void * v1 ) ;
			extern void Add_error_string( int v1, const char * v2 ) ;
			extern int Query_thread( void ) ;
			extern void Close_port( const char * v1 ) ;
			extern int Add_error_code( int v1 ) ;
			extern void Free_mem( void * v1 ) ;
			extern void Open_port( const Info &v1, char * v2 ) ;
			extern bool Is_finalized( void ) ;
			extern bool Is_thread_main( void ) ;

			#ifdef MPI_MODE_RDONLY
			typedef int Datarep_extent_function( const Datatype&, Aint&, void *);
			typedef int Datarep_conversion_function( void , Datatype &, int, void ,
			Offset, void * );
			#endif


			extern Datatype CHAR;
			extern Datatype UNSIGNED_CHAR;
			extern Datatype BYTE;
			extern Datatype SHORT;
			extern Datatype UNSIGNED_SHORT;
			extern Datatype INT;
			extern Datatype UNSIGNED;
			extern Datatype LONG;
			extern Datatype UNSIGNED_LONG;
			extern Datatype FLOAT;
			extern Datatype DOUBLE;
			extern Datatype LONG_DOUBLE;
			extern Datatype LONG_LONG_INT;
			extern Datatype LONG_LONG;
			extern Datatype PACKED;
			extern Datatype LB;
			extern Datatype UB;
			extern Datatype FLOAT_INT;
			extern Datatype DOUBLE_INT;
			extern Datatype LONG_INT;
			extern Datatype SHORT_INT;
			extern Datatype LONG_DOUBLE_INT;
			extern Datatype REAL4;
			extern Datatype REAL8;
			extern Datatype REAL16;
			extern Datatype COMPLEX8;
			extern Datatype COMPLEX16;
			extern Datatype COMPLEX32;
			extern Datatype INTEGER1;
			extern Datatype INTEGER2;
			extern Datatype INTEGER4;
			extern Datatype INTEGER8;
			extern Datatype INTEGER16;
			extern Datatype WCHAR;
			extern Datatype SIGNED_CHAR;
			extern Datatype UNSIGNED_LONG_LONG;
			extern Datatype TWOINT;
			extern Datatype BOOL;
			#define MPIR_CXX_BOOL 0x4c000133
			extern Datatype COMPLEX;
			#define MPIR_CXX_COMPLEX 0x4c000834
			extern Datatype DOUBLE_COMPLEX;
			#define MPIR_CXX_DOUBLE_COMPLEX 0x4c001035
			extern Datatype LONG_DOUBLE_COMPLEX;
			#define MPIR_CXX_LONG_DOUBLE_COMPLEX 0x4c001036
			extern Datatype DATATYPE_NULL;

			#if 1
			extern Datatype INTEGER;
			extern Datatype REAL;
			extern Datatype DOUBLE_PRECISION;
			extern Datatype F_COMPLEX;
			extern Datatype F_DOUBLE_COMPLEX;
			extern Datatype LOGICAL;
			extern Datatype CHARACTER;
			extern Datatype TWOREAL;
			extern Datatype TWODOUBLE_PRECISION;
			extern Datatype TWOINTEGER;
			#endif
			extern const Op MAX;
			extern const Op MIN;
			extern const Op SUM;
			extern const Op PROD;
			extern const Op LAND;
			extern const Op BAND;
			extern const Op LOR;
			extern const Op BOR;
			extern const Op LXOR;
			extern const Op BXOR;
			extern const Op MINLOC;
			extern const Op MAXLOC;
			extern const Op REPLACE;
			extern const Op OP_NULL;
			extern Intracomm COMM_SELF;
			extern const Group GROUP_EMPTY;
			extern const Nullcomm COMM_NULL;
			extern const Group GROUP_NULL;
			extern const Request REQUEST_NULL;
			extern const Errhandler ERRHANDLER_NULL;
			extern const Errhandler ERRORS_RETURN;
			extern const Errhandler ERRORS_ARE_FATAL;
			extern const Errhandler ERRORS_THROW_EXCEPTIONS;
			extern const Info INFO_NULL;
			extern const Win WIN_NULL;
			extern const int BSEND_OVERHEAD;
			extern const int KEYVAL_INVALID;
			extern const int CART;
			extern const int GRAPH;
			extern const int IDENT;
			extern const int SIMILAR;
			extern const int CONGRUENT;
			extern const int UNEQUAL;
			extern const int PROC_NULL;
			extern const int ANY_TAG;
			extern const int ANY_SOURCE;
			extern const int ROOT;
			extern const int TAG_UB;
			extern const int IO;
			extern const int HOST;
			extern const int WTIME_IS_GLOBAL;
			extern const int UNIVERSE_SIZE;
			extern const int LASTUSEDCODE;
			extern const int APPNUM;
			extern const int MAX_PROCESSOR_NAME;
			extern const int MAX_ERROR_STRING;
			extern const int MAX_PORT_NAME;
			extern const int MAX_OBJECT_NAME;
			extern const int MAX_INFO_VAL;
			extern const int MAX_INFO_KEY;
			extern const int UNDEFINED;
			extern const int LOCK_EXCLUSIVE;
			extern const int LOCK_SHARED;
			extern const int WIN_BASE;
			extern const int WIN_DISP_UNIT;
			extern const int WIN_SIZE;
			extern const int SUCCESS;
			extern const int ERR_BUFFER;
			extern const int ERR_COUNT;
			extern const int ERR_TYPE;
			extern const int ERR_TAG;
			extern const int ERR_COMM;
			extern const int ERR_RANK;
			extern const int ERR_REQUEST;
			extern const int ERR_ROOT;
			extern const int ERR_GROUP;
			extern const int ERR_OP;
			extern const int ERR_TOPOLOGY;
			extern const int ERR_DIMS;
			extern const int ERR_ARG;
			extern const int ERR_UNKNOWN;
			extern const int ERR_TRUNCATE;
			extern const int ERR_OTHER;
			extern const int ERR_INTERN;
			extern const int ERR_PENDING;
			extern const int ERR_IN_STATUS;
			extern const int ERR_LASTCODE;
			extern const int ERR_FILE;
			extern const int ERR_ACCESS;
			extern const int ERR_AMODE;
			extern const int ERR_BAD_FILE;
			extern const int ERR_FILE_EXISTS;
			extern const int ERR_FILE_IN_USE;
			extern const int ERR_NO_SPACE;
			extern const int ERR_NO_SUCH_FILE;
			extern const int ERR_IO;
			extern const int ERR_READ_ONLY;
			extern const int ERR_CONVERSION;
			extern const int ERR_DUP_DATAREP;
			extern const int ERR_UNSUPPORTED_DATAREP;
			extern const int ERR_INFO;
			extern const int ERR_INFO_KEY;
			extern const int ERR_INFO_VALUE;
			extern const int ERR_INFO_NOKEY;
			extern const int ERR_NAME;
			extern const int ERR_NO_MEM;
			extern const int ERR_NOT_SAME;
			extern const int ERR_PORT;
			extern const int ERR_QUOTA;
			extern const int ERR_SERVICE;
			extern const int ERR_SPAWN;
			extern const int ERR_UNSUPPORTED_OPERATION;
			extern const int ERR_WIN;
			extern const int ERR_BASE;
			extern const int ERR_LOCKTYPE;
			extern const int ERR_KEYVAL;
			extern const int ERR_RMA_CONFLICT;
			extern const int ERR_RMA_SYNC;
			extern const int ERR_SIZE;
			extern const int ERR_DISP;
			extern const int ERR_ASSERT;
			extern const int TYPECLASS_REAL;
			extern const int TYPECLASS_INTEGER;
			extern const int TYPECLASS_COMPLEX;
			#if defined(MPI_SEEK_SET) && !defined(MPICH_IGNORE_CXX_SEEK) && !defined(SEEK_SET)
			extern const int SEEK_SET;
			extern const int SEEK_END;
			extern const int SEEK_CUR;
			#endif
			extern const int DISTRIBUTE_BLOCK;
			extern const int DISTRIBUTE_CYCLIC;
			extern const int DISTRIBUTE_DFLT_DARG;
			extern const int DISTRIBUTE_NONE;
			extern const int ORDER_C;
			extern const int ORDER_FORTRAN;
			// Include these only if MPI-IO is available
			#ifdef MPI_MODE_RDONLY
			extern const int MAX_DATAREP_STRING;
			extern const MPI_Offset DISPLACEMENT_CURRENT;
			extern const int MODE_APPEND;
			extern const int MODE_CREATE;
			extern const int MODE_DELETE_ON_CLOSE;
			extern const int MODE_EXCL;
			extern const int MODE_RDONLY;
			extern const int MODE_RDWR;
			extern const int MODE_SEQUENTIAL;
			extern const int MODE_UNIQUE_OPEN;
			extern const int MODE_WRONLY;
			#endif // IO
			extern const int MODE_NOCHECK;
			extern const int MODE_NOPRECEDE;
			extern const int MODE_NOPUT;
			extern const int MODE_NOSTORE;
			extern const int MODE_NOSUCCEED;
			extern const int COMBINER_CONTIGUOUS;
			extern const int COMBINER_DARRAY;
			extern const int COMBINER_DUP;
			extern const int COMBINER_F90_COMPLEX;
			extern const int COMBINER_F90_INTEGER;
			extern const int COMBINER_F90_REAL;
			extern const int COMBINER_HINDEXED_INTEGER;
			extern const int COMBINER_HINDEXED;
			extern const int COMBINER_HVECTOR_INTEGER;
			extern const int COMBINER_HVECTOR;
			extern const int COMBINER_INDEXED_BLOCK;
			extern const int COMBINER_INDEXED;
			extern const int COMBINER_NAMED;
			extern const int COMBINER_RESIZED;
			extern const int COMBINER_STRUCT_INTEGER;
			extern const int COMBINER_STRUCT;
			extern const int COMBINER_SUBARRAY;
			extern const int COMBINER_VECTOR;
			extern const int THREAD_FUNNELED;
			extern const int THREAD_MULTIPLE;
			extern const int THREAD_SERIALIZED;
			extern const int THREAD_SINGLE;
			extern const char ** const ARGV_NULL;
			extern const char *** const ARGVS_NULL;
			extern void * const BOTTOM;
			extern void * const IN_PLACE;
			extern void Init(void);
			extern void Init(int &, char **& );
			extern int Init_thread(int);
			extern int Init_thread(int &, char **&, int );
			extern double Wtime(void);
			extern double Wtick(void);
			} // namespace MPI

lammps/tools/mingw-cross/mpich2-win64/include/mpicxx.h
ee8dcb331ac4efficient_neuronet

mpicxx.h
View Options

lammps/tools/mingw-cross/mpich2-win64/include/mpicxx.hee8dcb331ac4efficient_neuronet

mpicxx.hView Options

lammps/tools/mingw-cross/mpich2-win64/include/mpicxx.h
ee8dcb331ac4efficient_neuronet

mpicxx.h
View Options