impi-devel 2021.17.1__py2.py3-none-manylinux_2_28_x86_64.whl

impi_devel-2021.17.1.data/data/include/mpicxx.h

@@ -0,0 +1,2796 @@
+/*
+    Copyright Intel Corporation.
+    
+    This software and the related documents are Intel copyrighted materials, and
+    your use of them is governed by the express license under which they were
+    provided to you (License). Unless the License provides otherwise, you may
+    not use, modify, copy, publish, distribute, disclose or transmit this
+    software or the related documents without Intel's prior written permission.
+    
+    This software and the related documents are provided as is, with no express
+    or implied warranties, other than those that are expressly stated in the
+    License.
+*/
+/*
+ * Copyright (C) by Argonne National Laboratory
+    
+    				  COPYRIGHT
+    
+    The following is a notice of limited availability of the code, and disclaimer
+    which must be included in the prologue of the code and in all source listings
+    of the code.
+    
+    Copyright Notice
+    1998--2020, Argonne National Laboratory
+    
+    Permission is hereby granted to use, reproduce, prepare derivative works, and
+    to redistribute to others.  This software was authored by:
+    
+    Mathematics and Computer Science Division
+    Argonne National Laboratory, Argonne IL 60439
+    
+    (and)
+    
+    Department of Computer Science
+    University of Illinois at Urbana-Champaign
+    
+    
+    			      GOVERNMENT LICENSE
+    
+    Portions of this material resulted from work developed under a U.S.
+    Government Contract and are subject to the following license: the Government
+    is granted for itself and others acting on its behalf a paid-up, nonexclusive,
+    irrevocable worldwide license in this computer software to reproduce, prepare
+    derivative works, and perform publicly and display publicly.
+    
+    				  DISCLAIMER
+    
+    This computer code material was prepared, in part, as an account of work
+    sponsored by an agency of the United States Government.  Neither the United
+    States, nor the University of Chicago, nor any of their employees, makes any
+    warranty express or implied, or assumes any legal liability or responsibility
+    for the accuracy, completeness, or usefulness of any information, apparatus,
+    product, or process disclosed, or represents that its use would not infringe
+    privately owned rights.
+    
+    			   EXTERNAL CONTRIBUTIONS
+    
+    Portions of this code have been contributed under the above license by:
+    
+     * Intel Corporation
+     * Cray
+     * IBM Corporation
+     * Microsoft Corporation
+     * Mellanox Technologies Ltd.
+     * DataDirect Networks.
+     * Oak Ridge National Laboratory
+     * Sun Microsystems, Lustre group
+     * Dolphin Interconnect Solutions Inc.
+     * Institut Polytechnique de Bordeaux
+ *     
+ *
+ * This file is automatically generated by buildiface -nosep -initfile=./cxx.vlist
+ * DO NOT EDIT
+ */
+/* style: c++ header */
+
+#ifdef MPI
+#error "You cannot define MPI; that name is reserved for the MPI namespace"
+#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, (const int  *)v2, (const 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[], Aint v3[],  const Datatype v4[] ) 
+    {
+        Datatype v5;
+        MPI_Datatype *l4 = new MPI_Datatype[(unsigned long)v1];
+        { 
+            int i4; 
+            for (i4=0;i4<v1;i4++) {
+                l4[i4] = v4[i4].the_real_datatype;
+            }
+        }
+        MPIX_CALLWORLD( MPI_Type_create_struct( v1, (const int  *)v2, (const 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, (const int  *)v3, (MPI_Datatype) the_real_datatype, &(v5.the_real_datatype) ));
+        return v5;
+    }
+    virtual Aint Pack_external_size( const char * v1, int v2 ) const
+    {
+        MPI_Aint v4;
+        MPIX_CALLWORLD( MPI_Pack_external_size( v1, 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, (const int  *)v2, (const 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, (const int  *)v4, (const int  *)v5, (const int  *)v6, (const 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[], Aint v6[], Datatype v7[] ) const
+    {
+        MPI_Datatype *l7 = new MPI_Datatype[(unsigned long)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, (const 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, const int v2[], const int v3[], const int v4[], const int v5 ) const
+    {
+        Datatype v7;
+        MPIX_CALLWORLD( MPI_Type_create_subarray( v1, v2, (const int  *)v3, (const int  *)v4, (int)v5, (MPI_Datatype) the_real_datatype, &(v7.the_real_datatype) ));
+        return v7;
+    }
+    virtual void Unpack_external( const char v1[], const void * v2, const Aint v3, Aint & v4, void * v5, int v6 ) const
+    {
+        MPIX_CALLWORLD( MPI_Unpack_external( v1, (const 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[(unsigned long)v1];
+        { 
+            int i4; 
+            for (i4=0;i4<v1;i4++) {
+                l4[i4] = v4[i4].the_real_datatype;
+            }
+        }
+        MPIX_CALLWORLD( MPI_Type_create_struct( v1, (const int  *)v2, (const 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( const char * v1, const void * v2, const int v3, void * v5, Aint v6, Aint & v7 ) const
+    {
+        MPIX_CALLWORLD( MPI_Pack_external( v1, (const 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 MPIR_ARGUNUSED, 
+        int keyval MPIR_ARGUNUSED, void *ex MPIR_ARGUNUSED,
+        void *attr_in MPIR_ARGUNUSED, void *attr_out MPIR_ARGUNUSED, 
+        bool &flag ) { flag = 1; return 0;}
+    static int NULL_DELETE_FN( Datatype &type MPIR_ARGUNUSED, 
+        int keyval MPIR_ARGUNUSED, void * attr MPIR_ARGUNUSED, 
+        void *ex MPIR_ARGUNUSED ) { return 0; }
+    static int DUP_FN( const Datatype &oldtype MPIR_ARGUNUSED, 
+        int keyval MPIR_ARGUNUSED, void *ex MPIR_ARGUNUSED,
+        void *attr_in, void *attr_out, bool &flag ) { 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, (const 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, (const char *)v2, (const 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, (const 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, (const 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( (const MPI_Status *) &the_real_status, &v2 ));
+        return v2!= 0;
+    }
+    virtual int Get_elements( const Datatype &v2 ) const
+    {
+        int v3;
+        MPIX_CALLWORLD( MPI_Get_elements( (const 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( (const 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, (const 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, (const 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, (const 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 ) const
+    {
+        int v2;
+        MPIX_CALLWORLD( MPI_Op_commutative( (MPI_Op) the_real_op, &v2 ));
+        return v2!= 0;
+    }
+    virtual void Reduce_local( const void * v1, void * v2, int v3, const Datatype &v4 ) const
+    {
+        MPIX_CALLWORLD( MPI_Reduce_local( (const void *)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[(unsigned long)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[(unsigned long)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[(unsigned long)v1];
+        MPI_Status *l5 = new MPI_Status[(unsigned long)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[(unsigned long)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[(unsigned long)v1];
+        MPI_Status *l4 = new MPI_Status[(unsigned long)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[(unsigned long)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[(unsigned long)v1];
+        MPI_Status *l5 = new MPI_Status[(unsigned long)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[(unsigned long)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[(unsigned long)v1];
+        MPI_Status *l3 = new MPI_Status[(unsigned long)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[(unsigned long)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[(unsigned long)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[(unsigned long)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[(unsigned long)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( (const 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( (const 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( (const 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( (const 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( (const 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( (const 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( (const 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( (const 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( (const 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( (const 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( (const 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( (const 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( (const 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( (const void *)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (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( (const void *)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, (const int  *)v5, (const 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( (const 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[(unsigned long)Get_size()];
+        MPI_Datatype *l8 = new MPI_Datatype[(unsigned long)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( (const void *)v1, (const int  *)v2, (const int  *)v3, l4, v5, (const int  *)v6, (const 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( (const 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, (const 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( (const void *)v1, (const int  *)v2, (const int  *)v3, (MPI_Datatype)(v4.the_real_datatype), v5, (const int  *)v6, (const int  *)v7, (MPI_Datatype)(v8.the_real_datatype), (MPI_Comm) the_real_comm ));
+    }
+    virtual void Reduce_scatter( const void * v1, void * v2, const int v3[], const Datatype &v4, const Op &v5 ) const
+    {
+        MPIX_CALLREF( this, MPI_Reduce_scatter( (const 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( (const 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 Gather( const void * v1, int v2, const Datatype &v3, void * v4, int v5, const Datatype &v6, int v7 ) const
+    {
+        MPIX_CALLREF( this, MPI_Gather( (const 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( (const 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( (const 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( (const void *)v1, (const int  *)v2, (const 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( (const void *)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, (const int  *)v5, (const 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 MPIR_ARGUNUSED, 
+           int keyval MPIR_ARGUNUSED, void *ex MPIR_ARGUNUSED,
+           void *attr_in MPIR_ARGUNUSED, void *attr_out MPIR_ARGUNUSED, 
+	   bool &flag ) { flag = 0; return 0;}
+    static int NULL_DELETE_FN( Comm &comm MPIR_ARGUNUSED, 
+	   int keyval MPIR_ARGUNUSED, void * attr MPIR_ARGUNUSED, 
+	   void *ex MPIR_ARGUNUSED ) { return 0; }
+    static int DUP_FN( const Comm &oldcomm MPIR_ARGUNUSED, 
+           int keyval MPIR_ARGUNUSED, void *ex MPIR_ARGUNUSED,
+           void *attr_in, void *attr_out, bool &flag ) { flag = 1; 
+                    *(void **)attr_out = attr_in; return 0;} 
+    static Errhandler Create_errhandler( Errhandler_function * );
+
+    virtual void Call_errhandler( int v2 ) const;
+    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( (const void *)v1, v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPI_Op)(v5.the_real_op), (MPI_Comm) the_real_comm ));
+    }
+};
+
+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( (const 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( (const 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( (const 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( (const 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 [(unsigned long)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 [(unsigned long)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( (const 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, (const 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( (const 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;
+    }
+    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 MPIR_ARGUNUSED, 
+        int keyval MPIR_ARGUNUSED, void *ex MPIR_ARGUNUSED,
+        void *attr_in MPIR_ARGUNUSED, void *attr_out MPIR_ARGUNUSED, 
+        bool &flag ) { flag = 1; return 0;}
+    static int NULL_DELETE_FN( Win &win MPIR_ARGUNUSED, 
+        int keyval MPIR_ARGUNUSED, void * attr MPIR_ARGUNUSED, 
+        void *ex MPIR_ARGUNUSED ) { return 0; }
+    static int DUP_FN( const Win &oldwin MPIR_ARGUNUSED, 
+	int keyval MPIR_ARGUNUSED, void *ex MPIR_ARGUNUSED,
+        void *attr_in, void *attr_out, bool &flag ) { flag = 1; 
+            *(void **)attr_out = attr_in; return 0;} 
+
+    virtual void Call_errhandler( int v2 ) const;
+};
+#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, (const 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, (const 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, (const 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, (const 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, (const 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, (const 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, (const void *)v2, MPI_STATUS_IGNORE ));
+    }
+    static void Delete( const char * v1, const Info &v2 ) 
+    {
+        MPIX_CALLOBJ( FILE_NULL, MPI_File_delete( (const 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, (const 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, (const 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, (const 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, (const 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, (const 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 Write_all_begin( const void * v2, int v3, const Datatype &v4 ) 
+    {
+        MPIX_CALLREF( this, MPI_File_write_all_begin( (MPI_File) the_real_file, (const 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, (const 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, (const 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, (const 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), (const 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, (const 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, (const 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, (const 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, (const 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, (const 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, (const 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, (const 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, (const 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, (const 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 * );
+
+    virtual void Call_errhandler( int v2 ) const;
+#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, (const int  *)v3, (const 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, (const 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;
+    }
+    Cartcomm Dup( void ) const
+    {
+        Cartcomm v2;
+        MPIX_CALLREF( this, MPI_Comm_dup( (MPI_Comm) the_real_comm, &(v2.the_real_comm) ));
+        return v2;
+    }
+    virtual void Get_topo( int v2, int v3[], bool v4[], int v5[] ) const
+    {
+        int *l4 = new int[(unsigned long)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[(unsigned long)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, (const int  *)v3, l4, &v5 ));
+
+            delete[] l4;
+        return v5;
+    }
+    virtual Cartcomm Sub( const bool v2[] ) const
+    {
+        Cartcomm v3;
+        int *l2 = new int[(unsigned long)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 ));
+    }
+    
+// 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( const 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 0x4c002036
+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 COMM_TYPE_SHARED;
+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 COMBINER_HINDEXED_BLOCK;
+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